`Class.StarterGui` is a container object designed to hold
`Class.LayerCollector` objects such as `Class.ScreenGui|ScreenGuis`.

When a `Class.Player.Character` spawns, the contents of their
`Class.PlayerGui` (if any) are emptied. Children of the `Class.StarterGui` are
then copied along with their descendants into the `Class.PlayerGui`. Note,
however, that `Class.LayerCollector` objects such as
`Class.ScreenGui|ScreenGuis` with their
`Class.LayerCollector.ResetOnSpawn|ResetOnSpawn` property set to `false` will
only be placed into each player's `Class.PlayerGui` once and will not be
deleted when the `Class.Player` respawns.

`Class.StarterGui` also includes a range of functions allowing you to interact
with the `Class.CoreGui`. For example `Class.StarterGui:SetCoreGuiEnabled()`
can be used to disable elements of the `Class.CoreGui`, and
`Class.StarterGui:SetCore()` can perform a range of functions including
creating notifications and system messages.


This method returns data set or made available by Roblox's core scripts.
The first and only parameter is a string that selects the information to
be fetched. The following sections describe the strings and the data they
return by this function.

Calling this method may yield. Many of these also register an equivalent
`Class.StarterGui:SetCore()|SetCore()` function (these are marked with an
asterisk).

##### PointsNotificationsActive \*

Returns `true` if player point notifications are enabled.

##### BadgesNotificationsActive \*

Returns `true` if badge notifications are enabled.

##### AvatarContextMenuEnabled \*

Returns `true` if the
[Avatar Context Menu](/players/avatar-context-menu) is enabled.

##### ChatActive \*

Returns whether the chat is active or not. This is indicated by the
selection state of the top bar's chat icon.

##### ChatWindowSize \*

Returns the size of the chat window as a `Datatype.UDim2`.

##### ChatWindowPosition \*

Returns the size of the chat window as a `Datatype.UDim2`.

##### ChatBarDisabled \*

Returns `true` if the chat bar is disabled.

##### GetBlockedUserIds

Returns a list of `Class.Player.UserId|UserIds` associated with users that
have been blocked by the local player.

##### PlayerBlockedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is blocked
by the local player.

##### PlayerUnblockedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is
unblocked by the local player.

##### PlayerMutedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is muted
by the local player.

##### PlayerUnmutedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is unmuted
by the local player.

##### PlayerFriendedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is
connected by the local player.

##### PlayerUnfriendedEvent

Returns a `Class.BindableEvent` that is fired whenever a player is
unconnected by the local player.

##### DevConsoleVisible \*

Returns `true` if the
[Developer Console](/studio/developer-console) is visible.

##### VRRotationIntensity

Returns a string describing the camera rotation sensitivity in VR: `Low`,
`High` and `Smooth`. This will not be available unless
`Class.VRService.VREnabled` is `true`.


StarterGui:GetCore

parameterName

Returns a variable that has been specified by a Roblox core script.


The below example would print whether or not the player list is visible to the
LocalPlayer.


This function returns whether the given `Enum.CoreGuiType`is enabled, or
if it has been disabled using `Class.StarterGui:SetCoreGuiEnabled()`. This
function should be called on the client.

Note that setting `"TopbarEnabled"` to `false` using
`Class.StarterGui:SetCore()|SetCore()` hides all
`Enum.CoreGuiType|CoreGuiTypes` but does not affect the result of this
function.


StarterGui:GetCoreGuiEnabled

coreGuiType

Whether the given `Enum.CoreGuiType` is enabled.


Returns whether the given `Enum.CoreGuiType`is enabled, or if it has been
disabled using `Class.StarterGui:SetCoreGuiEnabled()`.


This method (not to be confused with
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled()`) exposes a
variety of functionality defined by Roblox's core scripts, such as sending
notifications, toggling notifications for badges/points, defining a
callback for the reset button, or toggling the topbar.

The first parameter is a string that selects the functionality with which
the call will interact. It may be necessary to call this method multiple
times using `Global.LuaGlobals.pcall()` in case the respective core script
has not yet loaded (or if it has been disabled entirely).

The following table describes the strings that may be accepted as the
first parameter. The parameters that should follow are dependent on the
functionality that will be used and are described in sub-tables.

##### ChatActive

Controls whether the chat is active.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>	
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether the chat should be made active.</td>
  </tr>
  </tbody>
</table>

##### PointsNotificationsActive

Controls whether notifications for earned player points will appear.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether notifications for earned player points will appear.</td>
  </tr>
  </tbody>
</table>

##### BadgesNotificationsActive

Controls whether notifications for earned badges will appear.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>active</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether notifications for earned badges
will appear.</td>
  </tr>
  </tbody>
</table>

##### ResetButtonCallback

Determines the behavior, if any, of the reset button given a boolean or a
`Class.BindableEvent` to be fired when a player requests to reset.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
		</thead>
    <tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether the reset button retains its default behavior.</td>
  </tr>
	<tr>
    <td colspan="4"><b>OR</b></td>
  </tr>
	<tr>
    <td><code>callback</code></td>
    <td><code>Class.BindableEvent</code></td>
    <td>(required)</td>
    <td>A <code>Class.BindableEvent</code> to be fired when the player confirms they want to reset.</td>
  </tr>
  </tbody>
</table>

##### ChatMakeSystemMessage

Display a formatted message in the chat. Using this method requires the
experience's `Class.TextChatService.ChatVersion` to be set to
`Enum.ChatVersion|LegacyChatService`, although legacy chat is
**deprecated** and usage is discouraged. For experiences using the current
`Class.TextChatService`, refer to
`Class.TextChannel:DisplaySystemMessage()`.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
      </tr>
	</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dictionary</td>
    <td>(required)</td>
    <td>A dictionary of information describing the message (see below).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(required)</td>
    <td>The message to display.</td>
  </tr>
	<tr>
    <td><code>Color</code></td>
    <td><code>Datatype.Color3</code></td>
    <td><code>Datatype.Color3.fromRGB(255, 255, 243)</code></td>
    <td>Text color of the message.</td>
  </tr>
	<tr>
    <td><code>Font</code></td>
    <td><code>Enum.Font</code></td>
    <td><code>SourceSansBold</code></td>
    <td>Font of the message.</td>
  </tr>
	<tr>
    <td><code>TextSize</code></td>
    <td>integer</td>
    <td><code>18</code></td>
    <td>Text size of the message.</td>
  </tr>
  </tbody>
</table>

##### SendNotification

Causes a non-intrusive notification to appear at the bottom right of the
screen. The notification may have up to two buttons.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
  <tbody>
	<tr>
    <td><code>configTable</code></td>
    <td>dictionary</td>
    <td>(required)</td>
    <td>A dictionary of information describing the notification (see below).</td>
  </tr>
  </tbody>
</table>

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>Title</code></td>
    <td>string</td>
    <td>(required)</td>
    <td>The title of the notification.</td>
  </tr>
	<tr>
    <td><code>Text</code></td>
    <td>string</td>
    <td>(required)</td>
    <td>The main text of the notification.</td>
  </tr>
	<tr>
    <td><code>Icon</code></td>
    <td>string</td>
    <td></td>
    <td>The image to display with the notification.</td>
  </tr>
	<tr>
    <td><code>Duration</code></td>
    <td>number</td>
    <td><code>5</code></td>
    <td>Duration (in seconds) the notification should stay visible.</td>
  </tr>
	<tr>
    <td><code>Callback</code></td>
    <td><code>Class.BindableFunction</code></td>
    <td></td>
    <td>A <code>Class.BindableFunction</code> that should be invoked with the text of the button pressed by the player.</td>
  </tr>
	<tr>
    <td><code>Button1</code></td>
    <td>string</td>
    <td></td>
    <td>The text to display on the first button.</td>
  </tr>
	<tr>
    <td><code>Button2</code></td>
    <td>string</td>
    <td></td>
    <td>The text to display on the second button.</td>
  </tr>
  </tbody>
</table>

##### TopbarEnabled

Determines whether the topbar is displayed. Disabling the topbar will also
disable all `Class.CoreGui|CoreGuis` such as the chat, inventory, and
player list (for example, those set with
`Class.StarterGui:SetCoreGuiEnabled()|SetCoreGuiEnabled`).

When disabled, the region the topbar once occupied will still capture
mouse events; however, buttons placed there will not respond to clicks.
The origin of GUI space will still be offset 36 pixels from the top of the
screen.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether the topbar should be visible.</td>
  </tr>
</tbody>
</table>

##### DevConsoleVisible

Determines whether the
[Developer Console](/studio/developer-console) is visible.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>visibility</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether the console is visible.</td>
  </tr>
</tbody>
</table>

##### PromptSendFriendRequest

Prompts the current player to send a friend request to the given
`Class.Player`.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(required)</td>
    <td>The player to which the friend request should be sent.</td>
  </tr>
</tbody>
</table>

##### PromptUnfriend

Prompts the current player to remove a given `Class.Player` from their
friends list.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(required)</td>
    <td>The player who should be unconnected.</td>
  </tr>
</tbody>
</table>

##### PromptBlockPlayer

Prompts the current player to block the given `Class.Player`.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(required)</td>
    <td>The player who should be blocked.</td>
  </tr>
  </tbody>
</table>

##### PromptUnblockPlayer

Prompts the current player to unblock the given `Class.Player`.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
 </thead>
 <tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(required)</td>
    <td>The player who should be unblocked.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuEnabled

Determines whether the
[Avatar Context Menu](/players/avatar-context-menu) is enabled.

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>enabled</code></td>
    <td>boolean</td>
    <td>(required)</td>
    <td>Determines whether the context menu is enabled.</td>
  </tr>
</tbody>
</table>

##### AvatarContextMenuTarget

Forcibly opens the
[Avatar Context Menu](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>player</code></td>
    <td><code>Class.Player</code></td>
    <td>(required)</td>
    <td>The player on whom the context menu will be opened.</td>
  </tr>
</tbody>
</table>

##### AddAvatarContextMenuOption

Adds an option to the
[Avatar Context Menu](/players/avatar-context-menu).

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td><code>Enum.AvatarContextMenuOption</code></td>
    <td>(required)</td>
    <td>Option to add.</td>
  </tr>
	<tr>
    <td colspan="4"><b>OR</b></td>
  </tr>
	<tr>
    <td><code>option</code></td>
    <td>table</td>
    <td>(required)</td>
    <td>A two-element table, where the first is the name of the custom action, and the second is a <code>Class.BindableEvent</code> which will be fired with a player was selected when the option was activated.</td>
  </tr>
</tbody>
</table>

##### RemoveAvatarContextMenuOption

Removes an option to the
[Avatar Context Menu](/players/avatar-context-menu). The
`option` argument must be the same as what was used with
`"AddAvatarContextMenuOption"` (see above).

<table size="small">
	<thead>
		<tr>
			<th>Name</th>
			<th>Type</th>
			<th>Default</th>
			<th>Description</th>
    </tr>
</thead>
<tbody>
	<tr>
    <td><code>option</code></td>
    <td>Variant</td>
    <td>(required)</td>
    <td>The same value provided to <b>AddAvatarContextMenuOption</b>.</td>
  </tr>
  </tbody>
</table>

##### AvatarContextMenuTheme

Configures the customizable
[Avatar Context Menu](/players/avatar-context-menu) which is an
opt-in feature that allows easy player-to-player social interaction via
custom actions, such as initiating trades, battles, and more. For more
info on how to customize its theme, see the
[Avatar Context Menu](/players/avatar-context-menu) article.

##### CoreGuiChatConnections

Sets up a bindable gateway connection between the `Class.CoreGui` topbar's
chat button and the legacy chat system. The second parameter must be a
table of `Class.BindableEvent|BindableEvents` and
`Class.BindableFunction|BindableFunctions`.


StarterGui:SetCore

Selects the functionality with which the call will interact.


value

A table of `Class.BindableEvent|BindableEvents` and
`Class.BindableFunction|BindableFunctions`.


Allows you to perform certain interactions with Roblox's core scripts.


This function sets whether the `Class.CoreGui` element associated with the
given `Enum.CoreGuiType` is enabled or disabled.

The top bar cannot be disabled using this function. To disable it, set
`"TopbarEnabled"` to `false` using `Class.StarterGui:SetCore()`.


StarterGui:SetCoreGuiEnabled

enabled

Whether to enable or disable the given `Enum.CoreGuiType`.


Sets whether the `Class.CoreGui` element associated with the given
`Enum.CoreGuiType` is enabled or disabled.


StarterGui

Allows `Class.StarterGui` to process input like `Class.PlayerGui` and
`Class.CoreGui` do. The default value is `false`.


StarterGui.ProcessUserInput

Allows this service to process input like `Class.PlayerGui` and
`Class.CoreGui` do.


If set to true, each child parented to the `Class.StarterGui` will be
cloned into a player's `Class.PlayerGui` when that player's character is
respawned.

If one of the children is a PlayerGui and it has its PlayerGui property
set to false, it will not be cloned.


StarterGui.ResetPlayerGuiOnSpawn

Determines whether each child parented to the StarterGui will be cloned
into a player's PlayerGui when that player's character is respawned.


StarterGui.RtlTextSupport

This property sets the preferred screen orientation mode for users with
mobile devices. For the different modes available, see
`Enum.ScreenOrientation`.

By default, this property is set to
`Enum.ScreenOrientation.Sensor|Sensor`, meaning the experience is
displayed depending on the best match to the device's current orientation,
either landscape (left/right) or portrait.

When a `Class.Player` joins the experience on a mobile device, this
property determines the device's starting orientation and sets that
player's `Class.PlayerGui.ScreenOrientation` accordingly. You can also get
the player's current screen orientation through
`Class.PlayerGui.CurrentScreenOrientation`, useful when using one of the
"sensor" `Enum.ScreenOrientation` settings.

Note that changing this property will not change the screen orientation
for `Class.Player|Players` already in the experience. To change the
orientation for an existing player, use their
`Class.PlayerGui.ScreenOrientation` property.


StarterGui.ScreenOrientation

Sets the default screen orientation mode for users with mobile devices.


This property determines whether the contents of `Class.StarterGui` is
visible in Studio.


StarterGui.ShowDevelopmentGui

Determines whether the contents of `Class.StarterGui` is visible in
Studio.


StarterGui.VirtualCursorMode

A container for `Class.LayerCollector` objects to be copied into the
`Class.PlayerGui` of `Class.Player|Players`. Also provides a range of
functions for interacting with the `Class.CoreGui`.


`BasePlayerGui` is an abstract class that all GUI drawing storage classes
inherit from.


All GUIs returned by `Class.BasePlayerGui:GetGuiObjectsAtPosition()` are
'cloned' by the `highlightAsFrame()` local function, which creates a `Frame`
GUI positioned on top of the specified GUI that is semi-transparent and the
same `Class.GuiBase2d.AbsoluteSize` and `Class.GuiBase2d.AbsolutePosition`.

These highlights are added to the HighlightsContainer `ScreenGui` in the
Highlight folder of the player's PlayerGui folder. Both are created by the
code sample. All highlight GUIs are `Class.Instance:Destroy()`ed every time
`highlightGui()` executes.

Note that HighlightContainer's `Class.ScreenGui.DisplayOrder` is 99999, a
large number, so that it is unlikely any other GUI will render on top of the
highlight GUIs.


Takes a screen position and returns a list of all the `Class.GuiObject`
instances which are occupying that screen position, sorted in the order
they appear on screen from top to bottom as the first and last index,
respectively. The main use case is to get GUI objects under the player's
mouse or touch inputs to allow for selection or highlighting.

Since the child classes of `Class.BasePlayerGui` inherit this function, it
can be fired by container classes such as `Class.PlayerGui` and
`Class.StarterGui`.


BasePlayerGui:GetGuiObjectsAtPosition

The **X** position on the screen relative to the top-left corner after
the GUI inset is applied (see `Class.GuiService:GetGuiInset()`).


The **Y** position on the screen relative to the top-left corner after
the GUI inset is applied (see `Class.GuiService:GetGuiInset()`).


A table of the `Class.GuiObject` instances that occupy the given
screen space.


Returns a list of all `Class.GuiObject` instances occupying the given


BasePlayerGui

`BasePlayerGui` is an abstract class which the GUI drawing storage classes
inherit from.


`Instance` is the base class for all classes in the Roblox class hierarchy
which can be part of the `Class.DataModel` tree.

It is not possible to directly create root `Instance` objects, but the special
`Datatype.Instance.new()` constructor creates objects via code, taking the
name of the class as a parameter and returning the created object.


Demonstrates detecting changes to an instance's ancestry by connecting to the
`Class.Instance.AncestryChanged` event.

The ChangingPart's Parent is set to different values overtime. The parent of
the part is the part's ancestor, so the `Class.Instance.AncestryChanged` event
will fire whenever it changes.


Fires when this instance is reparented or when any of its ancestors is
reparented.

You can use this event to track the deletion of an instance in Studio,
such as manual deletion in the Explorer or through a plugin. If you need
to detect when an instance is destroyed using `Class.Instance:Destroy()`,
use the `Class.Instance.Destroying` event instead.


Instance.AncestryChanged

child

The instance whose `Class.Instance.Parent|Parent` property changed,
which can be this instance or a more distant ancestor, **not**
necessarily the instance the handler is connected to.


parent

The new parent of the `child` parameter.


Fires when the `Class.Instance.Parent` property of this object or one of
its ancestors is changed.


This event fires whenever any attribute is changed on the instance,
including when an attribute is set to `nil`. The name of the changed
attribute is passed to the connected function.

For example, the following code snippet connects the `attributeChanged()`
function to fire whenever one of the part's attributes changes:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part

local function attributeChanged(attributeName)
	print(attributeName, "changed")
end

part.AttributeChanged:Connect(attributeChanged)
```

See also `Class.Instance:GetAttributeChangedSignal()` which returns an
event that fires when a specific given attribute changes.


Instance.AttributeChanged

attribute

The name of the attribute that has been changed.


Fires whenever an attribute is changed on the `Class.Instance`.


This snippet prints the names of objects as they are added to the Workspace:


Fires after an object is parented to this `Class.Instance`.

Note, when using this method on a client to detect objects created by the
server it is necessary to use `Class.Instance:WaitForChild()` when
indexing these object's descendants. This is because the object and its
descendants are not guaranteed to replicate from the server to the client
simultaneously. For example:

```
local Workspace = game:GetService("Workspace")

Workspace.ChildAdded:Connect(function(child)
	-- Use WaitForChild() since descendants may not have replicated yet
	local head = child:WaitForChild("Head")
end)
```

Note, this event only operates for immediate children of the
`Class.Instance`. For an event that captures all descendants, use
`Class.Instance.DescendantAdded`.

See also `Class.Instance.ChildRemoved`.


Instance.ChildAdded

The `Class.Instance` that has been added.


Fires after an object is parented to this `Class.Instance`.


Instance.childAdded

This snippet prints the names of objects as they are removed from the
Workspace:


Fires after a child is removed from this `Class.Instance`.

Removed refers to when an object's parent is changed from this
`Class.Instance` to something other than this `Class.Instance`. Note, this
event will also fire when a child is destroyed (using
`Class.Instance:Destroy()`) as the destroy function sets an object's
parent to `nil`.

This event only operates for immediate children of the `Class.Instance`.
For an event that captures all descendants, use
`Class.Instance.DescendantRemoving`.

See also `Class.Instance.ChildAdded`.


Instance.ChildRemoved

The `Class.Instance` that has been removed.


Fires after a child is removed from this `Class.Instance`.


This following example will print the name of any object that is added to the
Workspace:


This event fires after a descendant is added to the `Class.Instance`.

As it fires for every descendant, parenting an object to the
`Class.Instance` will fire the event for this object and all of its
descendants individually.

If you're only concerned with the **direct children** of the
`Class.Instance`, use `Class.Instance.ChildAdded` instead.

See also `Class.Instance.DescendantRemoving`.


Instance.DescendantAdded

descendant

Fires after a descendant is added to the `Class.Instance`.


The following example prints the name of any descendant as it is being removed
from the Workspace:


This event fires **immediately before** the parent `Class.Instance`
changes such that a **descendant** instance will no longer be a
descendant. `Class.Instance:Destroy()|Destroy()` changes an instance's
`Class.Instance.Parent|Parent` to `nil`, so calling that method on a
descendant of the parent will cause this event to fire.

Since this event fires **before** the descendant's removal, the parent of
the descendant will be unchanged at the time of this event firing. If the
descendant is also a **direct child** of the parent, this event will fire
before `Class.Instance.ChildRemoved`.

If a descendant has children, this event fires with the descendant first,
followed by its descendants.

#### Warning

This event fires with the descendant object that is being removed.
Attempting to set the `Class.Instance.Parent|Parent` of the descendant to
something else will fail. Below is an example that demonstrates this:

```
local Workspace = game:GetService("Workspace")

Workspace.DescendantRemoving:Connect(function(descendant)
	-- Do not manipulate the parent of the descendant in this function!
	-- This event fires BECAUSE the parent was manipulated, and the change hasn't happened yet
	-- Therefore, it is problematic to change the parent like this:
	descendant.Parent = game
end)

local part = Instance.new("Part")
part.Parent = Workspace
part.Parent = nil
```

See also `Class.Instance.DescendantAdded|DescendantAdded`.


Instance.DescendantRemoving

The `Class.Instance` that is being removed.


Fires immediately before a descendant of the `Class.Instance` is removed.


This sample demonstrates how, when using Immediate signal behavior, an
Instance being destroyed remains in place until the connected function yields.


This sample demonstrates how, when using Deferred signal behavior, an Instance
is destroyed before the signal fires.


The `Class.Instance` will never be deleted from memory while a connected
function is still using it. However, if the function yields at any point,
the `Class.Instance` and its descendants will be parented to `nil`.

If the `Class.Workspace.SignalBehavior` property is set to
`Enum.SignalBehavior.Immediate`, this event fires immediately before the
`Class.Instance` or one of its ancestors is destroyed with
`Class.Instance:Destroy()`.

If the `Class.Workspace.SignalBehavior` property is set to
`Enum.SignalBehavior.Deferred`, this event fires at the next resumption
point, which will be after the `Class.Instance` or one of its ancestors is
destroyed with `Class.Instance:Destroy()`.

With `Enum.SignalBehavior.Deferred|Deferred` behavior, connecting a script
to its own `Class.Instance.Destroying` event is problematic, as the script
will be destroyed before the callback can be called (meaning it will not
execute).

When deleting an `Class.Instance` in Studio, such as manually deleting
through the [Explorer](/studio/explorer) or through a plugin,
the `Class.Instance` isn't destroyed. Instead, the parent is set to `nil`
which you can track with `Class.Instance.AncestryChanged`.


Instance.Destroying

Fires immediately before (or is deferred until after) the instance is
destroyed via `Class.Instance:Destroy()`.


This event fires whenever any style property is changed on the instance,
including when a property is set to `nil`.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Styled properties changed")
end

meterBar:StyledPropertiesChanged():Connect(stylePropertyChanged)
```


Instance.StyledPropertiesChanged

Fires whenever any style property is changed on the instance, including
when a property is set to `nil`.


This method applies a tag to the instance, with no effect if the tag is
already applied. Successfully adding a tag will fire a signal created by
`Class.CollectionService:GetInstanceAddedSignal()` with the given tag.

#### Warnings

- An instance's tags that were added client-side will be dropped if the
  server later adds or removes a tag on that instance because the server
  replicates all tags together and overwrites previous tags.

- When tagging an instance, it is common that some resources are used to
  give the tag its functionality, for example event connections or tables.
  To prevent memory leaks, it's a good idea to clean these up (disconnect,
  set to `nil`, etc.) when no longer needed for a tag. Do this when
  calling `Class.Instance:RemoveTag()`, calling
  `Class.Instance:Destroy()`, or in a function connected to a signal
  returned by `Class.CollectionService:GetInstanceRemovedSignal()`.


Instance:AddTag

The children function returns an array of the object's children.


Instance:children

Returns an array of the object's children.


This method destroys all of an instance's children and descendants.

```
local part = Instance.new("Part")

-- Add some sparkles
for i = 1, 3 do
	local sparkles = Instance.new("Sparkles")
	sparkles.Parent = part

  local sc = Instance.new("Sparkles")
  sc.Parent = sparkles
end

print("Children:", #part:GetChildren())  --> Children: 3

part:ClearAllChildren()

print("Children:", #part:GetChildren())  --> Children: 0
```

If you do not wish to destroy **all** children and descendants, use either
`Class.Instance:GetChildren()` or `Class.Instance:GetDescendants()` to
loop through those children/descendants and select what to destroy. For
example, the following code sample will destroy all
`Class.BasePart|BaseParts` descending from a `Class.Model`:

```
local Workspace = game:GetService("Workspace")

local model = Workspace:FindFirstChild("TestModel")

for _, descendant in model:GetDescendants() do
	if descendant:IsA("BasePart") then
		descendant:Destroy()
	end
end
```


Instance:ClearAllChildren

This method destroys all of an instance's children.


Demonstrates cloning a model using `Class.Instance:Clone()`.


`Clone()` creates a copy of an instance and all of its descendants,
ignoring all instances that are not
`Class.Instance.Archivable|Archivable`. The copy of the root instance is
returned by this method and its `Class.Instance.Parent|Parent` is set to
`nil`. Note that if the instance itself has
`Class.Instance.Archivable|Archivable` set to `false`, this method will
return `nil`.

If a reference property such as `Class.ObjectValue.Value` is set in a
cloned instance, the value of the copy's property depends on the
original's value:

- If a reference property refers to an instance that was **also** cloned,
  the copy will refer to the copy.
- If a reference property refers to an instance that was **not** cloned,
  the same value is maintained in the copy.


Instance:Clone

Create a copy of an instance and all its descendants, ignoring instances
that are not `Class.Instance.Archivable|Archivable`.


Instance:clone

Demonstrates destroying a Part using the `Class.Instance:Destroy()` function.

This function is the correct way to dispose of objects that are no longer
required.


Sets the `Class.Instance.Parent` property to `nil`, locks the
`Class.Instance.Parent` property, disconnects all connections, and calls
`Destroy()` on all children. This method is the correct way to dispose of
objects that are no longer required.

Disposing of unneeded objects is important, since unnecessary objects and
connections in a place use up memory which can lead to serious performance
issues over time.

As a best practice after calling `Destroy()` on an object, set any
variables referencing the object (or its descendants) to `nil`. This
prevents your code from accessing anything to do with the object.

```lua
local part = Instance.new("Part")
part.Name = "Hello, world"
part:Destroy()
-- Don't do this:
print(part.Name)  --> "Hello, world"
-- Do this to prevent the above line from working:
part = nil
```

Once an `Class.Instance` has been destroyed by this method, it cannot be
reused because the `Class.Instance.Parent` property is locked. To
**temporarily** remove an object instead of destroying it, set
`Class.Instance.Parent|Parent` to `nil`. For example:

```
local Workspace = game:GetService("Workspace")

object.Parent = nil
task.wait(2)
object.Parent = Workspace
```

To destroy an object after a set amount of time, use
`Class.Debris:AddItem()`.


Instance:Destroy

Sets the `Class.Instance.Parent` property to `nil`, locks the
`Class.Instance.Parent` property, disconnects all connections, and calls
`Destroy()` on all children.


Instance:destroy

Returns the first ancestor of the `Class.Instance` whose
`Class.Instance.Name` is equal to the given name.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

The following code snippet would find the first ancestor of the object
named `Car`.

```
local car = object:FindFirstAncestor("Car")
```

For variants of this method that find ancestors of a specific class,
please see `Class.Instance:FindFirstAncestorOfClass()` and
`Class.Instance:FindFirstAncestorWhichIsA()`.


Instance:FindFirstAncestor

name

The `Class.Instance.Name` to be looked for.


Returns the first ancestor of the `Class.Instance` whose
`Class.Instance.Name` is equal to the given name.


Returns the first ancestor of the `Class.Instance` whose
`Class.Object.ClassName` is equal to the given className.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

A common use of this method is finding the `Class.Model` a
`Class.BasePart` belongs to. For example:

```
local model = part:FindFirstAncestorOfClass("Model")
```

This method is a variant of `Class.Instance:FindFirstAncestor()` which
checks the `Class.Object.ClassName` property rather than
`Class.Instance.Name`. `Class.Instance:FindFirstAncestorWhichIsA()` also
exists, using the `Class.Object:IsA()` method instead to respect class
inheritance.


Instance:FindFirstAncestorOfClass

className

The `Class.Object.ClassName` to be looked for.


Returns the first ancestor of the `Class.Instance` whose
`Class.Object.ClassName` is equal to the given className.


Returns the first ancestor of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.

This method works upwards, meaning it starts at the instance's immediate
`Class.Instance.Parent` and works up towards the `Class.DataModel`. If no
matching ancestor is found, it returns `nil`.

Unlike `Class.Instance:FindFirstAncestorOfClass()`, this method uses
`Class.Object:IsA()` which respects class inheritance. For example:

```
print(part:IsA("Part"))  --> true
print(part:IsA("BasePart"))  --> true
print(part:IsA("Instance"))  --> true
```

Therefore, the following code sample will return the first
`Class.BasePart` ancestor, regardless of if it is a `Class.WedgePart`,
`Class.MeshPart` or `Class.Part`.

```
local part = object:FindFirstAncestorWhichIsA("BasePart")
```

See also `Class.Instance:FindFirstAncestor()`.


Instance:FindFirstAncestorWhichIsA

Returns the first ancestor of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.


The below would look in Workspace for an object name "Brick". If found, it
will change the name of the object to "Foo".


Returns the first child of the `Class.Instance` with the given name, or
`nil` if no such child exists. If the optional `recursive` argument is
`true`, this method searches all descendants rather than only the
immediate children of the `Class.Instance`.

#### Checking the Existence of an Object

`FindFirstChild()` is necessary if you need to verify an object exists
before continuing. Attempting to index a child by name using the dot
operator throws an error if the child doesn't exist.

```lua
local Workspace = game:GetService("Workspace")

-- The following line errors if the part doesn't exist in the workspace
Workspace.Part.Transparency = 0.5
```

A better approach is to use `FindFirstChild()` to first check for `Part`,
then use an `if` statement to run code that needs it.

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace:FindFirstChild("Part")
if part then
	part.Transparency = 0.5
end
```

#### Finding a Child Whose Name Matches a Property

Sometimes the `Class.Instance.Name|Name` of an object is the same as that
of a property of its `Class.Instance.Parent|Parent`. When using the dot
operator, properties take precedence over children if they share a name.

In the following example, a `Class.Folder` called `Color` is added to a
`Class.Part`, which also has the `Class.Part.Color` property. Notice that
`part.Color` refers to the `Datatype.Color3` property value, not the child
`Class.Folder` instance. A benefit of using
`Class.Instance:FindFirstChild()|FindFirstChild()` is that the
introduction of new properties does not impose a risk on your code.

```lua
local part = Instance.new("Part")
local folder = Instance.new("Folder")
folder.Name = "Color"
folder.Parent = part
local c1 = part.Color  -- The property
local c2 = part:FindFirstChild("Color")  -- The child folder
```

#### Performance Notes

`Class.Instance:FindFirstChild()|FindFirstChild()` takes about 20% longer
than using the dot operator and almost 8 times longer than simply storing
a reference to an object. Therefore, you should avoid calling it in
performance-dependent code such as in tight loops or functions connected
to `Class.RunService.Heartbeat` and `Class.RunService.PreRender`. Instead,
store the result in a variable, or consider using
`Class.Instance.ChildAdded|ChildAdded` or
`Class.Instance:WaitForChild()|WaitForChild()` to detect when a child of a
given name becomes available.


Instance:FindFirstChild

The `Class.Instance.Name` to be searched for.


recursive

Whether or not the search should be conducted recursively.


Returns the first child of the `Class.Instance` found with the given name.


Instance:findFirstChild

Returns the first child of the `Class.Instance` whose
`Class.Object.ClassName|ClassName` is equal to the given `className`.
Unlike `Class.Instance:FindFirstChildWhichIsA()`, this method only returns
objects whose class matches `className`, ignoring class inheritance. If no
matching child is found, this method returns `nil`.


Instance:FindFirstChildOfClass

Returns the first child of the `Class.Instance` whose
`Class.Object.ClassName|ClassName` is equal to the given class name.


Returns the first child of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.

If no matching child is found, this method returns `nil`. If the optional
recursive argument is true, this method searches all descendants rather
than only the immediate children of the `Class.Instance`.

Unlike `Class.Instance:FindFirstChildOfClass()`, this method uses
`Class.Object:IsA()` which respects class inheritance. For example:

```lua
print(part:IsA("Part")) --> true
print(part:IsA("BasePart")) --> true
print(part:IsA("Instance")) --> true
```

Therefore, the following code sample will return the first
`Class.BasePart` child, regardless of if it is a `Class.WedgePart`,
`Class.MeshPart` or `Class.Part`.

```
local part = object:FindFirstChildWhichIsA("BasePart")
```

Developers looking for a child by name, should use
`Class.Instance:FindFirstChild()` instead.


Instance:FindFirstChildWhichIsA

The `Class.Object.ClassName` to be searched for.


Returns the first child of the `Class.Instance` for whom
`Class.Object:IsA()` returns true for the given className.


Returns the first descendant found with the given `Class.Instance.Name`.

This method is disabled and cannot be used. To find the first descendant
of an instance, consider using the `recursive` parameter on
`Class.Instance:FindFirstChild()` instead.


Instance:FindFirstDescendant

The `Class.Instance.Name` to search for.


Returns the first descendant found with the given `Class.Instance.Name`.


If the `Class.Instance` is an `Class.Actor`, the `Class.Actor` itself is
returned. Otherwise, its closest ancestor `Class.Actor` is returned. If no
ancestor is an `Class.Actor`, the result is `nil`.


Instance:GetActor

Returns the `Class.Actor` associated with the Instance, if any.


This method returns the value which has been assigned to the given
attribute name. If no attribute has been assigned, `nil` is returned.

For example, the following code snippet sets and then gets the value of
the instance's `InitialPosition` attribute:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local initialPosition = instance:GetAttribute("InitialPosition")
print(initialPosition)
```

#### See Also

- `Class.Instance:SetAttribute()` which sets the attribute with the given
  name to the given value.
- `Class.Instance:GetAttributes()` which returns a dictionary of key‑value
  pairs for each of the instance's attributes.


Instance:GetAttribute

The name of the attribute being retrieved.


The value which has been assigned to the given attribute name. If no
attribute has been assigned, `nil` is returned.


Returns the value which has been assigned to the given attribute name.


This method returns an event that behaves exactly like the
`Class.Object.Changed|Changed` event, except that it only fires when the
specific given attribute changes; effectively it is similar to
`Class.Object:GetPropertyChangedSignal()|GetPropertyChangedSignal()` but
for attributes.

It's generally a good idea to use this method instead of a connection to
`Class.Object.Changed|Changed` with a function that checks the attribute
name. Subsequent calls to this method on the same object with the same
attribute name return the same event.

The following code example returns a signal that fires the function
`attributeChanged()` when the part's `InitialPosition` attribute changes:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)

local function attributeChanged()
	print("Attribute changed")
end

part:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
```

See also `Class.Instance.AttributeChanged` which fires whenever any
attribute is changed on the instance.


Instance:GetAttributeChangedSignal

The name of the specified attribute for which the change signal is
being returned.


An event that fires when the given attribute changes.


Returns an event that fires when the given attribute changes.


This method returns a dictionary of key‑value pairs for each attribute
where the key is the attribute's name and the value is a non‑`nil` value.

For example, the following code snippet outputs an instance's attributes
and values:

```lua
local Workspace = game:GetService("Workspace")

local part = Workspace.Part
part:SetAttribute("InitialPosition", part.Position)
part:SetAttribute("CanUse", true)

for name, value in part:GetAttributes() do
	print(name .. " = " .. value)
end
```

See also `Class.Instance:GetAttribute()` which returns the value that has
been assigned to the given attribute name.


Instance:GetAttributes

A dictionary of string → variant pairs for each attribute where the
string is the name of the attribute and the variant is a non-nil
value.


Returns a dictionary of the instance's attributes.


The below would print the name of all objects currently in Workspace when ran.


Returns an array (a numerically indexed table) containing all of the
instance's direct children, or every `Class.Instance` whose
`Class.Instance.Parent|Parent` is equal to the object. The array can be
iterated upon using either a numeric or generic `for` loop:

```lua
local Workspace = game:GetService("Workspace")

-- Numeric loop example
local children = Workspace:GetChildren()
for i = 1, #children do
	local child = children[i]
	print(child.Name .. " is child number " .. i)
end
```

```lua
local Workspace = game:GetService("Workspace")

-- Generic loop example
local children = Workspace:GetChildren()
for i, child in children do
	print(child.Name .. " is child number " .. i)
end
```

Note that the returned array is **not** sorted in any particular order, so
manual sorting (for example using `Library.table.sort()`) is advised for
sorting the children returned by this method.

See also the `Class.Instance:GetDescendants()|GetDescendants()` method.


Instance:GetChildren

An array containing the instance's children.


Returns an array containing all of the instance's children.


Instance:getChildren

Returns a coded string of the debug ID used internally by Roblox. Note
that:

- This item is protected. Attempting to use it in a `Class.Script` or
  `Class.LocalScript` will cause an error.
- A debug ID is an ID used in debugging processes. It allows a debugger to
  read each instruction before an application processes it. All objects in
  Roblox act like processes and each run instructions (or 'code') that can
  be debugged if needed.
- This can be helpful for plugins which need to distinguish similar
  objects from one-another (such as objects that share the same name).


Instance:GetDebugId

scopeLength

Returns a coded string of the debug ID used internally by Roblox.


GetDescendants is often used to do something to all the descendants that are a
particular type of object. The code in this example uses GetDescendants and
`Class.Instance:IsA()` to find all of the parts in the workspace and turns
them green.


This object method returns an array that contains all of the descendants
of that object. Unlike `Class.Instance:GetChildren()`, which only returns
the immediate children of an object, this method finds every child of the
object, every child of those children, and so on.

Note that the returned array is **not** sorted in any particular order, so
manual sorting (for example using `Library.table.sort()`) is advised for
sorting the descendants returned by this method. Also consdier the
`Class.Instance:QueryDescendants()|QueryDescendants()` method to query
descendants by a combination of selectors and combinators.


Instance:GetDescendants

An array containing the instance's descendants.


Returns an array containing all of the descendants of the instance.


This code sample demonstrates the behavior of `Class.Instance:GetFullName()`.
It shows how the function behaves when called on an object not in the
`DataModel` hierarchy, and it also shows how the return value does not escape
special characters.


This code sample re-implements the `Class.Instance:GetFullName()` function in
Lua.


Returns a string describing the instance's ancestry. The string is a
concatenation of the `Class.Instance.Name|Name` of the object and its
ancestors, separated by periods. The `Class.DataModel` (`game`) is not
considered. For example, a `Class.Part` in the `Class.Workspace` may
return `Class.Workspace.Part`.

When called on an `Class.Instance` that is not a descendant of the
`Class.DataModel`, this method considers all ancestors up to and including
the topmost one without a `Class.Instance.Parent|Parent`.

This method is useful for logging and debugging. You shouldn't attempt to
parse the returned string for any useful operation; this method does not
escape periods (or any other symbol) in object names. In other words,
although its output often appears to be a valid Luau identifier, it is not
guaranteed.


Instance:GetFullName

Returns a string describing the instance's ancestry.


This method returns the styled or explicitly modified value of the
specified property, or else the default property value if it hasn't been
styled/modified. This differs slightly from accessing the property value
directly, such as `[GuiObject].Rotation`, which returns the default or
modified value of the property.

```lua
local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")

local coreSheet = ReplicatedStorage:FindFirstChild("CoreSheet")
local rule = coreSheet:FindFirstChildWhichIsA("StyleRule")
rule.Selector = "TextButton"

-- Reference to a button
local button = HUDContainer:FindFirstChildWhichIsA("TextButton")

print(button:GetStyled("Rotation")) --> 0 (default value)
print(button.Rotation) --> 0 (default value)

-- Apply rotation through style rule property
rule:SetProperty("Rotation", 30)

print(button:GetStyled("Rotation")) --> 30 (styled value based on rule)
print(button.Rotation) --> 0 (default value)

-- Explicitly modify/override styled property
button.Rotation = 45

print(button:GetStyled("Rotation")) --> 45 (modified value)
print(button.Rotation) --> 45 (modified value)
```


Instance:GetStyled

selector

Optional selector for the pseudo instance you are targeting on the
instance.


The styled or explicitly modified value of the specified property, or
else the default property value if it hasn't been styled/modified.


Returns the styled or explicitly modified value of the specified property,
or else the default property value if it hasn't been styled/modified.


This method returns an event that behaves exactly like the
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` event,
except that it only fires when the given style property changes. It's
generally a good idea to use this method instead of a connection to
`Class.Instance.StyledPropertiesChanged|StyledPropertiesChanged` with a
function that checks the property name. Subsequent calls to this method on
the same object with the same property name return the same event.

Note that this event will not pass any arguments to a connected function,
so the value of the changed property must be read directly within a
script.

```lua
local Players = game:GetService("Players")

local player = Players.LocalPlayer
local playerGui = player.PlayerGui
local HUDContainer = playerGui:WaitForChild("HUDContainer")
local meterBar = HUDContainer.MeterBar

local function stylePropertyChanged()
	print("Style property changed!")
end

meterBar:GetStyledPropertyChangedSignal("AnchorPoint"):Connect(stylePropertyChanged)
```


Instance:GetStyledPropertyChangedSignal

property

Name of the style property for which to listen for changes.


Event that fires when the given style property changes.


This method returns an array of the tags applied to the given instance, as
strings. You can add tags either in Studio in the
[Properties](/studio/properties) window or at runtime with
`Class.Instance:AddTag()|AddTag()`.

This method is useful when you want to do something with multiple tags on
an instance at once. However, it is inefficient to use this method to
check for the existence of a single tag; instead, use
`Class.Instance:HasTag()|HasTag()` to check for a specific tag.


Instance:GetTags

Gets an array of all tags applied to the instance.


This method returns `true` if the provided tag has been added to the
object. You can add tags either in Studio in the
[Properties](/studio/properties) window or at runtime with
`Class.Instance:AddTag()|AddTag()`.


Instance:HasTag

Check whether the instance has a given tag.


Demonstrates determining if one instance is the ancestor of another using
`Class.Instance:IsAncestorOf()`

Workspace and SpawnLocation are ancestors of the SpawnLocation's decal.
Workspace is an ancestor of SpawnLocation.

SpawnLocation and its decal are descendants of Workspace, not ancenstors.
Decal is a descendant to SpawnLocation, not an ancestor.


Returns true if an `Class.Instance` is an ancestor of the given
descendant.

An `Class.Instance` is considered the ancestor of an object if the
object's `Class.Instance.Parent` or one of it's parent's
`Class.Instance.Parent` is set to the `Class.Instance`.

See also, `Class.Instance:IsDescendantOf()`.


Instance:IsAncestorOf

True if the `Class.Instance` is an ancestor of the given descendant.


Returns true if an `Class.Instance` is an ancestor of the given
descendant.


Returns `true` if an `Class.Instance` is a descendant of the given
ancestor.

Note that `IsDescendantOf()` cannot be used with a parameter of `nil` to
check if an object has been removed.

See also `Class.Instance:IsAncestorOf()`.


Instance:IsDescendantOf

Returns `true` if an `Class.Instance` is a descendant of the given
ancestor.


Instance

`Instance` is the base class for all classes in the Roblox class hierarchy
which can be part of the `Class.DataModel` tree.


/reference/engine/classes/StarterGui.yaml