// THIS FILE IS GENERATED AUTOMATICALLY AND SHOULD NOT BE EDITED BY HAND!
///
///
///
interface Services {
AccountService: AccountService;
AnalyticsService: AnalyticsService;
AnimationClipProvider: AnimationClipProvider;
AnimationFromVideoCreatorService: AnimationFromVideoCreatorService;
AnimationFromVideoCreatorStudioService: AnimationFromVideoCreatorStudioService;
AppUpdateService: AppUpdateService;
AssetCounterService: AssetCounterService;
AssetDeliveryProxy: AssetDeliveryProxy;
AssetImportService: AssetImportService;
AssetManagerService: AssetManagerService;
AssetService: AssetService;
AvatarChatService: AvatarChatService;
AvatarCreationService: AvatarCreationService;
AvatarEditorService: AvatarEditorService;
AvatarImportService: AvatarImportService;
BadgeService: BadgeService;
BulkImportService: BulkImportService;
CalloutService: CalloutService;
CaptureService: CaptureService;
Chat: Chat;
ChatbotUIService: ChatbotUIService;
CollaboratorsService: CollaboratorsService;
CollectionService: CollectionService;
CommandService: CommandService;
ConfigureServerService: ConfigureServerService;
ContentProvider: ContentProvider;
ContextActionService: ContextActionService;
ControllerService: ControllerService;
CoreScriptDebuggingManagerHelper: CoreScriptDebuggingManagerHelper;
CreationDBService: CreationDBService;
CrossDMScriptChangeListener: CrossDMScriptChangeListener;
DataModelPatchService: DataModelPatchService;
DataStoreService: DataStoreService;
Debris: Debris;
DebuggablePluginWatcher: DebuggablePluginWatcher;
DebuggerConnectionManager: DebuggerConnectionManager;
DebuggerUIService: DebuggerUIService;
DeviceIdService: DeviceIdService;
DraggerService: DraggerService;
EngineAPICloudProcessingService: EngineAPICloudProcessingService;
EventIngestService: EventIngestService;
ExperienceAuthService: ExperienceAuthService;
ExperienceNotificationService: ExperienceNotificationService;
ExperienceService: ExperienceService;
FaceAnimatorService: FaceAnimatorService;
FacialAnimationRecordingService: FacialAnimationRecordingService;
FacialAnimationStreamingServiceV2: FacialAnimationStreamingServiceV2;
GamepadService: GamepadService;
GamePassService: GamePassService;
GeometryService: GeometryService;
GroupService: GroupService;
GuiService: GuiService;
HapticService: HapticService;
HeightmapImporterService: HeightmapImporterService;
HttpService: HttpService;
ILegacyStudioBridge: ILegacyStudioBridge;
IncrementalPatchBuilder: IncrementalPatchBuilder;
InsertService: InsertService;
InternalSyncService: InternalSyncService;
IXPService: IXPService;
JointsService: JointsService;
KeyframeSequenceProvider: KeyframeSequenceProvider;
LanguageService: LanguageService;
LegacyStudioBridge: LegacyStudioBridge;
Lighting: Lighting;
LiveScriptingService: LiveScriptingService;
LocalizationService: LocalizationService;
LodDataService: LodDataService;
LogReporterService: LogReporterService;
LogService: LogService;
LSPFileSyncService: LSPFileSyncService;
LuauScriptAnalyzerService: LuauScriptAnalyzerService;
MarketplaceService: MarketplaceService;
MaterialGenerationService: MaterialGenerationService;
MaterialService: MaterialService;
MemoryStoreService: MemoryStoreService;
MessageBusService: MessageBusService;
MessagingService: MessagingService;
MetaBreakpointManager: MetaBreakpointManager;
OmniRecommendationsService: OmniRecommendationsService;
OpenCloudService: OpenCloudService;
PackageUIService: PackageUIService;
PatchBundlerFileWatch: PatchBundlerFileWatch;
PathfindingService: PathfindingService;
PhysicsService: PhysicsService;
PlacesService: PlacesService;
PlaceStatsService: PlaceStatsService;
PlatformFriendsService: PlatformFriendsService;
Players: Players;
PlayerViewService: PlayerViewService;
PluginManagementService: PluginManagementService;
PluginPolicyService: PluginPolicyService;
PolicyService: PolicyService;
ProcessInstancePhysicsService: ProcessInstancePhysicsService;
ProximityPromptService: ProximityPromptService;
PublishService: PublishService;
ReflectionService: ReflectionService;
RemoteCursorService: RemoteCursorService;
RemoteDebuggerServer: RemoteDebuggerServer;
ReplicatedFirst: ReplicatedFirst;
ReplicatedStorage: ReplicatedStorage;
RibbonNotificationService: RibbonNotificationService;
RobloxServerStorage: RobloxServerStorage;
RomarkService: RomarkService;
RtMessagingService: RtMessagingService;
RunService: RunService;
SafetyService: SafetyService;
ScriptChangeService: ScriptChangeService;
ScriptCloneWatcher: ScriptCloneWatcher;
ScriptCloneWatcherHelper: ScriptCloneWatcherHelper;
ScriptCommitService: ScriptCommitService;
ScriptContext: ScriptContext;
ScriptEditorService: ScriptEditorService;
ScriptRegistrationService: ScriptRegistrationService;
SelectionHighlightManager: SelectionHighlightManager;
ServerScriptService: ServerScriptService;
ServerStorage: ServerStorage;
ServiceVisibilityService: ServiceVisibilityService;
SessionService: SessionService;
SharedTableRegistry: SharedTableRegistry;
ShorelineUpgraderService: ShorelineUpgraderService;
SmoothVoxelsUpgraderService: SmoothVoxelsUpgraderService;
SnippetService: SnippetService;
SocialService: SocialService;
SoundService: SoundService;
StarterGui: StarterGui;
StarterPack: StarterPack;
StarterPlayer: StarterPlayer;
Stats: Stats;
StreamingService: StreamingService;
StudioAssetService: StudioAssetService;
StudioDeviceEmulatorService: StudioDeviceEmulatorService;
StudioPublishService: StudioPublishService;
StudioScriptDebugEventListener: StudioScriptDebugEventListener;
StudioSdkService: StudioSdkService;
StudioWidgetsService: StudioWidgetsService;
StylingService: StylingService;
TeamCreateData: TeamCreateData;
TeamCreatePublishService: TeamCreatePublishService;
TeamCreateService: TeamCreateService;
Teams: Teams;
TeleportService: TeleportService;
TemporaryCageMeshProvider: TemporaryCageMeshProvider;
TemporaryScriptService: TemporaryScriptService;
TextBoxService: TextBoxService;
TextChatService: TextChatService;
TextService: TextService;
TextureGenerationMeshHandler: TextureGenerationMeshHandler;
ToastNotificationService: ToastNotificationService;
TracerService: TracerService;
TutorialService: TutorialService;
TweenService: TweenService;
UGCAvatarService: UGCAvatarService;
UnvalidatedAssetService: UnvalidatedAssetService;
UserInputService: UserInputService;
UserService: UserService;
VideoCaptureService: VideoCaptureService;
VideoService: VideoService;
VisibilityCheckDispatcher: VisibilityCheckDispatcher;
VisibilityService: VisibilityService;
VoiceChatInternal: VoiceChatInternal;
VoiceChatService: VoiceChatService;
VRService: VRService;
VRStatusService: VRStatusService;
Workspace: Workspace;
}
interface CreatableInstances {
Accessory: Accessory;
AccessoryDescription: AccessoryDescription;
Accoutrement: Accoutrement;
Actor: Actor;
AdGui: AdGui;
AdPortal: AdPortal;
AirController: AirController;
AlignOrientation: AlignOrientation;
AlignPosition: AlignPosition;
AngularVelocity: AngularVelocity;
Animation: Animation;
AnimationConstraint: AnimationConstraint;
AnimationController: AnimationController;
AnimationRigData: AnimationRigData;
Animator: Animator;
ArcHandles: ArcHandles;
Atmosphere: Atmosphere;
Attachment: Attachment;
AudioAnalyzer: AudioAnalyzer;
AudioChorus: AudioChorus;
AudioCompressor: AudioCompressor;
AudioDeviceInput: AudioDeviceInput;
AudioDeviceOutput: AudioDeviceOutput;
AudioDistortion: AudioDistortion;
AudioEcho: AudioEcho;
AudioEmitter: AudioEmitter;
AudioEqualizer: AudioEqualizer;
AudioFader: AudioFader;
AudioFlanger: AudioFlanger;
AudioListener: AudioListener;
AudioPitchShifter: AudioPitchShifter;
AudioPlayer: AudioPlayer;
AudioReverb: AudioReverb;
AudioSearchParams: AudioSearchParams;
Backpack: Backpack;
BallSocketConstraint: BallSocketConstraint;
Beam: Beam;
BillboardGui: BillboardGui;
BindableEvent: BindableEvent;
BindableFunction: BindableFunction;
BlockMesh: BlockMesh;
BloomEffect: BloomEffect;
BlurEffect: BlurEffect;
BodyAngularVelocity: BodyAngularVelocity;
BodyColors: BodyColors;
BodyForce: BodyForce;
BodyGyro: BodyGyro;
BodyPartDescription: BodyPartDescription;
BodyPosition: BodyPosition;
BodyThrust: BodyThrust;
BodyVelocity: BodyVelocity;
Bone: Bone;
BoolValue: BoolValue;
BoxHandleAdornment: BoxHandleAdornment;
Breakpoint: Breakpoint;
BrickColorValue: BrickColorValue;
BubbleChatMessageProperties: BubbleChatMessageProperties;
BuoyancySensor: BuoyancySensor;
Camera: Camera;
CanvasGroup: CanvasGroup;
CFrameValue: CFrameValue;
CharacterMesh: CharacterMesh;
ChorusSoundEffect: ChorusSoundEffect;
ClickDetector: ClickDetector;
ClimbController: ClimbController;
Clouds: Clouds;
Color3Value: Color3Value;
ColorCorrectionEffect: ColorCorrectionEffect;
CompressorSoundEffect: CompressorSoundEffect;
ConeHandleAdornment: ConeHandleAdornment;
Configuration: Configuration;
ControllerManager: ControllerManager;
ControllerPartSensor: ControllerPartSensor;
CornerWedgePart: CornerWedgePart;
CurveAnimation: CurveAnimation;
CylinderHandleAdornment: CylinderHandleAdornment;
CylinderMesh: CylinderMesh;
CylindricalConstraint: CylindricalConstraint;
DataStoreGetOptions: DataStoreGetOptions;
DataStoreIncrementOptions: DataStoreIncrementOptions;
DataStoreOptions: DataStoreOptions;
DataStoreSetOptions: DataStoreSetOptions;
Decal: Decal;
DepthOfFieldEffect: DepthOfFieldEffect;
Dialog: Dialog;
DialogChoice: DialogChoice;
DistortionSoundEffect: DistortionSoundEffect;
DoubleConstrainedValue: DoubleConstrainedValue;
DragDetector: DragDetector;
Dragger: Dragger;
EchoSoundEffect: EchoSoundEffect;
EditableImage: EditableImage;
EditableMesh: EditableMesh;
EqualizerSoundEffect: EqualizerSoundEffect;
EulerRotationCurve: EulerRotationCurve;
ExperienceInviteOptions: ExperienceInviteOptions;
Explosion: Explosion;
FaceControls: FaceControls;
FileMesh: FileMesh;
Fire: Fire;
FlangeSoundEffect: FlangeSoundEffect;
FloatCurve: FloatCurve;
FloorWire: FloorWire;
Folder: Folder;
ForceField: ForceField;
Frame: Frame;
GetTextBoundsParams: GetTextBoundsParams;
Glue: Glue;
GroundController: GroundController;
Handles: Handles;
Hat: Hat;
HiddenSurfaceRemovalAsset: HiddenSurfaceRemovalAsset;
Highlight: Highlight;
HingeConstraint: HingeConstraint;
Hole: Hole;
Humanoid: Humanoid;
HumanoidController: HumanoidController;
HumanoidDescription: HumanoidDescription;
IKControl: IKControl;
ImageButton: ImageButton;
ImageHandleAdornment: ImageHandleAdornment;
ImageLabel: ImageLabel;
IntConstrainedValue: IntConstrainedValue;
InternalSyncItem: InternalSyncItem;
IntersectOperation: IntersectOperation;
IntValue: IntValue;
Keyframe: Keyframe;
KeyframeMarker: KeyframeMarker;
KeyframeSequence: KeyframeSequence;
LinearVelocity: LinearVelocity;
LineForce: LineForce;
LineHandleAdornment: LineHandleAdornment;
LocalizationTable: LocalizationTable;
LocalScript: LocalScript;
ManualGlue: ManualGlue;
ManualWeld: ManualWeld;
MarkerCurve: MarkerCurve;
MaterialVariant: MaterialVariant;
MeshPart: MeshPart;
Model: Model;
ModuleScript: ModuleScript;
Motor: Motor;
Motor6D: Motor6D;
MotorFeature: MotorFeature;
NegateOperation: NegateOperation;
NoCollisionConstraint: NoCollisionConstraint;
NumberPose: NumberPose;
NumberValue: NumberValue;
ObjectValue: ObjectValue;
OperationGraph: OperationGraph;
Pants: Pants;
Part: Part;
ParticleEmitter: ParticleEmitter;
PartOperation: PartOperation;
Path2D: Path2D;
PathfindingLink: PathfindingLink;
PathfindingModifier: PathfindingModifier;
PitchShiftSoundEffect: PitchShiftSoundEffect;
Plane: Plane;
PlaneConstraint: PlaneConstraint;
PluginCapabilities: PluginCapabilities;
PointLight: PointLight;
Pose: Pose;
PrismaticConstraint: PrismaticConstraint;
ProximityPrompt: ProximityPrompt;
RayValue: RayValue;
RemoteEvent: RemoteEvent;
RemoteFunction: RemoteFunction;
ReverbSoundEffect: ReverbSoundEffect;
RigidConstraint: RigidConstraint;
RocketPropulsion: RocketPropulsion;
RodConstraint: RodConstraint;
RopeConstraint: RopeConstraint;
Rotate: Rotate;
RotateP: RotateP;
RotateV: RotateV;
RotationCurve: RotationCurve;
ScreenGui: ScreenGui;
Script: Script;
ScrollingFrame: ScrollingFrame;
Seat: Seat;
SelectionBox: SelectionBox;
SelectionPartLasso: SelectionPartLasso;
SelectionPointLasso: SelectionPointLasso;
SelectionSphere: SelectionSphere;
Shirt: Shirt;
ShirtGraphic: ShirtGraphic;
SkateboardController: SkateboardController;
SkateboardPlatform: SkateboardPlatform;
Sky: Sky;
Smoke: Smoke;
Snap: Snap;
Sound: Sound;
SoundGroup: SoundGroup;
Sparkles: Sparkles;
SpawnLocation: SpawnLocation;
SpecialMesh: SpecialMesh;
SphereHandleAdornment: SphereHandleAdornment;
SpotLight: SpotLight;
SpringConstraint: SpringConstraint;
StarterGear: StarterGear;
StringValue: StringValue;
StudioAttachment: StudioAttachment;
StudioCallout: StudioCallout;
StyleDerive: StyleDerive;
StyleLink: StyleLink;
StyleRule: StyleRule;
StyleSheet: StyleSheet;
SunRaysEffect: SunRaysEffect;
SurfaceAppearance: SurfaceAppearance;
SurfaceGui: SurfaceGui;
SurfaceLight: SurfaceLight;
SurfaceSelection: SurfaceSelection;
SwimController: SwimController;
Team: Team;
TeleportOptions: TeleportOptions;
TerrainDetail: TerrainDetail;
TerrainRegion: TerrainRegion;
TextBox: TextBox;
TextButton: TextButton;
TextChannel: TextChannel;
TextChatCommand: TextChatCommand;
TextChatMessageProperties: TextChatMessageProperties;
TextLabel: TextLabel;
Texture: Texture;
Tool: Tool;
Torque: Torque;
TorsionSpringConstraint: TorsionSpringConstraint;
TrackerStreamAnimation: TrackerStreamAnimation;
Trail: Trail;
TremoloSoundEffect: TremoloSoundEffect;
TrussPart: TrussPart;
UIAspectRatioConstraint: UIAspectRatioConstraint;
UICorner: UICorner;
UIFlexItem: UIFlexItem;
UIGradient: UIGradient;
UIGridLayout: UIGridLayout;
UIListLayout: UIListLayout;
UIPadding: UIPadding;
UIPageLayout: UIPageLayout;
UIScale: UIScale;
UISizeConstraint: UISizeConstraint;
UIStroke: UIStroke;
UITableLayout: UITableLayout;
UITextSizeConstraint: UITextSizeConstraint;
UnionOperation: UnionOperation;
UniversalConstraint: UniversalConstraint;
UnreliableRemoteEvent: UnreliableRemoteEvent;
UserNotification: UserNotification;
UserNotificationPayload: UserNotificationPayload;
UserNotificationPayloadAnalyticsData: UserNotificationPayloadAnalyticsData;
UserNotificationPayloadJoinExperience: UserNotificationPayloadJoinExperience;
UserNotificationPayloadParameterValue: UserNotificationPayloadParameterValue;
Vector3Curve: Vector3Curve;
Vector3Value: Vector3Value;
VectorForce: VectorForce;
VehicleController: VehicleController;
VehicleSeat: VehicleSeat;
VelocityMotor: VelocityMotor;
VideoFrame: VideoFrame;
ViewportFrame: ViewportFrame;
WedgePart: WedgePart;
Weld: Weld;
WeldConstraint: WeldConstraint;
Wire: Wire;
WireframeHandleAdornment: WireframeHandleAdornment;
WorldModel: WorldModel;
WrapLayer: WrapLayer;
WrapTarget: WrapTarget;
}
interface AbstractInstances {
BackpackItem: BackpackItem;
BasePart: BasePart;
BasePlayerGui: BasePlayerGui;
BaseScript: BaseScript;
BevelMesh: BevelMesh;
BodyMover: BodyMover;
CharacterAppearance: CharacterAppearance;
Clothing: Clothing;
Constraint: Constraint;
Controller: Controller;
DataModelMesh: DataModelMesh;
DynamicRotate: DynamicRotate;
FaceInstance: FaceInstance;
Feature: Feature;
FormFactorPart: FormFactorPart;
GenericSettings: GenericSettings;
GuiBase: GuiBase;
GuiBase2d: GuiBase2d;
GuiBase3d: GuiBase3d;
GuiButton: GuiButton;
GuiLabel: GuiLabel;
GuiObject: GuiObject;
HandleAdornment: HandleAdornment;
HandlesBase: HandlesBase;
Instance: Instance;
JointInstance: JointInstance;
LayerCollector: LayerCollector;
Light: Light;
LuaSourceContainer: LuaSourceContainer;
ManualSurfaceJointInstance: ManualSurfaceJointInstance;
Pages: Pages;
PartAdornment: PartAdornment;
PostEffect: PostEffect;
PVAdornment: PVAdornment;
PVInstance: PVInstance;
SelectionLasso: SelectionLasso;
ServiceProvider: ServiceProvider;
SlidingBallConstraint: SlidingBallConstraint;
SoundEffect: SoundEffect;
TriangleMeshPart: TriangleMeshPart;
TweenBase: TweenBase;
UIBase: UIBase;
UIComponent: UIComponent;
UIConstraint: UIConstraint;
UIGridStyleLayout: UIGridStyleLayout;
UILayout: UILayout;
ValueBase: ValueBase;
WorldRoot: WorldRoot;
}
interface Instances extends Services, CreatableInstances, AbstractInstances {
AnimationClip: AnimationClip;
AnimationImportData: AnimationImportData;
AnimationStreamTrack: AnimationStreamTrack;
AnimationTrack: AnimationTrack;
AssetImportSession: AssetImportSession;
AssetPatchSettings: AssetPatchSettings;
AssetSoundEffect: AssetSoundEffect;
AudioPages: AudioPages;
BaseImportData: BaseImportData;
BaseRemoteEvent: BaseRemoteEvent;
BaseWrap: BaseWrap;
BubbleChatConfiguration: BubbleChatConfiguration;
CatalogPages: CatalogPages;
ChannelSelectorSoundEffect: ChannelSelectorSoundEffect;
ChatInputBarConfiguration: ChatInputBarConfiguration;
ChatWindowConfiguration: ChatWindowConfiguration;
CloudLocalizationTable: CloudLocalizationTable;
Collaborator: Collaborator;
CommandInstance: CommandInstance;
ControllerBase: ControllerBase;
ControllerSensor: ControllerSensor;
CustomSoundEffect: CustomSoundEffect;
DataModel: DataModel;
DataStore: DataStore;
DataStoreInfo: DataStoreInfo;
DataStoreKey: DataStoreKey;
DataStoreKeyInfo: DataStoreKeyInfo;
DataStoreKeyPages: DataStoreKeyPages;
DataStoreListingPages: DataStoreListingPages;
DataStoreObjectVersionInfo: DataStoreObjectVersionInfo;
DataStorePages: DataStorePages;
DataStoreVersionPages: DataStoreVersionPages;
DebuggerConnection: DebuggerConnection;
DebuggerLuaResponse: DebuggerLuaResponse;
DebuggerVariable: DebuggerVariable;
EmotesPages: EmotesPages;
FacialAnimationStreamingServiceStats: FacialAnimationStreamingServiceStats;
FacialAnimationStreamingSubsessionStats: FacialAnimationStreamingSubsessionStats;
FacsImportData: FacsImportData;
FriendPages: FriendPages;
GlobalDataStore: GlobalDataStore;
GroupImportData: GroupImportData;
InputObject: InputObject;
InstanceAdornment: InstanceAdornment;
InventoryPages: InventoryPages;
JointImportData: JointImportData;
LocalDebuggerConnection: LocalDebuggerConnection;
LodDataEntity: LodDataEntity;
MaterialGenerationSession: MaterialGenerationSession;
MaterialImportData: MaterialImportData;
MemoryStoreHashMap: MemoryStoreHashMap;
MemoryStoreQueue: MemoryStoreQueue;
MemoryStoreSortedMap: MemoryStoreSortedMap;
MeshImportData: MeshImportData;
MessageBusConnection: MessageBusConnection;
MetaBreakpoint: MetaBreakpoint;
MetaBreakpointContext: MetaBreakpointContext;
Mouse: Mouse;
NetworkMarker: NetworkMarker;
OpenCloudApiV1: OpenCloudApiV1;
OrderedDataStore: OrderedDataStore;
OutfitPages: OutfitPages;
PackageLink: PackageLink;
ParabolaAdornment: ParabolaAdornment;
PatchMapping: PatchMapping;
Path: Path;
PausedState: PausedState;
PausedStateBreakpoint: PausedStateBreakpoint;
PausedStateException: PausedStateException;
Platform: Platform;
Player: Player;
PlayerGui: PlayerGui;
PlayerMouse: PlayerMouse;
PlayerScripts: PlayerScripts;
PluginManagerInterface: PluginManagerInterface;
PoseBase: PoseBase;
RootImportData: RootImportData;
ScreenshotHud: ScreenshotHud;
ScriptBuilder: ScriptBuilder;
ScriptDocument: ScriptDocument;
ScriptRuntime: ScriptRuntime;
SensorBase: SensorBase;
StackFrame: StackFrame;
StandardPages: StandardPages;
StarterCharacterScripts: StarterCharacterScripts;
StarterPlayerScripts: StarterPlayerScripts;
StudioObjectBase: StudioObjectBase;
StudioWidget: StudioWidget;
StyleBase: StyleBase;
SurfaceGuiBase: SurfaceGuiBase;
SyncScriptBuilder: SyncScriptBuilder;
TeleportAsyncResult: TeleportAsyncResult;
Terrain: Terrain;
TextChatConfigurations: TextChatConfigurations;
TextChatMessage: TextChatMessage;
TextFilterResult: TextFilterResult;
TextFilterTranslatedResult: TextFilterTranslatedResult;
TextSource: TextSource;
ThreadState: ThreadState;
TouchTransmitter: TouchTransmitter;
TrackerLodController: TrackerLodController;
Translator: Translator;
Tween: Tween;
UserGameSettings: UserGameSettings;
UserSettings: UserSettings;
}
// GENERATED ROBLOX INSTANCE CLASSES
/** Instance is the base class for all classes in the Roblox class hierarchy. Every other class that the Roblox engine defines inherits all of the members of Instance. It is not possible to directly create Instance objects.
*
* Instance has a special function called `Instance.new` which is used to create objects via code. This function takes the name of the class as a parameter and returns the created object. Abstract classes and services cannot be created with the Instance.new function.
*/
interface Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Instance: unique symbol;
/**
* This property determines whether an [object](https://developer.roblox.com/en-us/api-reference/class/Instance) should be included when the game is published or saved, or when [Instance:Clone](https://developer.roblox.com/en-us/api-reference/function/Instance/Clone) is called on one of the object's ancestors. Calling Clone directly on an object will return nil if the cloned object is not archivable. Copying an object in Studio (using the 'Duplicate' or 'Copy' options) will ignore the Archivable property and set Archivable to true for the copy.
*
* local part = Instance.new("Part")
* print(part:Clone()) --> Part
* part.Archivable = false
* print(part:Clone()) --> nil
*/
Archivable: boolean;
/**
* A read-only string representing the class this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) belongs to.
*
* This property can be used with various other functions of Instance that are used to identify objects by type, such as [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/IsA) or [Instance:FindFirstChildOfClass](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChildOfClass).
*
* Note this property is read only and cannot be altered by scripts. Developers wishing to change an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s class will instead have to create a new [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* Unlike [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/IsA), ClassName can be used to check if an object belongs to a specific class ignoring class inheritance. For example:
*
* for \_, child in ipairs(game.Workspace:GetChildren()) do
* if child.ClassName == "Part" then
* print("Found a Part")
* -- will find Parts in model, but NOT TrussParts, WedgeParts, etc
* end
* end
*
* Tags: NotReplicated
*/
readonly ClassName: string;
/**
* A non-unique identifier of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* This property is an identifier that describes an object. Names are not necessarily unique identifiers however; multiple children of an object may share the same name. Names are used to keep the object hierarchy organized, along with allowing scripts to access specific objects.
*
* The name of an object is often used to access the object through the data model hierarchy using the following methods:
*
* local baseplate = workspace.Baseplate
* local baseplate = workspace\["Baseplate"\]
* local baseplate = workspace:FindFirstChild("BasePlate")
*
* In order to make an object accessible using the dot operator, an object's Name must follow a certain syntax. The objects name must start with an underscore or letter. The rest of the name can only contain letters, numbers, or underscores (no other special characters). If an objects name does not follow this syntax it will not be accessible using the dot operator and Lua will not interpret its name as an identifier.
*
* If more than one object with the same name are siblings then any attempt to index an object by that name will return the only one of the objects found similar to [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild), but not always the desired object. If a specific object needs to be accessed through code, it is recommended to give it a unique name, or guarantee that none of its siblings share the same name as it.
*
* Note, a full name showing the instance's hierarchy can be obtained using [Instance:GetFullName](https://developer.roblox.com/en-us/api-reference/function/Instance/GetFullName).
*/
Name: string;
/**
* The Parent property determines the hierarchical parent of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). The following terminology is commonly used when talking about how this property is set:
*
* * An object is a **child** (**parented to**) another object when its Parent is set to that object.
* * The **descendants** of an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) are the children of that object, plus the descendants of the children as well.
* * The **ancestors** of an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) are all the objects that the Instance is a descendant of.
*
* It is from this property that many other API members get their name, such as [GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) and [FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild).
*
* The [Remove](https://developer.roblox.com/en-us/api-reference/function/Instance/Remove) function sets this property to nil. Calling [Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) will set the Parent of an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) and all of its descendants to `nil`, and also **lock** the Parent property. An error is raised when setting the Parent of a destroyed object.
*
* This property is also used to manage whether an object exists in the game or needs be be removed. As long as an objects parent is in the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel), is stored in a variable, or is referenced by another objects property, then the object remains in the game. Otherwise, the object will automatically be removed. The top level [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) object (the one referred to as the `game` by scripts) has no parent, but always has a reference held to it by the game engine, and exists for the duration of a session.
*
* Newly created objects using `Instance.new` will not have a parent, and usually will not be visible or function until one is set. The most elementary creation of an object has two steps: creating the object, then setting its parent.
*
* \-- Create a part and parent it to the workspace
* local part = Instance.new("Part")
* part.Parent = workspace
* -- Instance new can also take Parent as a second parameter
* Instance.new("NumberValue", workspace)
*
* Object Replication
* ==================
*
* An object created by server will not replicate to clients until it is parented to some object that is replicated. When creating an object then setting many properties, it's recommended to **set Parent last**. This ensures the object replicates once, instead of replicating many property changes.
*
* local part = Instance.new("Part") -- Avoid using the second parameter here
* part.Anchored = true
* part.BrickColor = BrickColor.new("Really red")
* -- Potentially many other property changes could go here here...
* -- Always set parent last!
* part.Parent = workspace
*
* However, if you were parenting your parts to a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) whose parent hasn't been set yet, then setting the parent first would not matter as the model would not have replicated yet.
*
* Tags: NotReplicated
*/
Parent: Instance | undefined;
AddTag(this: Instance, tag: string): void;
/**
* This function destroys all of an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s children.
*
* As [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) also calls itself on the children of an object it is used on, this function will destroy all descendants.
*
* Alternatives to ClearAllChildren
* --------------------------------
*
* If the developer does not wish to destroy all descendants, they should use [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) or [Instance:GetDescendants](https://developer.roblox.com/en-us/api-reference/function/Instance/GetDescendants) to loop through an object and select what to destroy. For example, the following code sample will destroy all parts in an object.
*
* for \_, instance in pairs(object:GetDescendants()) do
* if instance:IsA("BasePart") then
* instance:Destroy()
* end
* end
*/
ClearAllChildren(this: Instance): void;
/**
* **Clone** creates a copy of an object and all of its descendants, ignoring all objects that are not [Archivable](https://developer.roblox.com/en-us/api-reference/property/Instance/Archivable). The copy of the root object is returned by this function and its [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is set to nil.
*
* If a reference property such as [ObjectValue.Value](https://developer.roblox.com/en-us/api-reference/property/ObjectValue/Value) is set in a cloned object, the value of the copy's property depends on original's value:
*
* * If a reference property refers to an object that was **also** cloned, an _internal reference_, the copy will refer to the copy.
* * If a reference property refers to an object that was **not** cloned, an _external reference_, the same value is maintained in the copy.
*
* This function is typically used to create models that can be regenerated. First, get a reference to the original object. Then, make a copy of the object and insert the copy by setting its [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) or one of its descendants. Finally, when it's time to regenerate the model, [Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) the copy and clone a new one from the original like before.
*/
Clone(this: T): T;
/**
* Sets the [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property to nil, locks the [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property, disconnects all connections, and calls Destroy on all children. This function 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 (this is called a **memory leak**) which can lead to serious performance issues over time.
*
* **Tip:** 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.
*
* 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 [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) has been destroyed by this method it cannot be reused because the [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property is locked. To temporarily remove an object, set [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) it to nil instead. For example:
*
* object.Parent = nil
* wait(2)
* object.Parent = workspace
*
* To Destroy an object after a set amount of time, use [Debris:AddItem](https://developer.roblox.com/en-us/api-reference/function/Debris/AddItem).
*/
Destroy(this: Instance): void;
/**
* Returns the first ancestor of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) whose [Instance.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) is equal to the given name.
*
* This function works upwards, meaning it starts at the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s immediate [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) and works up towards the [DataModel](https://developer.roblox.com/en-us/api-reference/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 function that find ancestors of a specific class, please see [Instance:FindFirstAncestorOfClass](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestorOfClass) and [Instance:FindFirstAncestorWhichIsA](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestorWhichIsA).
*/
FindFirstAncestor(this: Instance, name: string): Instance | undefined;
/**
* Returns the first ancestor of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) whose [Instance.ClassName](https://developer.roblox.com/en-us/api-reference/property/Instance/ClassName) is equal to the given className.
*
* This function works upwards, meaning it starts at the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s immediate [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) and works up towards the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel). If no matching ancestor is found, it returns nil.
*
* A common use of this function is finding the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) belongs to. For example:
*
* local model = part:FindFirstAncestorOfClass("Model")
*
* This function is a variant of [Instance:FindFirstAncestor](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestor) which checks the [Instance.ClassName](https://developer.roblox.com/en-us/api-reference/property/Instance/ClassName) property rather than [Instance.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name). [Instance:FindFirstAncestorWhichIsA](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestorWhichIsA) also exists, using the [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/IsA) method instead to respect class inheritance.
*/
FindFirstAncestorOfClass(this: Instance, className: T): Instances[T] | undefined;
/**
* Returns the first ancestor of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) for whom [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/IsA) returns true for the given className.
*
* This function works upwards, meaning it starts at the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s immediate [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) and works up towards the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel). If no matching ancestor is found, it returns nil.
*
* Unlike [Instance:FindFirstAncestorOfClass](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestorOfClass), this function uses [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/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 [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) ancestor, regardless of if it is a [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart), [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) or [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* local part = object:FindFirstAncestorWhichIsA("BasePart")
*
* See also, [Instance:FindFirstAncestor](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstAncestor).
*/
FindFirstAncestorWhichIsA(this: Instance, className: T): Instances[T] | undefined;
/**
* Returns the first child of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) found with the given name. If no child exists with the given name, this function returns nil. If the optional recursive argument is true, this function searches all descendants rather than only the immediate children of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). Use this function if your code cannot guarantee the existence of an object with a given name.
*
* Checking the Existence of An Object
* -----------------------------------
*
* FindFirstChild is necessary if you need to verify an object something exists before continuing. Attempting to index a child by name using the dot operator throws an error if the child doesn't exist.
*
* \-- The following line errors if Part doesn't exist in the Workspace:
* workspace.Part.Transparency = 0.5
*
* Use FindFirstChild to first check for Part, then use an if-statement to run code that needs it.
*
* local part = workspace:FindFirstChild("Part")
* if part then
* part.Transparency = 0.5
* end
*
* Finding a Child Whose Name Matches a Property
* ---------------------------------------------
*
* Sometimes the [Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) of an object is the same as that of a property of its [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent). When using the dot operator, properties take precedence over children if they share a name.
*
* In the following example, a [Folder](https://developer.roblox.com/en-us/api-reference/class/Folder) called “Color” is added to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part), which also has the `Part/Color` property. `Part.Color` refers to the [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3), not the Folder.
*
* local part = Instance.new("Part")
* local folder = Instance.new("Folder")
* folder.Name = "Color"
* folder.Parent = part
* local c = part.Color --> A Color3
* local c2 = part:FindFirstChild("Color") --> The Folder
*
* A benefit of using FindFirstChild in this way is that the introduction of new properties does not impose a risk on your code.
*
* **Tip:** If you only need to use the result of a FindFirstChild call once, such as getting the property of a child if it exists, you can use the following syntax with the `and` operator:
*
* local myColor = workspace:FindFirstChild("SomePart") and workspace.SomePart.Color
*
* If SomePart exists, `myColor` will contain the Color of SomePart. Otherwise, it'll be nil without throwing an error. This works due to short-circuiting: Lua ignores the right side if the left is nil/false
*
* Performance Note
* ----------------
*
* FindFirstChild takes about 20% longer than using dot operator, and almost 8 times longer than simply storing a reference to an object. Therefore, you should avoid calling FindFirstChild in performance dependent code, such as in tight loops or functions connected to [RunService.Heartbeat](https://developer.roblox.com/en-us/api-reference/event/RunService/Heartbeat)/[RunService.RenderStepped](https://developer.roblox.com/en-us/api-reference/event/RunService/RenderStepped). **Store the result in a variable,** or consider using [ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded) or [WaitForChild](https://developer.roblox.com/en-us/api-reference/function/Instance/WaitForChild) to detect when a child of a given name becomes available.
*/
FindFirstChild(this: Instance, childName: string | number, recursive?: boolean): Instance | undefined;
/**
* Returns the first child of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) whose [ClassName](https://developer.roblox.com/en-us/api-reference/property/Instance/ClassName) is equal to the given className.
*
* If no matching child is found, this function returns nil.
*
* Unlike [Instance:FindFirstChildWhichIsA](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChildWhichIsA) this function uses only returns objects whose class matches the given className, ignoring class inheritance.
*
* Developers looking for a child by name should use [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild) instead.
*/
FindFirstChildOfClass(this: Instance, className: T): Instances[T] | undefined;
/**
* Returns the first child of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) for whom [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/IsA) returns true for the given className.
*
* If no matching child is found, this function returns nil. If the optional recursive argument is true, this function searches all descendants rather than only the immediate children of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* Unlike [Instance:FindFirstChildOfClass](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChildOfClass), this function uses [Instance:IsA](https://developer.roblox.com/en-us/api-reference/function/Instance/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 [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) child, regardless of if it is a [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart), [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) or [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* local part = object:FindFirstChildWhichIsA("BasePart")
*
* Developers looking for a child by name, should use [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild) instead.
*/
FindFirstChildWhichIsA(
this: Instance,
className: T,
recursive?: boolean,
): Instances[T] | undefined;
/**
* Returns the first descendant found with the given [Instance.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name).
*/
FindFirstDescendant(this: Instance, name: string): Instance | undefined;
/**
* Returns the Actor associated with the Instance, usually the first Actor ancestor
*/
GetActor(this: Instance): Actor;
/**
* This function returns the attribute which has been assigned to the given name. If no attribute has been assigned then nil is returned.
*
* For example, the following code snippet will set the value of the instance's `InitialPostion` attribute. Note that this code sample does not define [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance):
*
* local initialPosition = instance:GetAttribute("InitialPosition")
*
* See also
* ========
*
* * [Instance:SetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/SetAttribute), sets the attribute with the given name to the given value
* * [Instance:GetAttributes](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributes), returns a dictionary of string → variant pairs for each of the instance's attributes
* * [Instance.AttributeChanged](https://developer.roblox.com/en-us/api-reference/event/Instance/AttributeChanged), fires whenever an attribute is changed on the instance
* * [Instance:GetAttributeChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributeChangedSignal), returns an event that fires when the given attribute changes
*/
GetAttribute(this: Instance, attribute: string): AttributeValue | undefined;
/**
* This function returns an event that behaves exactly like the `Changed` event, except that the event only fires when the given attribute changes. It's generally a good idea to use this method instead of a connection to 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.
*
* It is similar to [Instance:GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal) but for attributes.
*
* For example, the following code snippet will return a signal that fires the function [Instance.AttributeChanged](https://developer.roblox.com/en-us/api-reference/event/Instance/AttributeChanged) when the instance's `InitialPosition` attribute changes. Note that this code sample does not define [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance):
*
* local function attributeChanged()
* print(“Attribute changed”)
* end
*
* instance:GetAttributeChangedSignal("InitialPosition"):Connect(attributeChanged)
*
* See also
* ========
*
* * [Instance:SetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/SetAttribute), sets the attribute with the given name to the given value
* * [Instance:GetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttribute), returns the attribute which has been assigned to the given name
* * [Instance:GetAttributes](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributes), returns a dictionary of string → variant pairs for each of the instance's attributes
* * [Instance.AttributeChanged](https://developer.roblox.com/en-us/api-reference/event/Instance/AttributeChanged), fires whenever an attribute is changed on the instance
*/
GetAttributeChangedSignal(this: Instance, attribute: string): RBXScriptSignal;
/**
* This function returns 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.
*
* For example, the following code snippet will print an instance's attributes and values. Note that this code sample does not define [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance):
*
* local attributes = instance:GetAttributes()
* for name, value in pairs(attributes) do
* print(name .. “ “ .. value)
* end
*
* See also
* ========
*
* * [Instance:SetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/SetAttribute), sets the attribute with the given name to the given value
* * [Instance:GetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttribute), returns the attribute which has been assigned to the given name
* * [Instance.AttributeChanged](https://developer.roblox.com/en-us/api-reference/event/Instance/AttributeChanged), fires whenever an attribute is changed on the instance
* * [Instance:GetAttributeChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributeChangedSignal), returns an event that fires when the given attribute changes
*/
GetAttributes(this: Instance): Map;
/**
* Returns an array (a numerically indexed table) containing all of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s direct children, or every [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) whose [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is equal to the object. The array can be iterated upon using either a numeric or generic for-loop:
*
* \-- Numeric for-loop example
* local children = workspace:GetChildren()
* for i = 1, #children do
* local child = children\[i\]
* print(child.Name .. " is child number " .. i)
* end\-- Generic for-loop example
* local children = workspace:GetChildren()
* for i, child in ipairs(children) do
* print(child.Name .. " is child number " .. i)
* end
*
* The children are sorted by the order in which their [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property was set to the object.
*
* See also the [GetDescendants](https://developer.roblox.com/en-us/api-reference/function/Instance/GetDescendants) function.
*/
GetChildren(this: Instance): Array;
/**
* The **GetDescendants** function of an object returns an array that contains all of the descendants of that object. Unlike [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren), which only returns the immediate children of an object, GetDescendants will find every child of the object, every child of those children, and so on.
*
* The arrays returned by GetDescendants are arranged so that parents come earlier than their children. Refer to the following example of a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace):
*
* 
*
* Inside this model are three parts (C, D, and E) and another model (InnerModel). Inside the inner model are two more parts (A and B). Calling GetDescendants on the first model and printing the contents of the returned array would print the first level of children (InnerModel, C, D, and E) before A and B.
*
* local descendants = game.Workspace.Model:GetDescendants()
*
* -- Loop through all of the descendants of the model and
* -- print out their name
* for index, descendant in pairs(descendants) do
* print(descendant.Name)
* end
*
* -- Prints:
* -- C
* -- D
* -- E
* -- InnerModel
* -- A
* -- B
*
* Tags: CustomLuaState
*/
GetDescendants(this: Instance): Array;
/**
* Returns a string describing the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s ancestry. The string is a concatenation of the [Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) of the object and its ancestors, separated by periods. The [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) (`game`) is not considered. For example, a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) may return `Workspace.Part`.
*
* When called on an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) that is not a descendant of the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel), this function considers all ancestors up to and including the topmost one without a [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent).
*
* This function is useful for logging and debugging. You shouldn't attempt to parse the returned string for any useful operation; this function does not escape periods (or any other symbol) in object names. In other words, although its output often appears to be a valid Lua identifier, it is not guaranteed.
*/
GetFullName(this: Instance): string;
/**
* This method returns an event that behaves exactly like the `Changed` event, except that the event only fires when the given property changes. It's generally a good idea to use this method instead of a connection to `Changed` 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.
*
* `print(object:GetPropertyChangedSignal("Name") == object:GetPropertyChangedSignal("Name")) --> always true`
*
* [ValueBase](https://developer.roblox.com/en-us/api-reference/class/ValueBase) objects, such as [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue) and [StringValue](https://developer.roblox.com/en-us/api-reference/class/StringValue), use a modified `Changed` event that fires with the contents of the `Value` property. As such, this method provides a way to detect changes in other properties of those objects. For example, to detect changes in the `Name` property of an [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue), use `IntValue:GetPropertyChangedSignal("Name"):Connect(someFunc)` since the `Changed` event of [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue) objects only detect changes on the `Value` property.
*/
GetPropertyChangedSignal(
this: T,
propertyName: InstancePropertyNames,
): RBXScriptSignal<() => void>;
GetTags(this: Instance): unknown;
HasTag(this: Instance, tag: string): boolean;
/**
* IsA returns true if the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s class is **equivalent to** or a **subclass** of a given class. This function is similar to the **instanceof** operators in other languages, and is a form of [type introspection](https://en.wikipedia.org/wiki/Type_introspection). To ignore class inheritance, test the [ClassName](https://developer.roblox.com/en-us/api-reference/property/Instance/ClassName) property directly instead. For checking native Lua data types (number, string, etc) use the functions `type` and `typeof`.
*
* Most commonly, this function is used to test if an object is some kind of part, such as [Part](https://developer.roblox.com/en-us/api-reference/class/Part) or [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart), which inherits from [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) (an abstract class). For example, if your goal is to change all of a [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character)'s limbs to the same color, you might use [GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) to iterate over the children, then use IsA to filter non-[BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) objects which lack the `BrickColor` property:
*
* local function paintFigure(character, color)
* -- Iterate over the child objects of the character
* for \_, child in pairs(character:GetChildren()) do
* -- Filter out non-part objects, such as Shirt, Pants and Humanoid
* -- R15 use MeshPart and R6 use Part, so we use BasePart here to detect both:
* if child:IsA("BasePart") then
* child.BrickColor = color
* end
* end
* end
* paintFigure(game.Players.Player.Character, BrickColor.new("Bright blue"))
*
* Since all classes inherit from [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), calling `object:IsA("Instance")` will always return true.
*
* Tags: CustomLuaState
*/
IsA(this: Instance, className: T): this is Instances[T];
/**
* Returns true if an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) is an ancestor of the given descendant.
*
* An [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) is considered the ancestor of an object if the object's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) or one of it's parent's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is set to the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* See also, [Instance:IsDescendantOf](https://developer.roblox.com/en-us/api-reference/function/Instance/IsDescendantOf).
*/
IsAncestorOf(this: Instance, descendant: Instance): boolean;
/**
* Returns true if an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) is a descendant of the given ancestor.
*
* An [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) is considered the descendant of an object if the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s parent or one of its parent's parent is set to the object.
*
* Note, [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) is a descendant of nil. This means IsDescendantOf cannot be used with a parameter of nil to check if an object has been removed.
*
* See also, [Instance:IsAncestorOf](https://developer.roblox.com/en-us/api-reference/function/Instance/IsAncestorOf).
*/
IsDescendantOf(this: Instance, ancestor: Instance): boolean;
IsPropertyModified(this: Instance, name: string): boolean;
RemoveTag(this: Instance, tag: string): void;
ResetPropertyToDefault(this: Instance, name: string): void;
/**
* This function sets the attribute with the given name to the given value. If the value given is nil, then the attribute will be removed (since nil is returned by default).
*
* For example, the following code snippet will set the instance's `InitialPosition` attribute to [Vector3.new(0, 0, 0)](https://developer.roblox.com/en-us/api-reference/datatype/Vector3). Note that this code sample does not define [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance):
*
* instance:SetAttribute("InitialPosition", Vector3.new(0, 0, 0))
*
* Limitations
* ===========
*
* Naming requirements and restrictions:
*
* * Names must only use alphanumeric characters and underscore
* * No spaces or unique symbols are allowed
* * Strings must be 100 characters or less
* * Names are not allowed to start with RBX unless the caller is a Roblox core-script (reserved for Roblox)
*
* When attempting to set an attribute to an unsupported type, an error will be thrown.
*
* See also
* ========
*
* * [Instance:GetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttribute), returns the attribute which has been assigned to the given name
* * [Instance:GetAttributes](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributes), returns a dictionary of string → variant pairs for each of the instance's attributes
* * [Instance.AttributeChanged](https://developer.roblox.com/en-us/api-reference/event/Instance/AttributeChanged), fires whenever an attribute is changed on the instance
* * [Instance:GetAttributeChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributeChangedSignal), returns an event that fires when the given attribute changes
*/
SetAttribute(this: Instance, attribute: string, value: AttributeValue | undefined): void;
/**
* Returns the child of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) with the given name. If the child does not exist, it will yield the current thread until it does.
*
* If the _timeOut_ parameter is specified, this function will return nil and time out after _timeOut_ seconds elapsing without the child being found.
*
* Where should WaitForChild be used?
* ----------------------------------
*
* WaitForChild is extremely important when working on code ran by the client (in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)). Roblox does not guarantee the time or order in which objects are replicated from the server to the client. This can cause scripts to break when indexing objects that do not exist yet.
*
* For example, a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) may access a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) called 'Ship' like so:
*
* local ship = workspace.Ship
* -- Will error if ship hasn't replicated
*
* However if the model 'Ship' has not replicated to the client when this code is ran an error will be returned breaking the [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Another alternative is using [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild). Not only is this good practice when indexing objects in the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) (as it avoids accidentally accessing properties) but it does not break if the object does not exist. For example:
*
* local ship = workspace:FindFirstChild("Ship")
* -- Won't error, but ship will be nil if the ship hasn't replicated
*
* Here, if the model doesn't exist the code will not error. Instead the value ship will be equal to nil. This is better, but still not much good if we want to use the ship model.
*
* Instead WaitForChild should be used:
*
* local ship = workspace:WaitForChild("Ship")
* -- Will wait until the ship has replicated before continuing
*
* Here, the thread will be yielded until the ship model has been found. This means the ship model can be used as soon as it is ready.
*
* Notes
* -----
*
* * If a call to this function exceeds 5 seconds without returning, and no _timeOut_ parameter has been specified, a warning will be printed to the output that the thread may yield indefinitely; this warning takes the form `Infinite yield possible on 'X:WaitForChild("Y")'`, where X is the parent name and Y is the child object name.
* * This function does not yield if a child with the given name exists when the call is made.
* * This function is less efficient than [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild) or the dot operator. Therefore, it should only be used when the developer is not sure if the object has replicated to the client. Generally this is only the first time the object is accessed
*
* Tags: CustomLuaState, CanYield
*/
WaitForChild(this: Instance, childName: string | number): Instance;
WaitForChild(this: Instance, childName: string | number, timeOut: number): Instance | undefined;
/**
* Fires when the [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property of the object or one of its ancestors is changed.
*
* This event includes two parameters, _child_ and _parent_. _Child_ refers to the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) whose [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) was actually changed. _Parent_ refers to this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)'s new [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent).
*
* If you need to detect when an instance is destroyed via [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy), consider the [Instance.Destroying](https://developer.roblox.com/en-us/api-reference/event/Instance/Destroying) event instead.
*/
readonly AncestryChanged: RBXScriptSignal<(child: Instance, parent: Instance | undefined) => void>;
/**
* This event fires whenever an attribute is changed on the instance. This includes when an attribute is set to nil. The name of the attribute that has been changed is passed to the connected function.
*
* For example, the following code snippet will connect the `AttributeChanged` function to fire whenever one of `Instance's` attributes changes. Note that this code sample does not define [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance):
*
* local function attributeChanged(attributeName)
* print(attributeName, “changed”)
* end
*
* instance.AttributeChanged:Connect(attributeChanged)
*
* See also
* --------
*
* * [Instance:SetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/SetAttribute), sets the attribute with the given name to the given value
* * [Instance:GetAttribute](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttribute), returns the attribute which has been assigned to the given name
* * [Instance:GetAttributes](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributes), returns a dictionary of string → variant pairs for each of the instance's attributes
* * [Instance:GetAttributeChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetAttributeChangedSignal), returns an event that fires when the given attribute changes
*/
readonly AttributeChanged: RBXScriptSignal<(attribute: string) => void>;
/**
* The Changed event fires right after most properties change on objects. It is possible to find the present value of a changed property by using `object[property]`. To get the value of a property before it changes, you must have stored the value of the property before it changed.
*
* If you are only interested in listening to the change of a specific property, consider using the `GetPropertyChangedSignal` method instead to get an event that only fires when a given property changes.
*
* This event does not fire for physics-related changes, like when the `CFrame`, `Velocity`, `RotVelocity`, `Position`, `Orientation` and `CFrame` properties of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) change due to gravity. To detect changes in these properties, consider using a physics-based event like `RunService.Stepped` or `BasePart.Touched`. A while-true-do loop can also work.
*
* For “-Value” objects, this event behaves differently: it only fires when the `Value` property changes. See individual pages for [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue), [StringValue](https://developer.roblox.com/en-us/api-reference/class/StringValue), etc for more information. To detect other changes in these objects, you must use `GetPropertyChangedSignal` instead.
*/
readonly Changed: unknown;
/**
* Fires after an object is parented to this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* Note, when using this function on a client to detect objects created by the server it is necessary to use [Instance:WaitForChild](https://developer.roblox.com/en-us/api-reference/function/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:
*
* workspace.ChildAdded:Connect(function(child)
* -- need to use WaitForChild as descendants may not have replicated yet
* local head = child:WaitForChild("Head")
* end)
*
* Note, this function only works for immediate children of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). For a function that captures all descendants, use [Instance.DescendantAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/DescendantAdded).
*
* See also, [Instance.ChildRemoved](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildRemoved).
*/
readonly ChildAdded: RBXScriptSignal<(child: Instance) => void>;
/**
* Fires after a child is removed from this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* Removed refers to when an object's parent is changed from this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) to something other than this [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). Note, this event will also fire when a child is destroyed (using [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy)) as the destroy function sets an object's parent to nil.
*
* This function only works for immediate children of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). For a function that captures all descendants, use `Instance/DescendantRemoved`.
*
* See also [Instance.ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded).
*/
readonly ChildRemoved: RBXScriptSignal<(child: Instance) => void>;
/**
* The DescendantAdded event fires after a descendant is added to the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance).
*
* As DescendantAdded fires for every descendant, parenting an object to the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) will fire the event for this object and all of its descendants individually.
*
* Developers only concerned with the immediate children of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) should use [Instance.ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded) instead.
*
* See also [Instance.DescendantRemoving](https://developer.roblox.com/en-us/api-reference/event/Instance/DescendantRemoving).
*/
readonly DescendantAdded: RBXScriptSignal<(descendant: Instance) => void>;
/**
* DescendantRemoving fires **immediately before** the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) of a descendant of the [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) changes such that the object is no longer a descendant of the Instance. [Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) and [Remove](https://developer.roblox.com/en-us/api-reference/function/Instance/Remove) change an object's Parent to nil, so calling these on a descendant of an object will therefore cause this event to fire.
*
* Since this event fires before the the descendant's removal, the Parent of the descendant will be unchanged, i.e., it will still be a descendant at the time of this event firing. If the descendant is also a child of the object, It will also fire before ChildRemoved. There is no similar event called “DescendantRemoved”.
*
* If a descendant has children, this event fires with the descendant first followed by its descendants.
*
* Example
* -------
*
* The example below should help clarify how DescendantRemoving fires when there are several objects involved.
*
* 
*
* * Calling [Remove](https://developer.roblox.com/en-us/api-reference/function/Instance/Remove) on **PartA** would cause DescendantRemoving to fire on both **ModelA** and **Model**, in that order.
* * Setting the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) of **PartA** to **ModelB** would cause DescendantRemoving to fire on **ModelA** but not **Model** (as Model would still be an ancestor of PartA).
* * Calling [Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) on **ModelA** would cause DescendantRemoving to fire multiple times on several objects:
* 1. On **Model** with **ModelA**, **PartA** then **FireA**.
* 2. On **ModelA**, with **PartA** then **FireA**.
* 3. On **PartA** with **FireA**.
*
* Warning
* -------
*
* This event fires with the descendant object that is being removed. Attempting to set the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) of the descendant being removed to something else **will fail** with the following warning: “Something unexpectedly tried to set the parent of X to Y while trying to set the parent of X. Current parent is Z”, where X is the removing descendant, Y is the ignored parent setting, and Z is the original parent of X. Below is an example that demonstrates this:
*
* workspace.DescendantRemoving:Connect(function(descendant)
* -- Don't manipulate the parent of descendant in this function!
* -- This event fires BECAUSE the parent of descendant was manipulated,
* -- and the change hasn't happened yet, i.e. this function fires before that happens.
* -- 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 -- This triggers DescendantRemoving on Workspace:
* --> Something unexpectedly tried to set the parent of Part to NULL while trying to set the parent of Part. Current parent is Workspace.
*
* See also [DescendantAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/DescendantAdded).
*/
readonly DescendantRemoving: RBXScriptSignal<(descendant: Instance) => void>;
/**
* The Destroying event fires immediately before the Instance or one of its ancestors is destroyed.
*
* The Instance will never be deleted from memory while a connected function is still using it. However, if the function yields at any point, the Instance and its descendants will be parented to `nil`.
*/
readonly Destroying: RBXScriptSignal<() => void>;
}
interface AccessoryDescription extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AccessoryDescription: unique symbol;
AccessoryType: Enum.AccessoryType;
AssetId: number;
Instance: Instance | undefined;
IsLayered: boolean;
Order: number;
Puffiness: number;
}
interface AccountService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AccountService: unique symbol;
}
/** An Accoutrement is an object that welds its child [part](https://developer.roblox.com/en-us/api-reference/class/Part) called “Handle” to the Head of a player's character. The position and rotation of the Handle part can be changed with the [AttachmentPos](https://developer.roblox.com/en-us/api-reference/property/Accoutrement/AttachmentPos)/[Right](https://developer.roblox.com/en-us/api-reference/property/Accoutrement/AttachmentRight)/[Forward](https://developer.roblox.com/en-us/api-reference/property/Accoutrement/AttachmentForward)/[Up](https://developer.roblox.com/en-us/api-reference/property/Accoutrement/AttachmentUp) properties.
*
* Parts descending from an accoutrement will be massless when attached to other parts (e.g. with a Weld) as long as they are not the root part of the assembly returned by [GetRootPart()](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart). [GetMass()](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetMass) will return 0 for parts in this case and it will not add to the total mass or rotational inertia of the Assembly.
*
* This will not apply to a part descending from an accoutrement when an accoutrement is not welded to another part that is _**not**_ massless or one if its parts otherwise becomes root. This will not apply for the root part, it will have mass like a normal part.
*/
interface Accoutrement extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Accoutrement: unique symbol;
/**
* Sets the offset position of the object on the Player.
*
* Tags: Hidden, NotReplicated
*/
AttachmentForward: Vector3;
/**
* The exact CFrame of the Accoutrement.
*/
AttachmentPoint: CFrame;
/**
* Sets the position of the object on the Player.
*
* Tags: Hidden, NotReplicated
*/
AttachmentPos: Vector3;
/**
* Sets the offset position of the object on the Player.
*
* Tags: Hidden, NotReplicated
*/
AttachmentRight: Vector3;
/**
* Sets the offset position of the object on the Player.
*
* Tags: Hidden, NotReplicated
*/
AttachmentUp: Vector3;
}
/** The Accessory class is the successor to the legacy Hat system. It's designed to be cross-compatible with both the legacy R6 character system, and the new R15 character system.
*
* If an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) is inserted into the Accessory's Handle with the same name as an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) found in one of the character's limbs, they will connect, and the properties inherited from the [Accoutrement](https://developer.roblox.com/en-us/api-reference/class/Accoutrement) class will be ignored. Otherwise, the Accessory functions identically to a [Hat](https://developer.roblox.com/en-us/api-reference/class/Hat).
*
* Note: If two matching [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) are found the resulting [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) will be a child of the Handle of the Accessory. This differs from the legacy behavior of Hats where the Weld is always a child of the Head of the character.
*/
interface Accessory extends Accoutrement {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Accessory: unique symbol;
/**
* Specifies the AccessoryType of the Accessory. Will be [AccessoryType.Unknown](https://developer.roblox.com/en-us/api-reference/enum/AccessoryType) unless the Accessory has been equipped through the player spawning process or [Humanoid:ApplyDescription](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). If available on the Avatar shop, the Accessory item is categorized by the set [AccessoryType](https://developer.roblox.com/en-us/api-reference/enum/AccessoryType) (for example, “Hat” or “Face”).
*/
AccessoryType: Enum.AccessoryType;
}
interface Hat extends Accoutrement {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Hat: unique symbol;
}
interface AdPortal extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AdPortal: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Status: Enum.AdUnitStatus;
}
/** **Note**
*
* This service should only be used by developers who are enrolled in the [PlayFab](https://developer.rblx.playfab.com/en-US/sign-up) program.
*
* The AnalyticsService provides developers with out-of-the-box analytics so they can improve their games.
*
* Developers can report events and see visual analysis results on PlayFab webpage. For more information on how to enroll in the PlayFab Program, take a look at [this](https://devforum.roblox.com/t/join-our-playfab-program-leverage-all-the-data/653420) DevForum post.
*
* See also
* --------
*
* Developers who are interested in leveraging analytics to take their game to the next level should take a look at the [introductory article](https://developer.roblox.com/en-us/articles/using-the-analytics-service).
*/
interface AnalyticsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnalyticsService: unique symbol;
/**
* This function triggers a custom event with a custom event name data.
*
* Limits of events
* ----------------
*
* Each game server is allowed a certain number of standard events API calls based on the number of players present (more players means more events will be needed).
* The events that exceed the limit will be dropped and log an error to the developer console.
*
* * Per minute limit: 120 + numPlayers \* 20, all events shared this limit.
* * Cooldown: refresh every 10 seconds
*
* Limits of parameters
* --------------------
*
* Limit the size of parameters. The event that exceeds the limit will be dropped and log an error to the developer console.
*
* Parameters
*
* Maximum Number of Characters
*
* customData Variant
*
* 500 after serialized
*
* other string types
*
* 50
*
* See also
* --------
*
* * [AnalyticsService:FirePlayerProgressionEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FirePlayerProgressionEvent), triggers an event used to track player progression through the game
* * [AnalyticsService:FireInGameEconomyEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireInGameEconomyEvent), triggers an event used to track player actions pertaining to the in-game economy
* * [AnalyticsService:FireLogEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireLogEvent), triggers an event used to track errors and warnings experienced by players
*/
FireCustomEvent(
this: AnalyticsService,
player: Player | undefined,
eventCategory: string,
customData?: unknown,
): void;
/**
* **FireEvent** reports a custom event to PlayFab. The event is reported using a **category** and **value**, where the category is a string and the value can be a string or table. In order to use PlayFab, you must have a valid [ApiKey](https://developer.roblox.com/en-us/api-reference/property/AnalyticsService/ApiKey) set.
*
* Possible Errors
* ---------------
*
* * **“AnalyticsService can only be executed by game server.”** – Tracking can only be done on the server through a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) required by a script. See [RunService:IsServer](https://developer.roblox.com/en-us/api-reference/function/RunService/IsServer).
* * **“The ApiKey is invalid.”** – The [ApiKey](https://developer.roblox.com/en-us/api-reference/property/AnalyticsService/ApiKey) has been set, but it's invalid. Check that it is set to the correct value.
* * **“AnalyticsService can only accept valid UTF-8 characters.”** – Thrown when the value can't be serialized as UTF-8 characters. This can happen if you pass a value which has unicode characters, like emojis.
* * **“AnalyticsService failed in parse event value. Error: …”** – Thrown when there is an issue when serializing the provided value into a string.
* * **“AnalyticsService: , " and \\r\\n are not allowed in category.”** – The comma `,`, the double quote `"`, and newline characters `\r\n` cannot be used in the **category** parameter.
* * **“AnalyticsService: The event value you fired is too long.”** – Thrown if the **value** parameter was too long after serialization. The length limit is 1 KB, or 1024 bytes.
* @deprecated
*/
FireEvent(this: AnalyticsService, category: string, value: unknown): void;
/**
* This function triggers an event used to track player actions pertaining to the in-game economy.
*
* For example, it should be called to track when players acquire or spend virtual items within the economy like currency.
*
* Limits of events
* ----------------
*
* Each game server is allowed a certain number of standard events API calls based on the number of players present (more players means more events will be needed).
* The events that exceed the limit will be dropped and log an error to the developer console.
*
* * Per minute limit: 120 + numPlayers \* 20, all events shared this limit.
* * Cooldown: refresh every 10 seconds
*
* Limits of parameters
* --------------------
*
* Limit the size of parameters. The event that exceeds the limit will be dropped and log an error to the developer console.
*
* Parameters
*
* Maximum Number of Characters
*
* customData Variant
*
* 500 after serialized
*
* other string types
*
* 50
*
* See also
* --------
*
* * [AnalyticsService:FirePlayerProgressionEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FirePlayerProgressionEvent), triggers an event used to track player progression through the game
* * [AnalyticsService:FireLogEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireLogEvent), triggers an event used to track errors and warnings experienced by players
* * [AnalyticsService:FireCustomEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireCustomEvent), triggers an event used to emit a custom event
*/
FireInGameEconomyEvent(
this: AnalyticsService,
player: Player | undefined,
itemName: string,
economyAction: CastsToEnum,
itemCategory: string,
amount: number,
currency: string,
location?: { [index: string]: string },
customData?: unknown,
): void;
/**
* This function triggers an event used to track errors and warnings experienced by players.
*
* For example, it could be called to indicate when a function call fails - such as a datastore save or [TeleportService:Teleport](https://developer.roblox.com/en-us/api-reference/function/TeleportService/Teleport). See the example below.
*
* Limits of events
* ----------------
*
* Each game server is allowed a certain number of standard events API calls based on the number of players present (more players means more events will be needed).
* The events that exceed the limit will be dropped and log an error to the developer console.
*
* * Per minute limit: 120 + numPlayers \* 20, all events shared this limit.
* * Cooldown: refresh every 10 seconds
*
* Limits of parameters
* --------------------
*
* Limit the size of parameters. The event that exceeds the limit will be dropped and log an error to the developer console.
*
* Parameters
*
* Maximum Number of Characters
*
* FireLogEvent stackTrace
*
* 1000
*
* FireLogEvent message
*
* 500
*
* customData Variant
*
* 500 after serialized
*
* other string types
*
* 50
*
* See also
* --------
*
* * [AnalyticsService:FireInGameEconomyEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireInGameEconomyEvent), triggers an event used to track player actions pertaining to the in-game economy
* * [AnalyticsService:FirePlayerProgressionEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FirePlayerProgressionEvent), triggers an event used to track player progression through the game
* * [AnalyticsService:FireCustomEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireCustomEvent), triggers an event used to emit a custom event
*/
FireLogEvent(
this: AnalyticsService,
player: Player | undefined,
logLevel: CastsToEnum,
message: string,
debugInfo?: {
errorCode?: string;
stackTrace?: string;
},
customData?: unknown,
): void;
/**
* This function triggers an event used to track player progression through the game.
*
* For example, it should be called when a player starts an in-game tutorial and again that player finishes the tutorial. Another example (see below) includes tracking when a player gains experience, collects objects, and levels up.
*
* Limits of events
* ----------------
*
* Each game server is allowed a certain number of standard events API calls based on the number of players present (more players means more events will be needed).
* The events that exceed the limit will be dropped and log an error to the developer console.
*
* * Per minute limit: 120 + numPlayers \* 20, all events shared this limit.
* * Cooldown: refresh every 10 seconds
*
* Limits of parameters
* --------------------
*
* Limit the size of parameters. The event that exceeds the limit will be dropped and log an error to the developer console.
*
* Parameters
*
* Maximum Number of Characters
*
* FirePlayerProgressionEvent location
*
* 5 pairs of Key and Value, each Key and Value are 50
*
* FirePlayerProgressionEvent statistics
*
* 5 pairs of Key and Value, each Key and Value are 50
*
* customData Variant
*
* 500 after serialized
*
* other string types
*
* 50
*
* See also
* --------
*
* * [AnalyticsService:FireInGameEconomyEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireInGameEconomyEvent), triggers an event used to track player actions pertaining to the in-game economy
* * [AnalyticsService:FireLogEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireLogEvent), triggers an event used to track errors and warnings experienced by players
* * [AnalyticsService:FireCustomEvent](https://developer.roblox.com/en-us/api-reference/function/AnalyticsService/FireCustomEvent), triggers an event used to emit a custom event
*/
FirePlayerProgressionEvent(
this: AnalyticsService,
player: Player | undefined,
category: string,
progressionStatus: CastsToEnum,
location?: { [index: string]: string },
statistics?: { [index: string]: number },
customData?: unknown,
): void;
}
/** An object that references an animation asset (AnimationId) which can be loaded by a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController)
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* In order for [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) to replicate correctly, it's important to know when they should be loaded on the client (via a[LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)) or on the server (via a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* If an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) is a descendant of a Humanoid or AnimationController in a Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then animations started on that Player's client will be replicated to the server and other clients.
*
* If the Animator is not a descendant of a player character, its animations must be loaded and started on the server to replicate.
*
* The Animator object must be initially created on the server and replicated to clients for animation replication to work at all. If an Animator is created locally, then AnimationTracks loaded with that Animator will not replicate.
*
* Both [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) and [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) will create an Animator if one does not already exist. When calling LoadAnimation from LocalScripts you need to be careful to wait for the Animator to replicate from the server before calling LoadAnimation if you want character animations to replicate. You can do this with WaitForChild(“Animator”).
*
* See also
* --------
*
* * [Using the Animation Editor](https://developer.roblox.com/articles/using-animation-editor), explore this powerful built-in plugin for creating custom animations
* * [Using Animations in Games](https://developer.roblox.com/articles/using-animations-in-games), learn how to add pre-built and custom animations to your game
*/
interface Animation extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Animation: unique symbol;
/**
* This property is the content ID of the animation an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) object is referencing. Once an animation has been created and uploaded to Roblox the content ID can be found in the uploaded animation's URL.
*
* This URL is presented immediately after an animation has been uploaded to Roblox, in the Animation Editor export window. It can also be found in the Develop tab on the Roblox site, under 'Animations'.
*
* It's important to remember the URL is not the same as the content ID. It will work when pasted directly into the AnimationId property of an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) in Roblox studio, as Studio will automatically correct it, however if it is being set from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) then the correct content ID will need to be used, using the number from the URL. For example:
*
* "https://www.roblox.com/catalog/507771019" -- Web URL (will not work)
* "http://www.roblox.com/asset/?id=507771019" -- Content ID (will work)
* "rbxassetid://507771019" -- Content ID (alternative version, will work)
*
* Note, the animation will need to be loaded onto an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) in order to play it.
*/
AnimationId: string;
}
interface AnimationClip extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationClip: unique symbol;
Loop: boolean;
Priority: Enum.AnimationPriority;
}
interface CurveAnimation extends AnimationClip {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CurveAnimation: unique symbol;
}
/** This object stores all the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)s for an animation, determines if the animation is looped, and determines its priority against other animations.
*
* What is a Keyframe Sequence?
* ----------------------------
*
* The animation data Roblox uses in the playback of an animation, referenced by the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) property, is constructed from a KeyframeSequence. Every animation has a KeyframeSequence associated with it. KeyframeSequences are usually created by the Roblox Animation Editor but can be created through other plugins or even manually. Once uploaded to Roblox, their Content ID is used for the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) property.
*
* Note, in most cases developers do not need to manipulate KeyframeSequences as the animation editor covers most animation functionality. However, in some cases a developer may wish to generate an animation from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or build their own plugin.
*
* KeyframeSequence Properties
* ---------------------------
*
* The priority and looped animation settings are set by `KeyframeSequence/Priority` and `KeyframeSequence/Loop`. Note these can be eventually overwritten by the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) properties.
*
* The length of an animation is determined by the last [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) in the sequence, meaning the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) with the highest [Keyframe.Time](https://developer.roblox.com/en-us/api-reference/property/Keyframe/Time) property.
*
* KeyframeSequence Structure
* --------------------------
*
* KeyframeSequences are a container that hold [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)s. Keyframes represent a 'key' frame in the animation, that are interpolated between during playback.
*
* Keyframes contain [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s. [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s are specific to each [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) being animated and contain the `CFrame` applied to the [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connecting to the part. Poses are named according to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) they correspond with. For this reason, animations require distinct part names to play correctly.
*
* Poses are structured based on joint hierarchy. Each [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is parented to the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) corresponding to the part it is attached to. In practice, this means the poses branch out from the root part. See below for a visual example.
*
* 
*
* Using KeyframeSequences when making animations
* ----------------------------------------------
*
* KeyframeSequences must be first uploaded to Roblox before they can be played. This can be done by right clicking on the KeyframeSequence and clicking 'Save to Roblox'. Alternatively, [Plugin:SaveSelectedToRoblox](https://developer.roblox.com/en-us/api-reference/function/Plugin/SaveSelectedToRoblox) can be used. This will bring up the animation upload window.
*
* In some cases, a developer may want to preview an Animation before uploading it to the Roblox site. This can be achieved by generating a temporary id using [KeyframeSequenceProvider:RegisterKeyframeSequence](https://developer.roblox.com/en-us/api-reference/function/KeyframeSequenceProvider/RegisterKeyframeSequence). This will generate a hash id that can be used for localized animation testing.
*
* Obtaining KeyframeSequences
* ---------------------------
*
* In some cases the developer may wish to download the KeyframeSequence corresponding to an existing uploaded Animation. This can be done so using [KeyframeSequenceProvider:GetKeyframeSequenceAsync](https://developer.roblox.com/en-us/api-reference/function/KeyframeSequenceProvider/GetKeyframeSequenceAsync).
*/
interface KeyframeSequence extends AnimationClip {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_KeyframeSequence: unique symbol;
/**
* This function adds a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) to the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) by parenting it to the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence). It is functionally identical to setting the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)'s [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence).
*
* Note, this function will not error when an instance other than a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) is given as the keyframe parameter and will parent it successfully.
*/
AddKeyframe(this: KeyframeSequence, keyframe: Keyframe): void;
/**
* **GetKeyframes** returns an array that contains all [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)s that have been added to a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence).
*/
GetKeyframes(this: KeyframeSequence): Array;
/**
* This function removes a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) from the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) by setting its parent to nil. It is functionally identical to setting the keyframe's parent to nil
*
* The [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)'s parent is set to nil, but it is not destroyed. This means, provided the keyframe is referenced it can be re-parented later.
*
* Note, this function will not error when an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) other than a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) is given as the keyframe parameter.
*/
RemoveKeyframe(this: KeyframeSequence, keyframe: Keyframe): void;
}
interface AnimationClipProvider extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationClipProvider: unique symbol;
RegisterActiveAnimationClip(this: AnimationClipProvider, animationClip: AnimationClip): string;
RegisterAnimationClip(this: AnimationClipProvider, animationClip: AnimationClip): string;
/**
* Tags: Yields
*/
GetAnimationClipAsync(this: AnimationClipProvider, assetId: string): AnimationClip;
/**
* Tags: Yields
*/
GetAnimations(this: AnimationClipProvider, userId: number): Instance | undefined;
/**
* Tags: Yields
*/
GetClipEvaluatorAsync(this: AnimationClipProvider, assetId: string): ClipEvaluator;
}
/** An object which allows animations to be loaded and applied to a character or model in place of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when a Humanoid is not needed. Creates an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) and loads animations to update [Motor6Ds](https://developer.roblox.com/en-us/api-reference/class/Motor6D) of said character to react in the way that is described within the animation asset referenced by an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) object.
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* In order for [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) to replicate correctly, it's important to know when they should be loaded on the client (via a[LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)) or on the server (via a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* If an Animator is a descendant of a Humanoid or AnimationController in a Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then animations started on that Player's client will be replicated to the server and other clients.
*
* If the Animator is not a descendant of a player character, its animations must be loaded and started on the server to replicate.
*
* The Animator object must be initially created on the server and replicated to clients for animation replication to work at all. If an Animator is created locally, then AnimationTracks loaded with that Animator will not replicate.
*
* Both [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) and [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) will create an Animator if one does not already exist. When calling LoadAnimation from LocalScripts you need to be careful to wait for the Animator to replicate from the server before calling LoadAnimation if you want character animations to replicate. You can do this with WaitForChild(“Animator”).
*
* See also
* --------
*
* * [Using the Animation Editor](https://developer.roblox.com/articles/using-animation-editor), explore this powerful built-in plugin for creating custom animations
* * [Using Animations in Games](https://developer.roblox.com/articles/using-animations-in-games), learn how to add pre-built and custom animations to your game
*/
interface AnimationController extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationController: unique symbol;
/**
* Returns an array of all [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that are currently being played by the [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController).
*
* A typical use for this function is stopping currently playing tracks using [AnimationTrack:Stop](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/Stop).
*
* Note this function will not return [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that have loaded but are not playing. If the developer wishes to track these they will need to index them manually. See below for one example of how this could be achieved:
*
* local animationTracks = {}
* local track = animationController:LoadTrack(animation)
* table.insert(animationTracks, track)
* @deprecated
*/
GetPlayingAnimationTracks(this: AnimationController): Array;
/**
* This function loads an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) onto an [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController), returning an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that can be used for playback.
*
* How to load an Animation
* ------------------------
*
* The following code can be used to load an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) onto an [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController).
*
* ```lua
* local animationTrack = animationController:LoadAnimation(animation)
* animationTrack:Play()
* ```
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* In order for AnimationTracks to replicate correctly, it's important to know when they should be loaded on the client (via a[LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)) or on the server (via a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* If an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) is a descendant of a Humanoid or AnimationController in a Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then animations started on that Player's client will be replicated to the server and other clients.
*
* If the Animator is not a descendant of a player character, its animations must be loaded and started on the server to replicate.
*
* The Animator object must be initially created on the server and replicated to clients for animation replication to work at all. If an Animator is created locally, then AnimationTracks loaded with that Animator will not replicate.
*
* Both [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) and [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) will create an Animator if one does not already exist. When calling LoadAnimation from LocalScripts you need to be careful to wait for the Animator to replicate from the server before calling LoadAnimation if you want character animations to replicate. You can do this with WaitForChild(“Animator”).
*
* See also
* --------
*
* * [Using the Animation Editor](https://developer.roblox.com/articles/using-animation-editor), explore this powerful built-in plugin for creating custom animations
* * [Using Animations in Games](https://developer.roblox.com/articles/using-animations-in-games), learn how to add pre-built and custom animations to your game
* @deprecated
*/
LoadAnimation(this: AnimationController, animation: Animation): AnimationTrack;
/**
* This event fires whenever the [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController) begins playing an animation. It returns the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) playing.
*
* The [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) can be used to access the animation's playback functions and events. It will only fire for animations playing on the specific [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController).
*
* See [Humanoid.AnimationPlayed](https://developer.roblox.com/en-us/api-reference/event/Humanoid/AnimationPlayed) for the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) variant of this function.
* @deprecated
*/
readonly AnimationPlayed: RBXScriptSignal<(animationTrack: AnimationTrack) => void>;
}
interface AnimationFromVideoCreatorService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationFromVideoCreatorService: unique symbol;
}
interface AnimationFromVideoCreatorStudioService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationFromVideoCreatorStudioService: unique symbol;
}
interface AnimationRigData extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationRigData: unique symbol;
}
interface AnimationStreamTrack extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationStreamTrack: unique symbol;
/**
* Tags: Hidden, NotReplicated
*/
readonly Animation: TrackerStreamAnimation | undefined;
/**
* Tags: Hidden, NotReplicated
*/
readonly IsPlaying: boolean;
/**
* Tags: Hidden, NotReplicated
*/
Priority: Enum.AnimationPriority;
/**
* Tags: Hidden, NotReplicated
*/
readonly WeightCurrent: number;
/**
* Tags: Hidden, NotReplicated
*/
readonly WeightTarget: number;
}
/** Controls the playback of an animation on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController). This object cannot be created, instead it is returned by the [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) method. */
interface AnimationTrack extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationTrack: unique symbol;
/**
* The [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) object that was used to create this [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). To create an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) the developer must load an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) object onto a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController) using the [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) method.
*
* The Animation property is used to identify the underlying [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack).
*
* Tags: NotReplicated
*/
readonly Animation: Animation | undefined;
/**
* A read only property that returns true when the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) is playing.
*
* This property can be used by developers to check if an animation is already playing before playing it (as that would cause it to restart). If a developer wishes to obtain all playing [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack)s on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController) they should use [Humanoid:GetPlayingAnimationTracks](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetPlayingAnimationTracks)
*
* Tags: NotReplicated
*/
readonly IsPlaying: boolean;
/**
* A read only property that returns the length (in seconds) of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). This will return 0 until the animation has fully loaded and thus may not be immediately available.
*
* When the [AnimationTrack.Speed](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Speed) of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) is equal to 1, the animation will take [AnimationTrack.Length](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Length) (in seconds) to complete.
*
* Tags: NotReplicated
*/
readonly Length: number;
/**
* This property sets whether the animation will repeat after finishing. If it is changed while playing the result will take effect after the animation finishes.
*
* The Looped property for [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) defaults to how it was set in the animation editor. However this property can be changed, allowing control over the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) while the game is running. Looped also correctly handles animations played in reverse (negative [AnimationTrack.Speed](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Speed)). After the first keyframe is reached, it will restart at the last keyframe.
*
* This property allows the developer to have a looping and non looping variant of the same animation, without needing to upload two versions to Roblox.
*/
Looped: boolean;
/**
* This property sets the priority of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). Depending on what this is set to, playing multiple animations at once will look to this property to figure out which [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s should be played over one another.
*
* The Priority property for [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) defaults to how it was set in the editor. It uses the AnimationPriority Enum, which as four priority levels.
*
* 1. Core (lowest priority)
* 2. Idle
* 3. Movement
* 4. Action (highest priority)
*
* Correctly set animation priorities, either through the editor or through this property allow multiple animations to be played without them clashing. Where two playing animations direct the target to move the same limb in different ways, the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) with the highest priority will show. If both animations have the same priority, the weight of both tracks will be used to combine the animations.
*
* This property also allows the developer to play the same animation at different priorities, without needing to upload additional versions to Roblox.
*/
Priority: Enum.AnimationPriority;
/**
* The Speed of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) is a read only property that gives the current playback speed of the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). This has a default value of 1. When speed is equal to 1, the amount of time an animation takes to complete is equal to [AnimationTrack.Length](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Length) (in seconds).
*
* If the speed is adjusted, then the actual time it will take a track to play can be computed by dividing the length by the speed. Speed is a unitless quantity.
*
* Speed can be used to link the length of an animation to different game events (for example recharging an ability) without having to upload different variants of the same animation.
*
* This property is read only and is changed using [AnimationTrack:AdjustSpeed](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/AdjustSpeed).
*
* Tags: NotReplicated
*/
readonly Speed: number;
/**
* Returns the position in time in seconds that an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) is through playing its source animation. Can be set to make the track jump to a specific moment in the animation.
*
* TimePosition can be set to go to a specific point in the animation, but the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) must be playing to do so. It can also be used in combination with [AnimationTrack:AdjustSpeed](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/AdjustSpeed) to freeze the animation at a desired point (by setting speed to 0).
*
* Tags: NotReplicated
*/
TimePosition: number;
/**
* When weight is set in an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) it does not change instantaneously but moves from WeightCurrent to [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget). The time it takes to do this is determined by the fadeTime parameter given when the animation is played, or the weight is adjusted.
*
* WeightCurrent can be checked against [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget) to see if the desired weight has been reached. Note that these values should not be checked for equality with the == operator, as both of these values are floats. To see if WeightCurrent has reached the target weight, it is recommended to see if the distance between those values is sufficiently small (see code sample below).
*
* The animation weighting system is used to determine how [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack)s playing at the same priority are blended together. The default weight is one, and no movement will be visible on an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) with a weight of zero. The pose that is shown at any point in time is determined by the weighted average of all the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s and the WeightCurrent of each [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). See below for an example of animation blending in practice.
*
* 
*
* In most cases blending animations is not required and using [AnimationTrack.Priority](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Priority) is more suitable.
*
* Tags: NotReplicated
*/
readonly WeightCurrent: number;
/**
* When weight is set in an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) it does not change instantaneously but moves from WeightCurrent to [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget). The time it takes to do this is determined by the fadeTime parameter given when the animation is played, or the weight is adjusted.
*
* WeightCurrent can be checked against [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget) to see if the desired weight has been reached. Note that these values should not be checked for equality with the == operator, as both of these values are floats. To see if WeightCurrent has reached the target weight, it is recommended to see if the distance between those values is sufficiently small (see code sample below).
*
* The animation weighting system is used to determine how [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack)s playing at the same priority are blended together. The default weight is one, and no movement will be visible on an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) with a weight of zero. The pose that is shown at any point in time is determined by the weighted average of all the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s and the WeightCurrent of each [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). See below for an example of animation blending in practice.
*
* 
*
* In most cases blending animations is not required and using [AnimationTrack.Priority](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Priority) is more suitable.
*
* Tags: NotReplicated
*/
readonly WeightTarget: number;
/**
* This function changes the [AnimationTrack.Speed](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Speed) of an animation. A positive value for speed plays the animation forward, a negative one plays it backwards, and 0 pauses it.
*
* An AnimationTrack's initial speed is set as a parameter in [AnimationTrack:Play](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/Play). However a track's Speed can be changed during playback, using AdjustSpeed. When speed is equal to 1, the amount of time an animation takes to complete is equal to [AnimationTrack.Length](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Length) (in seconds).
*
* When is adjusted, then the actual time it will take a track to play can be computed by dividing the length by the speed. Speed is a unitless quantity.
*
* Speed can be used to link the length of an animation to different gameplay events (for example recharging an ability) without having to upload different variants of the same animation.
*
* Tags: CustomLuaState
*/
AdjustSpeed(this: AnimationTrack, speed?: number): void;
/**
* Changes the weight of an animation, with the optional fadeTime parameter determining how long it takes for [AnimationTrack.WeightCurrent](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightCurrent) to reach [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget).
*
* When weight is set in an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) it does not change instantaneously but moves from WeightCurrent to [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget). The time it takes to do this is determined by the fadeTime parameter given when the animation is played, or the weight is adjusted.
*
* WeightCurrent can be checked against [AnimationTrack.WeightTarget](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/WeightTarget) to see if the desired weight has been reached. Note that these values should not be checked for equality with the == operator, as both of these values are floats. To see if WeightCurrent has reached the target weight, it is recommended to see if the distance between those values is sufficiently small (see code sample below).
*
* The animation weighting system is used to determine how [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack)s playing at the same priority are blended together. The default weight is one, and no movement will be visible on an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) with a weight of zero. The pose that is shown at any point in time is determined by the weighted average of all the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s and the WeightCurrent of each [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). See below for an example of animation blending in practice.
*
* 
*
* In most cases blending animations is not required and using [AnimationTrack.Priority](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Priority) is more suitable.
*
* Tags: CustomLuaState
*/
AdjustWeight(this: AnimationTrack, weight?: number, fadeTime?: number): void;
/**
* This function returns an [event](https://developer.roblox.com/en-us/api-reference/datatype/RBXScriptSignal) similar to the [AnimationTrack.KeyframeReached](https://developer.roblox.com/en-us/api-reference/event/AnimationTrack/KeyframeReached) event, except it only fires when a specified [KeyframeMarker](https://developer.roblox.com/en-us/api-reference/class/KeyframeMarker) has been hit in an [animation](https://developer.roblox.com/en-us/api-reference/class/Animation). The difference allows for greater control of when the event will fire.
*
* To learn more about using this function, see **Animation Events** in the [Using the Animation Editor](https://developer.roblox.com/en-us/articles/using-animation-editor) article.
*
* More About Keyframes
* --------------------
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names can be set in the Roblox [Animation Editor](https://developer.roblox.com/en-us/articles/using-animation-editor) when creating or editing an animation. They cannot, however, be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on an existing animation prior to playing it.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names do not need to be unique. For example, if an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) has three keyframes named “EmitParticles,” the connected event returned by this function will fire each time one of these keyframes is reached.
*
* See Also
* --------
*
* * [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack), controls the playback of an animation on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController)
* * [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe), holds the [Poses](https://developer.roblox.com/en-us/api-reference/class/Pose) applied to joints in a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) at a given point of time in an animation
* * [Keyframe:AddMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/AddMarker)
* * [Keyframe:RemoveMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/RemoveMarker)
* * [Keyframe:GetMarkers](https://developer.roblox.com/en-us/api-reference/function/Keyframe/GetMarkers)
*/
GetMarkerReachedSignal(this: AnimationTrack, name: string): RBXScriptSignal<(param?: string) => void>;
/**
* Returns the time position of the first [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) of the given name in an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). If multiple [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)s share the same name, it will return the earliest one in the animation.
*
* This function will return an error if it is uses with an invalid keyframe name (one that does not exist for example) or if the underlying [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) has not yet loaded. To address this make sure only correct keyframe names are used and the animation has loaded before calling this function.
*
* To check if the animation has loaded, verify that the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack)'s [AnimationTrack.Length](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Length) is greater than zero.
*/
GetTimeOfKeyframe(this: AnimationTrack, keyframeName: string): number;
/**
* When [AnimationTrack:Play](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/Play) is called the track's animation will begin playing and the weight of the animation will increase from 0 to the specified weight (defaults to 1) over the specified fadeTime (defaults to 0.1).
*
* The speed the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) will play at is determined by the speed parameter (defaults to 1). When the speed is equal to 1 the number of seconds the track will take to complete is equal to the track's [AnimationTrack.Length](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/Length) property. For example, a speed of 2 will cause the track to play twice as fast.
*
* The weight and speed of the animation can also be changed after the animation has begun playing by using the [AnimationTrack:AdjustWeight](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/AdjustWeight) and [AnimationTrack:AdjustSpeed](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/AdjustSpeed) methods.
*
* If the developer wants to start the animation at a specific point using [AnimationTrack.TimePosition](https://developer.roblox.com/en-us/api-reference/property/AnimationTrack/TimePosition), it is important the animation is played before this is done.
*
* Tags: CustomLuaState
*/
Play(this: AnimationTrack, fadeTime?: number, weight?: number, speed?: number): void;
/**
* Stops the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). Once called playback of the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) will stop and the weight of the animation will move towards zero over a length of time specified by the optional fadeTime parameter.
*
* For example, if Stop is called with a fadeTime of 2 seconds it will take two seconds for the weight of the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) to reach zero and its effects completely end. Please note this will be the case regardless of the initial weight of the animation.
*
* It is not recommended to use a fadeTime of 0 seconds to try to override this effect and end the animation immediately as presently, this causes the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) poses to freeze.
*
* Tags: CustomLuaState
*/
Stop(this: AnimationTrack, fadeTime?: number): void;
/**
* This event fires whenever a looped [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) completes a loop, on the next update.
*
* Currently it may also fire at the exact end of a non looped animation track but this behavior should not be relied upon.
*/
readonly DidLoop: RBXScriptSignal<() => void>;
readonly Ended: RBXScriptSignal<() => void>;
/**
* Fires every time playback of an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) reaches a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) that does not have the default name - “Keyframe”.
*
* This event allows a developer to run code at predefined points in an animation (set by [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names). This allows the default functionality of Roblox animations to be expanded upon by adding [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound)s or `ParticleEffect`s at different points in an animation.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names do not need to be unique. For example, if an Animation has three keyframes named “Particles” the KeyframeReached event will fire each time one of these keyframes is reached.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names can be set in the Roblox Animation Editor when creating or editing an animation. They cannot however be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on an existing animation prior to playing it.
*/
readonly KeyframeReached: RBXScriptSignal<(keyframeName: string) => void>;
/**
* Fires whenever the [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) finishes playing.
*
* This event has a number of uses. It can be used to wait until an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) has stopped before continuing (for example, if chaining a series of animations to play after each other). It can also be used to clean up any [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)s created during the animation playback.
*/
readonly Stopped: RBXScriptSignal<() => void>;
}
/** The main class responsible for the playback and replication of [Animations](https://developer.roblox.com/en-us/api-reference/class/Animation). All replication of playing [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) is handled through the Animator instance.
*
* It is created when [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) or [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) is called under a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController) for the first time.
*
* For animation replication to function it is important for the Animator to be first created on the server.
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* In order for AnimationTracks to replicate correctly, it's important to know when they should be loaded on the client (via a[LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)) or on the server (via a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* If an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) is a descendant of a Humanoid or AnimationController in a Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then animations started on that Player's client will be replicated to the server and other clients.
*
* If the Animator is not a descendant of a player character, its animations must be loaded and started on the server to replicate.
*
* The Animator object must be initially created on the server and replicated to clients for animation replication to work at all. If an Animator is created locally, then AnimationTracks loaded with that Animator will not replicate.
*
* Both Humanoid:LoadAnimation() and AnimationController:LoadAnimation() will create an Animator if one does not already exist. When calling LoadAnimation from LocalScripts you need to be careful to wait for the Animator to replicate from the server before calling LoadAnimation if you want character animations to replicate. You can do this with WaitForChild(“Animator”).
*
* See also
* --------
*
* * [Using the Animation Editor](https://developer.roblox.com/articles/using-animation-editor), explore this powerful built-in plugin for creating custom animations
* * [Using Animations in Games](https://developer.roblox.com/articles/using-animations-in-games), learn how to add pre-built and custom animations to your game
*/
interface Animator extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Animator: unique symbol;
/**
* Tags: NotReplicated, NotBrowsable
*/
readonly EvaluationThrottled: boolean;
PreferLodEnabled: boolean;
/**
* Tags: NotReplicated, NotBrowsable
*/
readonly RootMotion: CFrame;
/**
* Tags: NotReplicated, NotBrowsable
*/
readonly RootMotionWeight: number;
/**
* Given the current set of [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) playing, and their current times and play speeds, compute relative velocities between the parts and apply them to Motor6D.Part1 (the part which [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) considers the “child” part). These relative velocity calculations and assignments happen in the order provided.
*
* This method doesn't apply velocities for a given joint if both of the joint's parts are currently part of the same assembly, for example, if they are still connected directly or indirectly by Motors or Welds.
*
* This method doesn't disable or remove the joints for you. You must disable or otherwise remove the rigid joints from the assembly before calling this method.
*
* The given `Motor6Ds` are not required to be descendants of the the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel). Removing the joints from the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) before calling this method is supported.
*/
ApplyJointVelocities(this: Animator, motors: Array): void;
/**
* Returns the list of currently playing [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTracks).
*/
GetPlayingAnimationTracks(this: Animator): Array;
/**
* **LoadAnimation** will load the given [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) onto an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator), returning a playable [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack). When called on Animators within models that the client has network ownership of, ie. the local player's character or from [BasePart:SetNetworkOwner](https://developer.roblox.com/en-us/api-reference/function/BasePart/SetNetworkOwner), this function also loads the animation for the server as well.
*
* You should use this function directly instead of the similarly-named [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) and [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) functions. These are deprecated proxies of this function which also create an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) if one does not exist; this can cause replication issues if you are not careful. For more information, see this [announcement post](https://devforum.roblox.com/t/deprecating-loadanimation-on-humanoid-and-animationcontroller/857129)
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* In order for AnimationTracks to replicate correctly, it's important to know when they should be loaded on the client (via a[LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)) or on the server (via a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* If an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) is a descendant of a Humanoid or AnimationController in a Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then animations started on that Player's client will be replicated to the server and other clients.
*
* If the Animator is not a descendant of a player character, its animations must be loaded and started on the server to replicate.
*
* The Animator object must be initially created on the server and replicated to clients for animation replication to work at all. If an Animator is created locally, then AnimationTracks loaded with that Animator will not replicate.
*
* Both [Humanoid:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/Humanoid/LoadAnimation) and [AnimationController:LoadAnimation](https://developer.roblox.com/en-us/api-reference/function/AnimationController/LoadAnimation) will create an Animator if one does not already exist. When calling LoadAnimation from LocalScripts you need to be careful to wait for the Animator to replicate from the server before calling LoadAnimation if you want character animations to replicate. You can do this with WaitForChild(“Animator”).
*
* See also
* --------
*
* * [Using the Animation Editor](https://developer.roblox.com/articles/using-animation-editor), explore this powerful built-in plugin for creating custom animations
* * [Using Animations in Games](https://developer.roblox.com/articles/using-animations-in-games), learn how to add pre-built and custom animations to your game
*/
LoadAnimation(this: Animator, animation: Animation): AnimationTrack;
RegisterEvaluationParallelCallback(this: Animator, callback: Callback): void;
readonly AnimationPlayed: RBXScriptSignal<(animationTrack: AnimationTrack) => void>;
}
interface AppUpdateService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AppUpdateService: unique symbol;
}
interface AssetCounterService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetCounterService: unique symbol;
}
interface AssetDeliveryProxy extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetDeliveryProxy: unique symbol;
Interface: string;
Port: number;
StartServer: boolean;
}
interface AssetImportService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetImportService: unique symbol;
}
interface AssetImportSession extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetImportSession: unique symbol;
readonly UploadComplete: RBXScriptSignal<(results: object) => void>;
readonly UploadProgress: RBXScriptSignal<(progressRatio: number) => void>;
}
interface AssetManagerService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetManagerService: unique symbol;
}
interface AssetPatchSettings extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetPatchSettings: unique symbol;
ContentId: string;
OutputPath: string;
PatchId: string;
}
/** The AssetService is a non-replicated service that handles asset related queries to the Roblox web API. Eventually, this will house all asset related queries for Roblox objects stored in the web. One should mind the [limitations](https://developer.roblox.com/en-us/articles/multi-place-games) this API has. */
interface AssetService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AssetService: unique symbol;
/**
* Tags: Yields
*/
CreateEditableImageAsync(this: AssetService, textureId: string): EditableImage;
/**
* Tags: Yields
*/
CreateEditableMeshAsync(this: AssetService, meshId: string): EditableMesh;
/**
* Tags: Yields
*/
CreateEditableMeshFromPartAsync(this: AssetService, meshPart: MeshPart): EditableMesh;
/**
* Clones a place with placeId equal to given templatePlaceId. It is placed into the inventory of the place's creator with the given name and description. This method will also return the placeId of the new place, which can be used with TeleportService. This method cannot be used to clone places that you do not own.
*
* Tags: Yields
*/
CreatePlaceAsync(this: AssetService, placeName: string, templatePlaceID: number, description?: string): number;
/**
* This function has been removed as of Release 471.
*
* Clones a place which has a placeId equal to the given templatePlaceID, placing it into the inventory of the given player with the given name and description, if they accept when prompted. This method cannot be used to clone places that you do not own, or those which have disabled the use of the CreatePlace API in their place's configuration.
*
* Tags: Yields
*/
CreatePlaceInPlayerInventoryAsync(this: AssetService, player: Player, placeName: string, templatePlaceID: number, description?: string): number;
/**
* Returns an array of assetIds that are contained in a specified package.
*
* Tags: Yields
*/
GetAssetIdsForPackage(this: AssetService, packageAssetId: number): Array;
/**
* If the bundle Id does not exist, it throws HTTP 400 (HTTP/1.1 400 Bad Request). If bundleId is not convertible to int, throws "Unable to cast string to int64". If param type is string, it implicitly tries to convert to int.
*
* This function returns details of the contents of the specified bundle.
*
* Understanding the returned ValueTable
* -------------------------------------
*
* It returns a ValueTable object with the following key-value pairs containing details about the specified bundle
*
* Key Name
*
* Value Type
*
* Description
*
* Id number
*
* int
*
* Bundle Id (passed in as an argument)
*
* Name
*
* string
*
* Bundle name
*
* Description
*
* string
*
* Bundle description
*
* BundleType
*
* string
*
* Bundle Type. eg. BodyParts or \`AvatarAnimation|AvatarAnimations\`
*
* Items
*
* ValueArray
*
* An array of ValueTable objects
*
* Each object in the Items array contains details of the item as described in the table below:
*
* Key Name
*
* Value Type
*
* Description
*
* Id number
*
* int
*
* Item's id
*
* Name
*
* string
*
* Item name
*
* Type
*
* string
*
* Item Type eg: "UserOutfit" or "Asset"
*
* Tags: Yields
*/
GetBundleDetailsAsync(this: AssetService, bundleId: number): BundleInfo;
/**
* The GetCreatorAssetID function returns the [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) of the account who created the the _creationID_ asset.
*
* Note
* ----
*
* This member is broken and currently does not function correctly. You should avoid using it for now.
*
* Tags: Yields
* @deprecated Use `GetProductInfo` instead
*/
GetCreatorAssetID(this: AssetService, creationID: number): number;
/**
* Returns a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object which contains the name and placeId of places within the current 'Game' (otherwise known as a 'Universe').
*
* Tags: Yields
*/
GetGamePlacesAsync(this: AssetService): StandardPages<{ Name: string; PlaceId: number }>;
/**
* Tags: Yields
*/
PromptCreateAssetAsync(this: AssetService, player: Player, instance: Instance, assetType: CastsToEnum): unknown;
/**
* Tags: Yields
*/
PromptImportAnimationClipFromVideoAsync(this: AssetService, player: Player, progressCallback: Callback): unknown;
/**
* Saves the state of the current place. This will only work for places that have been created with [AssetService:CreatePlaceAsync](https://developer.roblox.com/en-us/api-reference/function/AssetService/CreatePlaceAsync) or [AssetService:CreatePlaceInPlayerInventoryAsync](https://developer.roblox.com/en-us/api-reference/function/AssetService/CreatePlaceInPlayerInventoryAsync).
*
* Tags: Yields
*/
SavePlaceAsync(this: AssetService): void;
/**
* Tags: Yields
*/
SearchAudio(this: AssetService, searchParameters: AudioSearchParams): AudioPages;
}
/** **Note**
*
* Fog properties are hidden when Lighting contains an `[Atmosphere](Atmosphere)` object.
*
* The \*\*Atmosphere\*\* object pushes Roblox closer toward realistic environments where sunlight scatters in different ways depending on density and other air particle properties. It simulates real-world "aerial perspective" and lets you control light transmission from the background sky through distant objects. Furthermore, it controls haze and glare conditions, letting you tune a perfect sunset, foggy afternoon, and more.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
interface Atmosphere extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Atmosphere: unique symbol;
/**
* A [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3) value which changes the [Atmosphere](https://developer.roblox.com/en-us/api-reference/class/Atmosphere) hue for subtle environmental moods. This is best combined with increased [Haze](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Haze) to expand the visible effect.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
Color: Color3;
/**
* Defines the hue of the [Atmosphere](https://developer.roblox.com/en-us/api-reference/class/Atmosphere) away from the sun, gradually falling off from [Color](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Color) towards this value. Must be used with [Haze](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Haze) and [Glare](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Glare) levels higher than 0 to see any effect.
*/
Decay: Color3;
/**
* Defines the amount of particles in the air. The higher the density, the more particles and the more in-game objects/terrain will be obscured by them. Note that density does not **directly** affect the skybox — it merely affects in-game objects/terrain and visibility of the skybox through them.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
Density: number;
/**
* Specifies the glow/glare of the [Atmosphere](https://developer.roblox.com/en-us/api-reference/class/Atmosphere) around the sun. More glare results in an increased effect of sunlight cast onto the sky and world. Must be used with a [Haze](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Haze) level higher than 0 to see any effect.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
Glare: number;
/**
* Defines the haziness of the [Atmosphere](https://developer.roblox.com/en-us/api-reference/class/Atmosphere) with a visible effect both above the horizon and into the distance. This can be combined with [Color](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Color) to create environmental moods, like a grey tint for a polluted alien planet.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
Haze: number;
/**
* Controls how light transmits between the camera and the sky background. Increase this value to create a horizon silhouette against the sky or reduce it to blend distant objects into the sky for an endless and seamless open world.
*
* Offset should be balanced against [Density](https://developer.roblox.com/en-us/api-reference/property/Atmosphere/Density) and carefully tested in your place. A low offset may cause “ghosting” where the skybox can be seen through objects/terrain. This can be corrected by increasing the offset, which more clearly silhouettes distant objects/terrain against the sky, but too much offset may reveal level-of-detail “popping” for far distant terrain and meshes.
*
* See the [Atmosphere Controls](https://developer.roblox.com/en-us/articles/atmosphere) article for property comparisons and example environments.
*
* See also
* --------
*
* * [Custom Skyboxes](https://developer.roblox.com/en-us/articles/custom-skyboxes), outlines how to change the default skybox for games and customize the lighting
* * [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects), outlines how post-processing effects can quickly improve a game's visuals with a variety of customizable filters
*/
Offset: number;
}
/** **Attachment** defines a point and orientation relative to a parent [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). The offset is stored in the [CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame) property. The offset can also be set through other properties, such as [WorldCFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/WorldCFrame).
*
* Attachments are used by several kinds of [Constraint](https://developer.roblox.com/en-us/api-reference/class/Constraint) and are also valid parents for many objects that are otherwise parented directly to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), such as:
*
* * Particle-emitting objects like [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter), [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire), etc, emit from the attachment
* * Light-emitting objects like [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) and [SpotLight](https://developer.roblox.com/en-us/api-reference/class/SpotLight) shine from the attachment
* * [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound) will use the attachment as the focal point of the sound
*/
interface Attachment extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Attachment: unique symbol;
/**
* The [Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis) is the direction of the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)'s X-Axis, represented as a unit `Vector3`.
*
* Tags: NotReplicated
*/
Axis: Vector3;
/**
* Represents the CFrame offset of the Attachment.
*
*
* Changes to this property will reflect onto the [Attachment.Position](https://developer.roblox.com/en-us/api-reference/property/Attachment/Position) & [Attachment.Rotation](https://developer.roblox.com/en-us/api-reference/property/Attachment/Rotation) properties of this object.
*
* Similarly, a change to either of those properties will reflect onto this property.
*/
CFrame: CFrame;
/**
* A [Vector3](https://developer.roblox.com/api-reference/datatype/Vector3 "Vector3") that describes the orientation of the Attachment relative to the orientation of its parent, in degrees. Rotations are applied in Z, X, Y order.
*
* Tags: Hidden, NotReplicated
*/
Orientation: Vector3;
/**
* A [Vector3](https://developer.roblox.com/api-reference/datatype/Vector3 "Vector3") that describes the positional offset of the Attachment, relative to the position and orientation of its parent.
*
* Tags: Hidden, NotReplicated
*/
Position: Vector3;
/**
* A [Vector3](https://developer.roblox.com/api-reference/datatype/Vector3 "Vector3") that describes the rotation of the Attachment relative to the rotation of its parent, in degrees. Rotations are applied in Z, Y, X order.
*
* Tags: Hidden, NotReplicated
* @deprecated Use `Orientation` instead
*/
Rotation: Vector3;
/**
* The [SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis) is the direction of the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)'s Y-Axis, represented as a unit `Vector3`.
*
* Tags: NotReplicated
*/
SecondaryAxis: Vector3;
/**
* Toggles the visibility of the Attachment in-game.
*/
Visible: boolean;
/**
* Represents the direction of the [Attachment's](https://developer.roblox.com/en-us/api-reference/class/Attachment) [X-Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis) relative to the world, as a unit [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) with a length of 1.
*
* Tags: NotReplicated
*/
WorldAxis: Vector3;
/**
* WorldCFrame describes the exact [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of this attachment in the game world, independent of its [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) parent.
*
* The value of this property is equivalent to multiplying the CFrame of the [attachment's](https://developer.roblox.com/en-us/api-reference/class/Attachment) parent by its own CFrame:
*
* local worldCFrame = attachment.CFrame
* if attachment.Parent then
* worldCFrame = attachment.Parent.CFrame \* worldCFrame
* end
*
* Tags: NotReplicated
*/
WorldCFrame: CFrame;
/**
* Describes the orientation (in degrees) of the [attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) relative to the world, rather than the parent of the Attachment.
*
* Rotations are described in Z, X, Y order.
*
* Tags: Hidden, NotReplicated
*/
WorldOrientation: Vector3;
/**
* Describes the position of the [attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) relative to the world, rather than the parent of the Attachment.
*
* Tags: Hidden, NotReplicated
*/
WorldPosition: Vector3;
/**
* Determines the rotation (in degrees) of the attachment relative to the world, rather than the parent of the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* Tags: Hidden, NotReplicated
* @deprecated Use `WorldOrientation` instead
*/
readonly WorldRotation: Vector3;
/**
* Represents the direction of the [Y-Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis) of the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment), relative to the world, as a unit [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) with a length of 1.
*
* Tags: NotReplicated
*/
WorldSecondaryAxis: Vector3;
/**
* Returns the value of the Attachment's [Attachment.Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis).
* @deprecated Use `Axis` instead
*/
GetAxis(this: Attachment): Vector3;
GetConstraints(this: Attachment): Array;
/**
* Returns the value of the Attachment's [Attachment.SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis).
* @deprecated Use `SecondaryAxis` instead
*/
GetSecondaryAxis(this: Attachment): Vector3;
/**
* Sets the value of the Attachment's [Attachment.Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis).
* @deprecated Use `Axis` instead
*/
SetAxis(this: Attachment, axis: Vector3): void;
/**
* Sets the value of the Attachment's [Attachment.SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis).
* @deprecated Use `SecondaryAxis` instead
*/
SetSecondaryAxis(this: Attachment, axis: Vector3): void;
}
interface Bone extends Attachment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Bone: unique symbol;
/**
* **Transform** determines the current animated offset of the bone relative to its [CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame). This property is set by Roblox when animations on skinned meshes are played, although it can be manipulated manually in a manner similar to [Motor6D.Transform](https://developer.roblox.com/en-us/api-reference/property/Motor6D/Transform).
*
* See also
* --------
*
* * [Motor6D.Transform](https://developer.roblox.com/en-us/api-reference/property/Motor6D/Transform), a property which plays a similar role in character rig animation
* * [TransformedCFrame](https://developer.roblox.com/en-us/api-reference/property/Bone/TransformedCFrame) and [TransformedWorldCFrame](https://developer.roblox.com/en-us/api-reference/property/Bone/TransformedWorldCFrame), whose values are partially determined by this property
*
* Tags: NotReplicated
*/
Transform: CFrame;
/**
* **TransformedCFrame** describes the combined [CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame) offset of the bone and the current animation offset ([Transform](https://developer.roblox.com/en-us/api-reference/property/Bone/Transform)) in the bone's local space.
*
* See also
* --------
*
* * [Transform](https://developer.roblox.com/en-us/api-reference/property/Bone/Transform), a property which partially determines this property's value
* * [Bone.TransformedWorldCFrame](https://developer.roblox.com/en-us/api-reference/property/Bone/TransformedWorldCFrame), a world-space variant of this property
*
* Tags: Hidden, NotReplicated
*/
readonly TransformedCFrame: CFrame;
/**
* **TransformedWorldCFrame** describes the combined [CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame) offset of the bone and the current animation offset ([Transform](https://developer.roblox.com/en-us/api-reference/property/Bone/Transform)) in world space.
*
* See also
* --------
*
* * [Transform](https://developer.roblox.com/en-us/api-reference/property/Bone/Transform), a property which partially determines this property's value
* * [Bone.TransformedCFrame](https://developer.roblox.com/en-us/api-reference/property/Bone/TransformedCFrame), a local-space variant of this property
*
* Tags: NotReplicated
*/
readonly TransformedWorldCFrame: CFrame;
}
interface AudioAnalyzer extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioAnalyzer: unique symbol;
/**
* Tags: NotReplicated
*/
readonly PeakLevel: number;
/**
* Tags: NotReplicated
*/
readonly RmsLevel: number;
/**
* Tags: CustomLuaState
*/
GetSpectrum(this: AudioAnalyzer): unknown;
}
interface AudioChorus extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioChorus: unique symbol;
Depth: number;
Mix: number;
Rate: number;
}
interface AudioCompressor extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioCompressor: unique symbol;
Attack: number;
MakeupGain: number;
Ratio: number;
Release: number;
Threshold: number;
}
interface AudioDeviceInput extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioDeviceInput: unique symbol;
AccessType: Enum.AccessModifierType;
readonly Active: boolean;
Muted: boolean;
Player: Player | undefined;
GetUserIdAccessList(this: AudioDeviceInput): unknown;
SetUserIdAccessList(this: AudioDeviceInput, userIds: Array): void;
}
interface AudioDeviceOutput extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioDeviceOutput: unique symbol;
Player: Player | undefined;
}
interface AudioDistortion extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioDistortion: unique symbol;
Level: number;
}
interface AudioEcho extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioEcho: unique symbol;
DelayTime: number;
DryLevel: number;
Feedback: number;
WetLevel: number;
}
interface AudioEmitter extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioEmitter: unique symbol;
AudioInteractionGroup: string;
}
interface AudioEqualizer extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioEqualizer: unique symbol;
HighGain: number;
LowGain: number;
MidGain: number;
MidRange: NumberRange;
}
interface AudioFader extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioFader: unique symbol;
Volume: number;
}
interface AudioFlanger extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioFlanger: unique symbol;
Depth: number;
Mix: number;
Rate: number;
}
interface AudioListener extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioListener: unique symbol;
AudioInteractionGroup: string;
}
interface AudioPitchShifter extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioPitchShifter: unique symbol;
Pitch: number;
}
interface AudioPlayer extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioPlayer: unique symbol;
AssetId: string;
AutoLoad: boolean;
readonly IsPlaying: boolean;
/**
* Tags: NotReplicated
*/
readonly IsReady: boolean;
LoopRegion: NumberRange;
Looping: boolean;
PlaybackRegion: NumberRange;
PlaybackSpeed: number;
/**
* Tags: NotReplicated
*/
readonly TimeLength: number;
TimePosition: number;
Play(this: AudioPlayer): void;
Stop(this: AudioPlayer): void;
}
interface AudioReverb extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioReverb: unique symbol;
DecayRatio: number;
DecayTime: number;
Density: number;
Diffusion: number;
DryLevel: number;
EarlyDelayTime: number;
HighCutFrequency: number;
LateDelayTime: number;
LowShelfFrequency: number;
LowShelfGain: number;
ReferenceFrequency: number;
WetLevel: number;
}
interface AudioSearchParams extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioSearchParams: unique symbol;
Album: string;
Artist: string;
AudioSubType: Enum.AudioSubType;
/**
* Tags: NotReplicated
* @deprecated Use `AudioSubType` instead
*/
AudioSubtype: Enum.AudioSubType;
MaxDuration: number;
MinDuration: number;
SearchKeyword: string;
Tag: string;
Title: string;
}
interface AvatarChatService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AvatarChatService: unique symbol;
}
interface AvatarCreationService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AvatarCreationService: unique symbol;
/**
* Tags: Yields
*/
PromptCreateAvatarAsync(this: AvatarCreationService, player: Player, humanoidDescription: HumanoidDescription): unknown;
}
/** AvatarEditorService is a service to support developer Avatar Editors. It provides methods to modify the player's platform avatar, request information about a user's inventory, and request information about the catalog.
*
* See also
* --------
*
* For more information regarding the Avatar Editor, take a look at the [avatar editor service](https://developer.roblox.com/en-us/articles/avatar-editor-service) article.
*/
interface AvatarEditorService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AvatarEditorService: unique symbol;
GetAccessoryType(this: AvatarEditorService, avatarAssetType: CastsToEnum): Enum.AccessoryType;
/**
* Prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to allow the developer to read what items the user has in their inventory and other avatar editor related information. The prompt needs to be confirmed by the user for the developer to use [AvatarEditorService:GetInventory](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/GetInventory), [AvatarEditorService:GetOutfits](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/GetOutfits) and [AvatarEditorService:GetFavorite](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/GetFavorite). Permission does not persist between sessions.
*/
PromptAllowInventoryReadAccess(this: AvatarEditorService): void;
/**
* Prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to save the given [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) as an outfit. Does not yield. The result can be retrieved by listening to the [AvatarEditorService.PromptCreateOutfitCompleted](https://developer.roblox.com/en-us/api-reference/event/AvatarEditorService/PromptCreateOutfitCompleted) event.
*/
PromptCreateOutfit(this: AvatarEditorService, outfit: HumanoidDescription, rigType: CastsToEnum): void;
/**
* Prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to delete the given outfit. Does not yield. The result can be retrieved by listening to the [AvatarEditorService.PromptDeleteOutfitCompleted](https://developer.roblox.com/en-us/api-reference/event/AvatarEditorService/PromptDeleteOutfitCompleted) event.
*/
PromptDeleteOutfit(this: AvatarEditorService, outfitId: number): void;
/**
* Prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to delete the given outfit. Does not yield. The result can be retrieved by listening to the [AvatarEditorService.PromptRenameOutfitCompleted](https://developer.roblox.com/en-us/api-reference/event/AvatarEditorService/PromptRenameOutfitCompleted) event.
*/
PromptRenameOutfit(this: AvatarEditorService, outfitId: number): void;
/**
* This function prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to update their avatar based on the given [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) and [RigType](https://developer.roblox.com/en-us/api-reference/enum/RigType) (R6 or R15). Does not yield and can get the result by listening to the PromptSaveAvatarCompleted event. This is similar to how other prompts such as PromptPurchase work.
*/
PromptSaveAvatar(this: AvatarEditorService, humanoidDescription: HumanoidDescription, rigType: CastsToEnum): void;
/**
* This function prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to favorite or unfavorite the given asset or bundle.
*/
PromptSetFavorite(this: AvatarEditorService, itemId: number, itemType: CastsToEnum, shouldFavorite: boolean): void;
/**
* Prompts the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) to update the given outfit with the given HumanoidDescription.
*/
PromptUpdateOutfit(this: AvatarEditorService, outfitId: number, updatedOutfit: HumanoidDescription, rigType: CastsToEnum): void;
/**
* Returns a new [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) with the Shirt and Pants properties updated if necessary. Returns nil if default clothing was not needed.
*
* Default clothing is necessary if the HumanoidDescription does not currently have Shirt and Pants equipped and the body colors are too similar.
*
* Tags: Yields
*/
CheckApplyDefaultClothing(this: AvatarEditorService, humanoidDescription: HumanoidDescription): HumanoidDescription;
/**
* Tags: Yields
*/
ConformToAvatarRules(this: AvatarEditorService, humanoidDescription: HumanoidDescription): HumanoidDescription;
/**
* This function returns the platform Avatar rules for things like scaling, default shirts and pants, number of wearable assets, ect.
*
* The returned table includes the following fields:
*
* {
* "PlayerAvatarTypes": \[
* "R6"
* \],
* "Scales": {},
* "WearableAssetTypes": \[
* {
* "MaxNumber": 0,
* "Id": 0,
* "Name": "string"
* }
* \],
* "BodyColorsPalette": \[
* {
* "BrickColorId": 0,
* "NexColor": "string",
* "Name": "string"
* }
* \],
* "BasicBodyColorsPalette": \[
* {
* "BrickColorId": 0,
* "HexColor": "string",
* "Name": "string"
* }
* \],
* "MinimumDeltaEBodyColorDifference": 0,
* "ProportionsAndBodyTypeEnabledForUser": true,
* "DefaultClothingAssetLists": {
* "DefaultShirtAssetIds": \[
* 0
* \],
* "DefaultPantAssetIds": \[
* 0
* \]
* },
* "BundlesEnabledForUser": true,
* "EmotesEnabledForUser": true
* }
*
* Tags: Yields
*/
GetAvatarRules(this: AvatarEditorService): AvatarRules;
/**
* Gets the item details for a list of items at once. More efficient than AvatarEditorService:GetItemDetails if you need to get all the item details of a list.
*
* Tags: Yields
*/
GetBatchItemDetails(
this: AvatarEditorService,
itemIds: ReadonlyArray,
itemType: CastsToEnum,
): ReadonlyArray;
GetBatchItemDetails(
this: AvatarEditorService,
itemIds: ReadonlyArray,
itemType: CastsToEnum,
): ReadonlyArray;
GetBatchItemDetails(
this: AvatarEditorService,
itemIds: ReadonlyArray,
itemType: CastsToEnum,
): ReadonlyArray;
/**
* This function returns if the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) has favorited the given bundle or asset.
*
* Tags: Yields
*/
GetFavorite(this: AvatarEditorService, itemId: number, itemType: CastsToEnum): boolean;
/**
* Returns an [InventoryPages](https://developer.roblox.com/en-us/api-reference/class/InventoryPages) object with information about owned items in the users inventory with the given [AvatarAssetTypes](https://developer.roblox.com/en-us/api-reference/enum/AvatarAssetType).
*
* The returned table includes the following fields:
*
* \[
* {
* "AssetName": "string",
* "AssetId": 0,
* "SerialNumber": 0,
* "AssetType" : "string",
* }
* \]
*
* Tags: Yields
*/
GetInventory(this: AvatarEditorService, assetTypes: ReadonlyArray): InventoryPages;
/**
* This function returns the item details for the given item. It accepts two parameters - the first indicating the ID of the item being retrieved and the second indicating its [ItemType](https://developer.roblox.com/en-us/api-reference/enum/ItemType).
*
* Data returned in the format:
*
* {
* "IsForRent": true,
* "ExpectedSellerId": 0,
* "Owned": true,
* "IsPurchasable": true,
* "Id": 0,
* "ItemType": "Asset",
* "AssetType": "Image",
* "BundleType": "BodyParts",
* "Name": "string",
* "Description": "string",
* "ProductId": 0,
* "Genres": \[
* "All"
* \],
* "BundledItems": \[
* {
* "Owned": true,
* "Id": 0,
* "Name": "string",
* "Type": "string"
* }
* \],
* "ItemStatus": \[
* "New"
* \],
* "ItemRestrictions": \[
* "ThirteenPlus"
* \],
* "CreatorType": "User",
* "CreatorTargetId": 0,
* "CreatorName": "string",
* "Price": 0,
* "PremiumPricing": {
* "PremiumDiscountPercentage": 0,
* "PremiumPriceInRobux": 0
* },
* "LowestPrice": 0,
* "PriceStatus": "string",
* "UnitsAvailableForConsumption": 0,
* "PurchaseCount": 0,
* "FavoriteCount": 0
* }
*
* Tags: Yields
*/
GetItemDetails(
this: AvatarEditorService,
itemId: number,
itemType: CastsToEnum,
): AssetItemDetails;
GetItemDetails(
this: AvatarEditorService,
itemId: number,
itemType: CastsToEnum,
): BundleItemDetails;
GetItemDetails(this: AvatarEditorService, itemId: number, itemType: CastsToEnum): ItemDetails;
/**
* Tags: Yields
*/
GetOutfitDetails(this: AvatarEditorService, outfitId: number): object;
/**
* This function returns outfit data for the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer). This would be used with [Players:GetHumanoidDescriptionFromOutfitId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromOutfitId) to update the players character to the outfit. Access to this would also depend on [AvatarEditorService:PromptAllowInventoryReadAccess](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/PromptAllowInventoryReadAccess) being accepted by the user.
*
* The returned table includes the following fields:
*
* \[
* {
* "Id": 0,
* "Name": "string",
* "IsEditable": true
* }
* \]
*
* Name
*
* type
*
* Description
*
* id
*
* int
*
* name
*
* string
*
* isEditable
*
* boolean
*
* Tags: Yields
*/
GetOutfits(this: AvatarEditorService, outfitSource?: CastsToEnum, outfitType?: CastsToEnum): OutfitPages;
/**
* This function returns a list of recommendations based on the given [AssetType](https://developer.roblox.com/en-us/api-reference/enum/AssetType). Take a look at the code sample below for more information on possible usages for this function.
*
* Data is in the format:
*
* \[
* {
* "Item": {
* "AssetId": 0,
* "Name": "string",
* "Price": 0,
* "PremiumPrice": 0,
* "AbsoluteUrl": "string",
* "AudioUrl": "string"
* },
* "Creator": {
* "CreatorId": 0,
* "CreatorType": "string",
* "Name": "string",
* "CreatorProfileLink": "string"
* },
* "Product": {
* "Id": 0,
* "PriceInRobux": 0,
* "IsForSale": true,
* "IsPublicDomain": true,
* "IsResellable": true,
* "IsLimited": true,
* "IsLimitedUnique": true,
* "SerialNumber": 0,
* "IsRental": true,
* "RentalDurationInHours": 0,
* "BcRequirement": 0,
* "TotalPrivateSales": 0,
* "SellerId": 0,
* "SellerName": "string",
* "LowestPrivateSaleUserAssetId": 0,
* "IsXboxExclusiveItem": true,
* "OffsaleDeadline": "string",
* "NoPriceText": "string",
* "IsFree": true
* }
* }
* \]
*
* Tags: Yields
*/
GetRecommendedAssets(
this: AvatarEditorService,
assetType: CastsToEnum,
contextAssetId?: number,
): ReadonlyArray;
/**
* This function returns a list of recommended bundles for a given bundle id.
*
* Data is in the format:
*
* \[
* {
* "Id": 0,
* "Name": "string",
* "Description": "string",
* "BundleType": "string",
* "Items": \[
* {
* "Owned": true,
* "Id": 0,
* "Name": "string",
* "Type": "string"
* }
* \],
* "Creator": {
* "Id": 0,
* "Name": "string",
* "Type": "string"
* },
* "Product": {
* "Id": 0,
* "Type": "string",
* "IsPublicDomain": true,
* "IsForSale": true,
* "PriceInRobux": 0,
* "PremiumPricing": {
* "PremiumDiscountPercentage": 0,
* "PremiumPriceInRobux": 0
* }
* }
* }
* \]
*
* Tags: Yields
*/
GetRecommendedBundles(this: AvatarEditorService, bundleId: number): ReadonlyArray;
/**
* This function returns a [CatalogPages](https://developer.roblox.com/en-us/api-reference/class/CatalogPages) object containing the result of the given search.
*
* The returned data has the format:
*
* \[
* {
* "Id": 0,
* "ItemType": "Asset",
* "AssetType": "Image",
* "BundleType": "BodyParts",
* "Name": "string",
* "Description": "string",
* "ProductId": 0,
* "Genres": \[
* "All"
* \],
* "BundledItems": \[
* {
* "Owned": true,
* "Id": 0,
* "Name": "string",
* "Type": "string"
* }
* \],
* "ItemStatus": \[
* "New"
* \],
* "ItemRestrictions": \[
* "ThirteenPlus"
* \],
* "CreatorType": "User",
* "CreatorTargetId": 0,
* "CreatorName": "string",
* "Orice": 0,
* "PremiumPricing": {
* "PremiumDiscountPercentage": 0,
* "PremiumPriceInRobux": 0
* },
* "LowestPrice": 0,
* "PriceStatus": "string",
* "UnitsAvailableForConsumption": 0,
* "PurchaseCount": 0,
* "FavoriteCount": 0
* }
* \]
*
* Tags: Yields
*/
SearchCatalog(this: AvatarEditorService, searchParameters: CatalogSearchParams): CatalogPages;
/**
* This event fires when the [AvatarEditorService:PromptAllowInventoryReadAccess](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/PromptAllowInventoryReadAccess) prompt is responded to by the user. It can only return the Success or PermissionDenied [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) statuses as it does not perform any web requests which could fail.
*/
readonly PromptAllowInventoryReadAccessCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult) => void>;
/**
* This event fires when the PromptSaveOutfit operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptCreateOutfitCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult, failureType: unknown) => void>;
/**
* Fires when the PromptDeleteOutfit operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptDeleteOutfitCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult) => void>;
/**
* Fires when the PromptRenameOutfit operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptRenameOutfitCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult) => void>;
/**
* This event fires when the [AvatarEditorService:PromptSaveAvatar](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/PromptSaveAvatar) operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptSaveAvatarCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult, humanoidDescription: HumanoidDescription) => void>;
/**
* Fires when the [AvatarEditorService:PromptSetFavorite](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/PromptSetFavorite) operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptSetFavoriteCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult) => void>;
/**
* Fires when the [AvatarEditorService:PromptUpdateOutfit](https://developer.roblox.com/en-us/api-reference/function/AvatarEditorService/PromptUpdateOutfit) operation is completed. It gives a status [enum](https://developer.roblox.com/en-us/api-reference/enum/AvatarPromptResult) indicating whether the prompt succeeded, failed or permission was not granted by the user.
*/
readonly PromptUpdateOutfitCompleted: RBXScriptSignal<(result: Enum.AvatarPromptResult) => void>;
}
interface AvatarImportService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AvatarImportService: unique symbol;
}
/** A container object that holds a [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s inventory. Any [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) in a player's Backpack will be displayed in their inventory at the bottom of their screen. Selecting [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool)s from the inventory will equip the [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool), moving it from the Backpack to the player's character.
*
* The Backpack can also store [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s and [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s which will run when placed in a player's Backpack.
*
* When a player's character spawns, the contents of the [StarterPack](https://developer.roblox.com/en-us/api-reference/class/StarterPack) and their [StarterGear](https://developer.roblox.com/en-us/api-reference/class/StarterGear) are copied into their Backpack. Once a character dies, the Backpack is removed and a new one will be created – populating it with the contents of [StarterPack](https://developer.roblox.com/en-us/api-reference/class/StarterPack) and [StarterGear](https://developer.roblox.com/en-us/api-reference/class/StarterGear).
*
* Roblox provides an interface for a player to access their backpack and inventory by default at the bottom of the screen. If a developer wishes to disable the default Roblox backpack GUI and replace it with their own, they may do so using [StarterGui:SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled).
*
* The Backpack can be accessed from both the client and the server.
*
* ```lua
* -- Accessing Backpack from a Server Script:
* game.Players.PlayerName.Backpack
*
* -- Accessing Backpack from a LocalScript:
* game.Players.LocalPlayer.Backpack
* ```
*/
interface Backpack extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Backpack: unique symbol;
}
/** The **BadgeService** class provides information and functionality related to [badges](https://developer.roblox.com/en-us/articles/badges-special-game-awards). Badges are used across the platform to recognize a player's achievements and activity. Upon awarding a badge to a player, it is added to their inventory and displayed on their profile page.
*
* See the [badges](https://developer.roblox.com/en-us/articles/badges-special-game-awards) article for more information, as well as the code samples below.
*/
interface BadgeService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BadgeService: unique symbol;
/**
* **AwardBadge** grants a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) a [badge](https://developer.roblox.com/en-us/articles/badges-special-game-awards) given the player's [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) and the badge ID. In order to successfully award a badge, the following criteria must be met:
*
* * The player must be presently connected to the game.
* * The player must not already have the badge (note that a player may delete an awarded badge from their profile and be awarded the badge again).
* * The badge must be awarded from a server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or a [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) eventually required by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), not from a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
* * The badge must be awarded in a place that is part of the game associated with the badge.
* * The owner of the place must also own the badge (for example, the owner must not have deleted the badge).
* * The badge must be enabled; check this using the `IsEnabled` property of the badge fetched via [BadgeService:GetBadgeInfoAsync()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/GetBadgeInfoAsync).
*
* See also
* --------
*
* * [BadgeService:GetBadgeInfoAsync()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/GetBadgeInfoAsync)
* * [BadgeService:UserHasBadgeAsync()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/UserHasBadgeAsync)
*
* Tags: Yields
*/
AwardBadge(this: BadgeService, userId: number, badgeId: number): boolean;
/**
* This function fteches information about a [badge](https://developer.roblox.com/en-us/articles/badges-special-game-awards) given its ID. It takes a brief moment to load the information from the Roblox website; repeated calls will cache for a short duration. It returns a dictionary with the following fields:
*
* Key
*
* Type
*
* Description
*
* **Name**
*
* string
*
* The name of the badge.
*
* **Description**
*
* string
*
* The description of the badge.
*
* **IconImageId**
*
* int64
*
* The asset ID of the image for the badge.
*
* **IsEnabled**
*
* bool
*
* Indicates whether the badge is available to be awarded.
*
* See also
* --------
*
* * [BadgeService:AwardBadge()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/AwardBadge)
* * [BadgeService:UserHasBadgeAsync()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/UserHasBadgeAsync)
*
* Tags: Yields
*/
GetBadgeInfoAsync(this: BadgeService, badgeId: number): BadgeInfo;
/**
* This function returns whether the badge with the given id is marked **disabled** on the Roblox website. A badge can be disabled by its owner on its page on the Roblox website, in the settings sub-menu. When a badge is disabled, this function returns true and the badge can no longer be awarded using [AwardBadge](https://developer.roblox.com/en-us/api-reference/function/BadgeService/AwardBadge). A badge may be quickly re-enabled through the same menu.
*
* 
*
* In Studio, a badge can only be tested if it is **disabled**. Calling this function with an enabled badge in Studio will return **true** and produce a warning “Sorry, badges can only be tested if they are disabled on Roblox game servers”.
*
* Note that even if a badge is enabled it may not necessarily be awardable (for example if it isn't associated with the current game). See [AwardBadge](https://developer.roblox.com/en-us/api-reference/function/BadgeService/AwardBadge) for more information on the criteria required for awarding badges.
*
* Badges that are associated with special events are a common reason for a badge to be disabled. Often, it is easier to simply disable a badge instead of hard-coding a time check for when some event ends.
*
* Tags: Yields
* @deprecated
*/
IsDisabled(this: BadgeService, badgeId: number): boolean;
/**
* This function determines if a given badge is associated with the current game. It returns true if the badge is associated with the current game.
*
* Badges can only be awarded from a place that is part of the game associated with the badge. This means, for example, a developer cannot award a badge associated with another developer's game.
*
* Even if this returns true, a badge may still not be award-able. For example, it may be disabled. For more information on the criteria for awarding badges see [AwardBadge](https://developer.roblox.com/en-us/api-reference/function/BadgeService/AwardBadge).
*
* Tags: Yields
* @deprecated
*/
IsLegal(this: BadgeService, badgeId: number): boolean;
/**
* This function returns whether a player owns a badge given the [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) and the badge's id. Such a query can only be made under the following conditions:
*
* * This function must be called from the server, i.e. in a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) eventually required by a Script.
* * The player in question must be present in the server.
*
* Any badge for any game can be queried, no matter who created the badge or which game it is used for. There are a number of applications of UserHasBadge:
*
* * A restricted door that can only be opened by players who own a badge (see code sample)
* * A basic way of determining if a player has played another game
* * Very simple progress saving. However, it is recommended developers use [DataStoreService](https://developer.roblox.com/en-us/api-reference/class/DataStoreService) for saving as it is more scale-able and robust (remember - players can delete their own badges).
*
* Tags: Yields
* @deprecated
*/
UserHasBadge(this: BadgeService, userId: number, badgeId: number): boolean;
/**
* Checks whether a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) owns a [badge](https://developer.roblox.com/en-us/articles/badges-special-game-awards) given their [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) and the badge ID. This query can only be made under the following conditions:
*
* * This function must be called from a server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or a [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) eventually required by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), not from a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
* * The player in question must be present in the server.
*
* Any badge for any game can be queried, no matter who created the badge or which game it is used for.
*
* See also
* --------
*
* * [BadgeService:GetBadgeInfoAsync()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/GetBadgeInfoAsync)
* * [BadgeService:AwardBadge()](https://developer.roblox.com/en-us/api-reference/function/BadgeService/AwardBadge)
*
* Tags: Yields
*/
UserHasBadgeAsync(this: BadgeService, userId: number, badgeId: number): boolean;
}
interface BaseImportData extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BaseImportData: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Id: string;
ImportName: string;
ShouldImport: boolean;
readonly StatusRemoved: RBXScriptSignal<(status: object) => void>;
readonly StatusReported: RBXScriptSignal<(status: object) => void>;
}
interface AnimationImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationImportData: unique symbol;
}
interface FacsImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FacsImportData: unique symbol;
}
interface GroupImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GroupImportData: unique symbol;
Anchored: boolean;
ImportAsModelAsset: boolean;
InsertInWorkspace: boolean;
}
interface JointImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_JointImportData: unique symbol;
}
interface MaterialImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MaterialImportData: unique symbol;
DiffuseFilePath: string;
/**
* Tags: NotReplicated
*/
readonly IsPbr: boolean;
MetalnessFilePath: string;
NormalFilePath: string;
RoughnessFilePath: string;
}
interface MeshImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MeshImportData: unique symbol;
Anchored: boolean;
/**
* Tags: NotReplicated
*/
readonly CageManifold: boolean;
CageMeshIntersectedPreview: boolean;
/**
* Tags: NotReplicated
*/
readonly CageMeshNotIntersected: boolean;
/**
* Tags: NotReplicated
*/
readonly CageNoOverlappingVertices: boolean;
CageNonManifoldPreview: boolean;
CageOverlappingVerticesPreview: boolean;
/**
* Tags: NotReplicated
*/
readonly CageUVMatched: boolean;
CageUVMisMatchedPreview: boolean;
/**
* Tags: NotReplicated
*/
readonly Dimensions: Vector3;
DoubleSided: boolean;
IgnoreVertexColors: boolean;
IrrelevantCageModifiedPreview: boolean;
MeshHoleDetectedPreview: boolean;
/**
* Tags: NotReplicated
*/
readonly MeshNoHoleDetected: boolean;
/**
* Tags: NotReplicated
*/
readonly NoIrrelevantCageModified: boolean;
/**
* Tags: NotReplicated
*/
readonly NoOuterCageFarExtendedFromMesh: boolean;
OuterCageFarExtendedFromMeshPreview: boolean;
/**
* Tags: NotReplicated
*/
readonly PolygonCount: number;
UseImportedPivot: boolean;
}
interface RootImportData extends BaseImportData {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RootImportData: unique symbol;
AddModelToInventory: boolean;
Anchored: boolean;
AnimationIdForRestPose: number;
ExistingPackageId: string;
/**
* Tags: NotReplicated
*/
readonly FileDimensions: Vector3;
ImportAsModelAsset: boolean;
ImportAsPackage: boolean;
InsertInWorkspace: boolean;
InsertWithScenePosition: boolean;
InvertNegativeFaces: boolean;
MergeMeshes: boolean;
/**
* Tags: NotReplicated
*/
readonly PolygonCount: number;
RestPose: Enum.RestPose;
RigScale: Enum.RigScale;
RigType: Enum.RigType;
RigVisualization: boolean;
ScaleUnit: Enum.MeshScaleUnit;
UseSceneOriginAsCFrame: boolean;
UseSceneOriginAsPivot: boolean;
UsesCages: boolean;
ValidateUgcBody: boolean;
WorldForward: Enum.NormalId;
WorldUp: Enum.NormalId;
}
/** The BasePlayerGui is an abstract class that all GUI drawing storage classes inherit from. */
interface BasePlayerGui extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BasePlayerGui: unique symbol;
/**
* This function takes a screen position and returns a list of all the visible [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject) that are occupying that screen position.
*
* The main use case is to get GUI objects under the player's mouse or touch inputs to do things like allow selection or highlighting. These effects can already be achieved using [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter) and [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave) but this requires the developer to track these events for their UI objects all the time even if they only need this functionality in specific circumstances.
*
* Since the child classes of [BasePlayerGui](https://developer.roblox.com/en-us/api-reference/class/BasePlayerGui) inherit this function, it can be fired by class objects such as the [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) and [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) folders.
*/
GetGuiObjectsAtPosition(this: BasePlayerGui, x: number, y: number): Array;
}
/** The PlayerGui object is a container that holds a [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s user GUI. If a [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui) is a descendant of a PlayerGui, then any [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) inside of the ScreenGui will be drawn to the player's screen. Any [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) will run as soon as it is inserted into a PlayerGui.
*
* When a player first joins a game, their PlayerGui is automatically inserted into their [Player](https://developer.roblox.com/en-us/api-reference/class/Player) object. When the player's [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) spawns for the first time all of the contents of [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) are automatically copied into the player's PlayerGui. Note that if [Players.CharacterAutoLoads](https://developer.roblox.com/en-us/api-reference/property/Players/CharacterAutoLoads) is set to false the character will not spawn and StarterGui contents will not be copied until [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter) is called. If [StarterGui.ResetPlayerGuiOnSpawn](https://developer.roblox.com/en-us/api-reference/property/StarterGui/ResetPlayerGuiOnSpawn) is set to true then every time the player's character respawns all of the contents of that player's PlayerGui is cleared and replaced with the contents of StarterGui.
*
* \-- Accessing PlayerGui from a LocalScript:
* game:GetService('Players').LocalPlayer:WaitForChild('PlayerGui')
*/
interface PlayerGui extends BasePlayerGui {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlayerGui: unique symbol;
/**
* Describes the user's current screen orientation.
*
* Tags: NotReplicated
*/
readonly CurrentScreenOrientation: Enum.ScreenOrientation;
/**
* Sets the preferred screen orientation mode for this user, if the user is on a mobile device.
*/
ScreenOrientation: Enum.ScreenOrientation;
/**
* Overrides the default selection adornment (used for gamepads). For best results, this should point to a GuiObject.
*/
SelectionImageObject: GuiObject | undefined;
/**
* Returns the transparency of the Topbar.
* @deprecated
*/
GetTopbarTransparency(this: PlayerGui): number;
/**
* SetTopbarTransparency sets the transparency of the Topbar CoreGui. A value of 0 is completely opaque, and a value of 1 is completely transparent. Values outside of the range \[0, 1\] are clamped. The default transparency of the topbar is 0.5. The current transparency can be retrieved using the similarly-named [GetTopbarTransparency](https://developer.roblox.com/en-us/api-reference/function/PlayerGui/GetTopbarTransparency) function.
*
* Comparison of Values
* --------------------
*
* The screenshots below show the topbar at 1.0, 0.5 and 0.0 transparency.
* ![The TopBar with a transparency of 1.0 (completely hidden)]](https://developer.roblox.com/assets/bltb3d5158183e86b86/Topbar_Transparency_1.0.png) ![The TopBar with a transparency of 0.5 (50% transparency)]](https://developer.roblox.com/assets/blt3d2716062cdd8606/Topbar_Transparency_0.5.png) 
*
* Usage
* -----
*
* This method is often used when re-styling the topbar to match the visual aesthetic of a game. By hiding the topbar, you can create your own custom topbar. See the code samples for an example.
*
* Alternative
* -----------
*
* Using the [StarterGui:SetCore](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCore) method with the `TopbarEnabled` option allows you to enable/disable the entire topbar and all of its features (player list, health, etc). By contrast, this method only affects how the topbar is displayed.
* @deprecated
*/
SetTopbarTransparency(this: PlayerGui, transparency: number): void;
/**
* Fires when the transparency of the Topbar CoreGui changes.
* @deprecated
*/
readonly TopbarTransparencyChangedSignal: RBXScriptSignal<(transparency: number) => void>;
}
/** The StarterGui service is a container object designed to hold [GUI objects](https://developer.roblox.com/en-us/api-reference/class/LayerCollector) such as [ScreenGuis](https://developer.roblox.com/en-us/api-reference/class/ScreenGui).
*
* StarterGui as a container
* -------------------------
*
* When a [Players'](https://developer.roblox.com/en-us/api-reference/class/Player) [character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) respawns, the contents of their [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) is emptied. Children of the [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) are then copied along with their descendants into the [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui).
*
* [GUI objects](https://developer.roblox.com/en-us/api-reference/class/LayerCollector) such as [ScreenGuis](https://developer.roblox.com/en-us/api-reference/class/ScreenGui) with their [ResetOnSpawn](https://developer.roblox.com/en-us/api-reference/property/LayerCollector/ResetOnSpawn) property set to false will only be placed into each [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) once and will not be deleted when the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) respawns.
*
* StarterGui as an interface
* --------------------------
*
* The StarterGui also includes a range of functions allowing you to interact with the [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui). For example [StarterGui:SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled) can be used to disable elements of the [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui). [StarterGui:SetCore](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCore) can perform a range of functions including creating notifications and system messages.
*/
interface StarterGui extends BasePlayerGui {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_StarterGui: unique symbol;
/**
* If set to true, each child parented to the [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) will be cloned into a player's [PlayerGui](https://developer.roblox.com/en-us/api-reference/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.
* @deprecated
*/
ResetPlayerGuiOnSpawn: boolean;
/**
* This property sets the preferred orientation mode for users with mobile devices. For the different modes available, see [ScreenOrientation](https://developer.roblox.com/en-us/api-reference/enum/ScreenOrientation).
*
* When a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) joins the game, if they are using a mobile device, this property will determine the device's starting orientation. [PlayerGui.ScreenOrientation](https://developer.roblox.com/en-us/api-reference/property/PlayerGui/ScreenOrientation) will be set to this value for [Players](https://developer.roblox.com/en-us/api-reference/class/Player) joining the game. For example, the following code would set the default to _'Portrait'_:
*
* game:GetService("StarterGui").ScreenOrientation = Enum.ScreenOrientation.Portrait
*
* By default, this property is set to _'LandscapeSensor'_, meaning the viewport will rotate so it is always right-side-up in landscape.
*
* Changing this property will not change the [ScreenOrientation](https://developer.roblox.com/en-us/api-reference/enum/ScreenOrientation) for [Players](https://developer.roblox.com/en-us/api-reference/class/Player) already in the game. To change the orientation for an existing player use their [PlayerGui.ScreenOrientation](https://developer.roblox.com/en-us/api-reference/property/PlayerGui/ScreenOrientation) property.
*
* You can also get the current screen orientation for a user's device using [PlayerGui.CurrentScreenOrientation](https://developer.roblox.com/en-us/api-reference/property/PlayerGui/CurrentScreenOrientation). This is useful when using the 'sensor' [ScreenOrientation](https://developer.roblox.com/en-us/api-reference/enum/ScreenOrientation) settings.
*
* For more information, please see this article on [device orientation](https://developer.roblox.com/en-us/articles/device-orientation-for-mobile-roblox-games).
*/
ScreenOrientation: Enum.ScreenOrientation;
/**
* This function returns whether the given [CoreGuiType](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType) is enabled or if it has been disabled using [StarterGui:SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled).
*
* This function should be called on the client and is used by the core scripts to help determine which core GUI elements to show.
*
* GetCoreGuiEnabled only returns _false_ if the given [CoreGuiType](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType) has been disabled using [StarterGui:SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled). Setting _TopbarEnabled_ to _false_ using [StarterGui:SetCore](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCore) hides all [CoreGuiTypes](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType) and does not affect the result of function.
*/
GetCoreGuiEnabled(this: StarterGui, coreGuiType: CastsToEnum): boolean;
/**
* SetCore (not to be confused with [SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled)) exposes a variety of functionality defined by Roblox's [CoreScripts](https://developer.roblox.com/en-us/api-reference/class/CoreScript), such as sending notifications, toggling notifications for badges/points, defining a callback for the reset button or toggling the topbar. The first parameter to SetCore is a string that selects the functionality with which the call will interact: a CoreScript must have registered such a string already (if one hasn't, an error is raised). It may be necessary to make multiple calls to SetCore using `pcall` in case the respective CoreScript has yet to load (or if it has been disabled entirely).
*
* The following table describes the strings that may be accepted as the first parameter in a call to SetCore. 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
*
* Name
*
* Type
*
* Default
*
* Description
*
* `active`
*
* bool
*
* Required
*
* Determines whether the chat should be made active
*
* PointsNotificationsActive
* -------------------------
*
* Controls whether notifications for earned player points will appear
*
* Name
*
* Type
*
* Default
*
* Description
*
* `active`
*
* bool
*
* Required
*
* Determines whether notifications for earned player points will appear
*
* BadgesNotificationsActive
* -------------------------
*
* Controls whether notifications for earned badges will appear
*
* Name
*
* Type
*
* Default
*
* Description
*
* `active`
*
* bool
*
* Required
*
* Determines whether notifications for earned badges will appear
*
* ResetButtonCallback
* -------------------
*
* Determines the behavior, if any, of the reset button given a bool or a [BindableEvent](https://developer.roblox.com/en-us/api-reference/class/BindableEvent) to be [fired](https://developer.roblox.com/en-us/api-reference/function/BindableEvent/Fire) when a player requests to reset.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `enabled`
*
* bool
*
* Required
*
* Determines whether the reset button retains its default behavior
*
* OR
*
* `callback`
*
* BindableEvent
*
* Required
*
* A BindableEvent to be fired when the player confirms they want to reset
*
* ChatMakeSystemMessage
* ---------------------
*
* Display a formatted message in the chat.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `configTable`
*
* dictionary
*
* Required
*
* A dictionary of information describing the message (see below)
*
* Name
*
* Type
*
* Default
*
* Description
*
* `Text`
*
* string
*
* Required
*
* The message to display
*
* `Color`
*
* Color3
*
* `Color3.fromRGB(255, 255, 243)`
*
* The TextColor3 of the message
*
* `Font`
*
* `Enum.Font`
*
* `SourceSansBold`
*
* The TextLabel/Font|Font of the message
*
* `TextSize`
*
* `Integer`
*
* `18`
*
* The TextSize of the message
*
* ChatWindowSize
* --------------
*
* Determines the [size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) of the chat window.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `windowSize`
*
* UDim2
*
* Required
*
* Determines the size of the chat window
*
* ChatWindowPosition
* ------------------
*
* Determines the [position](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Position) of the chat window.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `windowPosition`
*
* UDim2
*
* Required
*
* Determines the position of the chat window
*
* ChatBarDisabled
* ---------------
*
* Determines whether the player is able to type a message into the chat.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `disabled`
*
* bool
*
* Required
*
* Determines whether the chat's TextBox input is visible.
*
* SendNotification
* ----------------
*
* Causes a non-intrusive notification to appear at the bottom right of the screen. The notification may have up to two buttons.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `configTable`
*
* dictionary
*
* Required
*
* A dictionary of information describing the notification (see below)
*
* Name
*
* Type
*
* Default
*
* Description
*
* `Title`
*
* string
*
* Required
*
* The title of the notification
*
* `Text`
*
* string
*
* Required
*
* The main text of the notification
*
* `Icon`
*
* string
*
* Optional
*
* The image to display with the notification
*
* `Duration`
*
* number
*
* 5
*
* Duration (in seconds) the notification should stay visible
*
* `Callback`
*
* BindableFunction
*
* Optional
*
* A BindableFunction that should be invoked with the text of the button pressed by the player.
*
* `Button1`
*
* string
*
* Optional
*
* The text to display on the first button
*
* `Button2`
*
* string
*
* Optional
*
* The text to display on the second button
*
* TopbarEnabled
* -------------
*
* Determines whether the topbar is displayed. Disabling the topbar will also disable all CoreGuis, such as the chat, inventory and player list (i.e. those set with [SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled)).
*
* When disabled, the region the topbar once occupied will still capture mouse events; however, [buttons](https://developer.roblox.com/en-us/api-reference/class/TextButton) placed there will not respond to [clicks](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Click). The origin of GUI space will still be offset 36 pixels from the top of the screen.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `enabled`
*
* bool
*
* Required
*
* Determines whether the topbar should be visible
*
* DevConsoleVisible
* -----------------
*
* Determines whether the Developer Console is visible.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `visibility`
*
* bool
*
* Required
*
* Determines whether the developer console is visible
*
* PromptSendFriendRequest
* -----------------------
*
* Prompts the current player to send a friend request to the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `player`
*
* Player
*
* Required
*
* The player to which the friend request should be sent
*
* PromptUnfriend
* --------------
*
* Prompts the current player to remove a given [Player](https://developer.roblox.com/en-us/api-reference/class/Player) from their friends list.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `player`
*
* Player
*
* Required
*
* The player who should be unfriended
*
* PromptBlockPlayer
* -----------------
*
* Prompts the current player to block the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `player`
*
* Player
*
* Required
*
* The player who should be blocked
*
* PromptUnblockPlayer
* -------------------
*
* Prompts the current player to unblock the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `player`
*
* Player
*
* Required
*
* The player who should be unblocked
*
* AvatarContextMenuEnabled
* ------------------------
*
* Determines whether the [Avatar Context Menu](https://developer.roblox.com/en-us/articles/avatar-context-menu#visual-customization) is enabled.
*
* Name
*
* Type
*
* Default
*
* Description
*
* `enabled`
*
* bool
*
* Required
*
* Determines whether the Avatar Context Menu is enabled
*
* AvatarContextMenuTarget
* -----------------------
*
* Forcibly opens the [Avatar Context Menu](https://developer.roblox.com/en-us/articles/avatar-context-menu#opening-the-menu).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `player`
*
* [Player](https://developer.roblox.com/en-us/api-reference/class/Player)
*
* Required
*
* The player on whom the ACM will be opened.
*
* AddAvatarContextMenuOption
* --------------------------
*
* Adds an option to the [Avatar Context Menu](https://developer.roblox.com/en-us/articles/avatar-context-menu#visual-customization).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `option`
*
* `Enum.AvatarContextMenuOption`
*
* Required
*
* `Friend` (send friend request), [Chat](https://developer.roblox.com/en-us/api-reference/class/Chat) (start private chat), or `Emote` (wave)
*
* OR
*
* `option`
*
* table
*
* Required
*
* A two-element table, where the first is the name of the custom action, and the second is a BindableEvent which will be fired with a player was selected when the option was activated.
*
* RemoveAvatarContextMenuOption
* -----------------------------
*
* Removes an option to the [Avatar Context Menu](https://developer.roblox.com/en-us/articles/avatar-context-menu#visual-customization). The `option` argument must be the same as what was used with **AddAvatarContextMenuOption** (see above).
*
* Name
*
* Type
*
* Default
*
* Description
*
* `option`
*
* Variant
*
* Required
*
* The same value provided to **AddAvatarContextMenuOption**
*
* AvatarContextMenuTheme
* ----------------------
*
* Configures the customizable Avatar Context Menu (ACM) 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 the ACM including how to customize its theme and use it in your game, see the [Avatar Context Menu](https://developer.roblox.com/en-us/articles/avatar-context-menu#visual-customization) article.
*
* CoreGuiChatConnections
* ----------------------
*
* Sets up a bindable gateway connection between the CoreGui topbar's chat button and the Lua Chat System. The second parameter must be a table of [BindableEvents](https://developer.roblox.com/en-us/api-reference/class/BindableEvent) and [BindableFunctions](https://developer.roblox.com/en-us/api-reference/class/BindableFunction). See the example below for more clarification.
*
* \-- Create the Bindable objects
* local ChatConnections = {}
*
* local function AddObjects(bindableClass,targetName,...)
* local target = ChatConnections\[targetName\]
* if not target then
* target = {}
* ChatConnections\[targetName\] = target
* end
* local names = {...}
* for \_,name in pairs(names) do
* local signal = Instance.new(bindableClass)
* signal.Name = targetName .. "\_" .. name
* signal.Parent = script
* target\[name\] = signal
* end
* end
*
* AddObjects("BindableEvent","ChatWindow",
* ---------------------------
* -- Fired from the CoreGui
* ---------------------------
* "ToggleVisibility", -- Fired when the CoreGui chat button is pressed.
* "SetVisible", -- Fired when the CoreGui wants to directly change the visiblity state of the chat window.
* "FocusChatBar", -- Fired when the CoreGui wants to capture the Chatbar's Focus.
* "TopbarEnabledChanged", -- Fired when the visibility of the Topbar is changed.
* "SpecialKeyPressed", -- Fired when the reserved ChatHotkey is pressed.
* "CoreGuiEnabled", -- Fired when a user changes the SetCoreGuiEnabled state of the Chat Gui.
*
* ---------------------------
* -- Fired to the CoreGui
* ---------------------------
* "ChatBarFocusChanged",
* -- ^ Fire this with 'true' when you want to assure the CoreGui that the ChatBar is being focused on.
*
* "VisibilityStateChanged",
* -- ^ Fire this with 'true' when the user shows or hides the chat.
*
* "MessagesChanged",
* -- ^ Fire this with a number to change the number of messages that have been recorded by the chat window.
* -- If the CoreGui thinks the chat window isn't visible, it will display the recorded difference between
* -- the number of messages that was displayed when it was visible, and the number you supply.
*
* "MessagePosted"
* -- ^ Fire this to make the player directly chat under Roblox's C++ API.
* -- This will fire the LocalPlayer's Chatted event.
* -- Please only fire this on the player's behalf. If you attempt to spoof a player's chat
* -- to get them in trouble, you could face serious moderation action.
* )
*
* AddObjects("BindableFunction","ChatWindow",
* "IsFocused" -- This will be invoked by the CoreGui when it wants to check if the chat window is active.
* )
*
* -- The following events are fired if the user calls StarterGui:SetCore(string name, Variant data)
* -- Note that you can only hook onto these ones specifically.
* AddObjects("BindableEvent","SetCore",
* "ChatMakeSystemMessage",
* "ChatWindowPosition",
* "ChatWindowSize",
* "ChatBarDisabled"
* )
*
* -- The following functions are invoked if the user calls StarterGui:GetCore(string name)
* -- Note that you can only hook onto these ones specifically.
* AddObjects("BindableFunction","GetCore",
* "ChatWindowPosition", -- Should return a UDim2 representing the position of the chat window.
* "ChatWindowSize", -- Should return a UDim2 representing the size of the chat window.
* "ChatBarDisabled" -- Should return true if the chat bar is currently disabled.
* )
*
* -- Connect ChatConnections to the CoreGui.
* local StarterGui = game:GetService("StarterGui")
* local tries = 0
* local maxAttempts = 10
*
* while (tries < maxAttempts) do
* local success,result = pcall(function ()
* StarterGui:SetCore("CoreGuiChatConnections",ChatConnections)
* end)
* if success then
* break
* else
* tries = tries + 1
* if tries == maxAttempts then
* error("Error calling SetCore CoreGuiChatConnections: " .. result)
* else
* wait()
* end
* end
* end
*
* while wait(0.2) do
* local isVisible = (math.random() > 0.5)
* ChatConnections.ChatWindow.VisibilityStateChanged:Fire(isVisible)
* if not isVisible then
* local messageCount = math.random(1,120)
* ChatConnections.ChatWindow.MessagesChanged:Fire(messageCount)
* end
* end
*/
SetCore(this: StarterGui, parameter: T, option: SettableCores[T]): void;
/**
* This function sets whether the [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui) element associated with the given [CoreGuiType](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType) is enabled or disabled.
*
* The top bar can not be disabled using this function. To disable the top bar, set _TopbarEnabled_ to _false_ using [StarterGui:SetCore](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCore). This will also disable the element associated with all [CoreGuiTypes](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType).
*
* For more information on how to use this function, see the article on [disabling the game interface](https://developer.roblox.com/en-us/articles/disabling-parts-of-game-interface).
*/
SetCoreGuiEnabled(this: StarterGui, coreGuiType: CastsToEnum, enabled: boolean): void;
/**
* GetCore returns data set or made available by Roblox's [CoreScripts](https://developer.roblox.com/en-us/api-reference/class/CoreScript). 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.
*
* Each of these is registered by a CoreScript and calling this function may yield. Many of these also register an equivalent [SetCore](https://developer.roblox.com/en-us/api-reference/function/StarterGui/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 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 UDim2.
*
* ChatWindowPosition\*
* --------------------
*
* Returns the size of the chat window as a UDim2.
*
* ChatBarDisabled\*
* -----------------
*
* Returns true if the chat bar is disabled.
*
* GetBlockedUserIds
* -----------------
*
* Returns a list of [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId)s associated with users that have been blocked by the local player.
*
* PlayerBlockedEvent
* ------------------
*
* Returns a BindableEvent that is fired whenever a player is blocked by the local player.
*
* PlayerUnblockedEvent
* --------------------
*
* Returns a BindableEvent that is fired whenever a player is unblocked by the local player.
*
* PlayerMutedEvent
* ----------------
*
* Returns a BindableEvent that is fired whenever a player is muted by the local player.
*
* PlayerUnmutedEvent
* ------------------
*
* Returns a BindableEvent that is fired whenever a player is unmuted by the local player.
*
* PlayerFriendedEvent
* -------------------
*
* Returns a BindableEvent that is fired whenever a player is friended by the local player.
*
* PlayerUnfriendedEvent
* ---------------------
*
* Returns a BindableEvent that is fired whenever a player is unfriended by the local player.
*
* DeveloperConsoleVisible\*
* -------------------------
*
* Returns true if the 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 [VRService.VREnabled](https://developer.roblox.com/en-us/api-reference/property/VRService/VREnabled) is true._
*
* Tags: Yields
*/
GetCore(this: StarterGui, parameter: T): GettableCores[T];
}
interface BaseRemoteEvent extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BaseRemoteEvent: unique symbol;
}
/** A **RemoteEvent** is designed to provide a one-way message between the server and clients, allowing [Scripts](https://developer.roblox.com/en-us/api-reference/class/Script) to call code in [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript) and vice-versa. This message can be directed from one client to the server, from the server to a particular client, or from the server to all clients.
*
* In order for both the server and clients to utilize a remote event, the RemoteEvent object itself must be in a place where both sides can see it. As such, we recommend that you store the RemoteEvent inside of [ReplicatedStorage](https://developer.roblox.com/en-us/api-reference/class/ReplicatedStorage), although in some cases it's appropriate to store it in the workspace or inside a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool).
*
* If you need the result of the call, you should use a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) instead. Otherwise a remote event is recommended since it will minimize network traffic/latency and won't yield the script to wait for a response. See [Remote Functions and Events](https://developer.roblox.com/en-us/articles/remote-functions-and-events) for more info.
*/
interface RemoteEvent extends BaseRemoteEvent {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RemoteEvent: unique symbol;
/**
* The FireAllClients function fires the [RemoteEvent.OnClientEvent](https://developer.roblox.com/en-us/api-reference/event/RemoteEvent/OnClientEvent) event for each client.
*
* Unlike [RemoteEvent:FireClient](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireClient), this event does not take a target player as an argument. Instead it will fire to all clients who have the same remote event connected to an OnClientEvent event.
*
* Since this function is used to communicate from the server to the client, it will only work when used in a [Script](https://developer.roblox.com/en-us/api-reference/class/Script).
*
* The behavior of this function, as well as other [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) and [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) events and functions, is well documented in [this](https://developer.roblox.com/articles/Remote-Functions-and-Events) article.
*
* There are limitations on the kinds of data that can be passed between the client and server. For more information, see [Parameter Limitations](https://developer.roblox.com/articles/Remote-Functions-and-Events#parameter-limitations).
*
* Note
* ----
*
* * Data can be passed from server to client through remote events in the same way data is passed from client to server. Any extra information can be passed in as arguments to the [RemoteEvent:FireClient](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireClient) and FireAllClients functions. Note that the FireClient function still needs to pass the player to send the message to as the first argument.
*/
FireAllClients(this: RemoteEvent, ...args: Parameters): void;
/**
* **FireClient** causes [OnClientEvent](https://developer.roblox.com/en-us/api-reference/event/RemoteEvent/OnClientEvent) to be fired in [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s running for the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player). Additional data passed to this function is then provided to OnClientEvent; beware of [limitations](https://developer.roblox.com/articles/Remote-Functions-and-Events#parameter-limitations) on this data.
*
* Since this function is used for communication from server to client, so it will only work when used by a server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script). For client-to-server communication (the other direction), use [FireServer](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireServer). Direct client-to-client communication not possible on Roblox; however, it can be simulated using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) that relays information received through some other means, such as [FireServer](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireServer).
*
* There are limitations on the kinds of data that can be passed between the client and server. For more information, see [Parameter Limitations](https://developer.roblox.com/articles/Remote-Functions-and-Events#parameter-limitations).
*
* See also
* --------
*
* * [FireAllClients](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireAllClients), which works similarly but for all [Player](https://developer.roblox.com/en-us/api-reference/class/Player)
*
* * [Remote Functions and Events](https://developer.roblox.com/articles/Remote-Functions-and-Events), which describes related classes, functions and events and also important limitations on the data that can be sent
*
* * Sometimes a game will need to send information from one client to another. Roblox does not support direct client to client contact, so any communication must first go through the server. This is typically done using remote events (although functions could be used if desired). First, the sending client would call FireServer. On the server, the function connected to OnServerEvent would hear this firing, and itself would then call FireClient.
*/
FireClient(this: RemoteEvent, player: Player, ...args: Parameters): void;
/**
* The FireServer event fires the [RemoteEvent.OnServerEvent](https://developer.roblox.com/en-us/api-reference/event/RemoteEvent/OnServerEvent) event on the server using the arguments specified with an additional player argument at the beginning.
*
* Since this function is used to communicate from the client to the server, it will only work when used in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* When firing from the client note that nothing has to be passed in by default (unlike firing to the client from the server - where the player is passed in).
*
* The behavior of this function, as well as other [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) and [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) events and functions, is well documented in [this](https://developer.roblox.com/articles/Remote-Functions-and-Events) article.
*
* There are limitations on the kinds of data that can be passed between the client and server. For more information, see [Parameter Limitations](https://developer.roblox.com/articles/Remote-Functions-and-Events#parameter-limitations).
*/
FireServer(this: RemoteEvent, ...args: Parameters): void;
/**
* The OnClientEvent event fires listening functions in [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) when either [RemoteEvent:FireClient](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireClient) or [RemoteEvent:FireAllClients](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireAllClients) is fired by the server from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script).
*
* This is used to retrieve remote events fired by the server and intended for the client. This event is in place to provide a method for communicating between the server and client, which is well documented in [this](https://developer.roblox.com/articles/Remote-Functions-and-Events) article. This event retrieves remote events fired by the server to the client.
*
* To fire from the client to the server, you should use [RemoteEvent:FireServer](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireServer) and [RemoteEvent.OnServerEvent](https://developer.roblox.com/en-us/api-reference/event/RemoteEvent/OnServerEvent).
*/
readonly OnClientEvent: RBXScriptSignal;
/**
* Fires listening functions in [Script](https://developer.roblox.com/en-us/api-reference/class/Script) when [RemoteEvent:FireServer](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireServer) is called from a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* This is used to retrieve remote events fired by the client and intended for the server. This event is in place to provide a method for communicating between the client and server, which is well documented in [this](https://developer.roblox.com/articles/Remote-Functions-and-Events) article. This event retrieves remote events fired by the client to the server.
*
* To fire from the server to the client, you should use [RemoteEvent:FireClient](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireClient) and [RemoteEvent.OnClientEvent](https://developer.roblox.com/en-us/api-reference/event/RemoteEvent/OnClientEvent).
*/
readonly OnServerEvent: RBXScriptSignal<(player: Player, ...args: Array) => void>;
}
interface UnreliableRemoteEvent extends BaseRemoteEvent {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_UnreliableRemoteEvent: unique symbol;
FireAllClients(this: UnreliableRemoteEvent, ...args: Parameters): void;
FireClient(this: UnreliableRemoteEvent, player: Player, ...args: Parameters): void;
FireServer(this: UnreliableRemoteEvent, ...args: Parameters): void;
readonly OnClientEvent: RBXScriptSignal;
readonly OnServerEvent: RBXScriptSignal<(player: Player, ...args: Array) => void>;
}
/** The base class for [WrapTarget](https://developer.roblox.com/en-us/api-reference/class/WrapTarget) and [WrapLayer](https://developer.roblox.com/en-us/api-reference/class/WrapLayer) objects. Note that [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) is the only valid parent type for [BaseWrap](https://developer.roblox.com/en-us/api-reference/class/BaseWrap) and that it behaves more like a component of [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) than an independent object. */
interface BaseWrap extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BaseWrap: unique symbol;
/**
* This property is set up automatically by the Avatar Importer plugin.
*
* Asset ID for cage mesh.
*/
CageMeshId: string;
/**
* This property is set up automatically by the Avatar Importer plugin.
*
* Cage mesh offset relative to parent [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart).
*/
CageOrigin: CFrame;
/**
* Cage mesh offset in world space.
*
* Tags: NotReplicated
*/
readonly CageOriginWorld: CFrame;
/**
* This property is set up automatically by the Avatar Importer plugin.
*
* Describes where a global zero was while authoring the cage mesh in an asset creation tool such as Blender or Maya. This property is not used by the deformer but it is useful for tools/aligning scripts, for example aligning two parts by matching their pivots as follows:
*
* local function alignWraps()
* local selectionService = game:GetService("Selection")
* local selectedObjects = selectionService:Get()
* local alignObjects = {}
* for \_, obj in pairs(selectedObjects) do
* if obj:IsA("BaseWrap") then
* --print("Wrap: " .. obj.Name)
* table.insert(alignObjects, obj)
* else
* print("Ignore: " .. obj.Name)
* end
* end
*
* if #alignObjects < 2 then
* warn("You need to select at least two wraps")
* return
* end
*
* local anchorWrap = alignObjects\[1\]
* local worldA\_from\_Wrap = anchorWrap.ImportOriginWorld
* print("Anchor: " .. anchorWrap.Name)
* for i = 2, #alignObjects do
* local wrapToAlign = alignObjects\[i\]
* print("Align: " .. wrapToAlign.Name)
* local wrap\_from\_WorldB = wrapToAlign.ImportOriginWorld:Inverse()
* local worldA\_from\_WorldB = worldA\_from\_Wrap \* wrap\_from\_WorldB
* local worldB = wrapToAlign.Parent.CFrame
* -- Note: adjust CFrame of the parent part
* wrapToAlign.Parent.CFrame = (worldB\_from\_WorldB \* worldB)
* end
* end
*/
ImportOrigin: CFrame;
/**
* Describes where the origin (in world space) was while authoring the cage mesh in an asset creation tool such as Blender or Maya.
*
* Tags: NotReplicated
*/
readonly ImportOriginWorld: CFrame;
}
/** The WrapLayer object defines a 3D accessory's inner and outer surfaces and other properties related to layering accessories. These surfaces, or the Inner Cage and Outer Cage, are similar to collision boxes, and describe the surfaces of which other 3D accessories can be placed without clipping or breaking.
*
* Internally, WrapLayer also uses the UV layout of the Inner and Outer cages to match coordinates to another 3D object's cage. This powers the deformation of objects around differently shaped avatars and underlying accessories.
*/
interface WrapLayer extends BaseWrap {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WrapLayer: unique symbol;
AutoSkin: Enum.WrapLayerAutoSkin;
/**
* This property is intended for fine-tuning purposes and is highly optional.
*
* [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) to adjust a binding point for a clothing item mesh. Allows for fine-tuning of clothing items (slight adjustment of position/rotation to get a unique look) in contexts such as community-made avatar editors.
*/
BindOffset: CFrame;
/**
* Allows for disabling of the [WrapLayer](https://developer.roblox.com/en-us/api-reference/class/WrapLayer) object as if it does not exist.
*/
Enabled: boolean;
/**
* Controls the composition order for layered clothing. Clothing items with higher order will appear on top of clothing items with lower order. If two items have the same order, the deformer composition order is ambiguous and depends on serialization order. Default value is 1.
*/
Order: number;
/**
* Controls how much underlying clothing items inflate the current clothing item.
*
* Valid range is 0 to 1. A value of 0 makes the clothing item always fit the body regardless of how many clothing layers are under it (all underlying clothing layers will be compressed). A value of 1 (default) never compresses anything and infinitely inflates over underlying clothing items.
*/
Puffiness: number;
/**
* AssetID for reference mesh used to define Inner Cage of a 3D object
*
* Reference mesh is used to define standard topology and UV coordinates for index matching. It is expected that for all catalog avatars, this will point to one of 15 standard reference meshes provided by Roblox. But for some NPCs or a custom avatar system, this might point to other meshes.
*
* Note: this property is set up automatically by the FBX importer
*/
ReferenceMeshId: string;
/**
* Reference mesh offset relative to parent MeshPart (in the parent MeshPart space)
*
* Note: this property is set up automatically by the FBX importer
*/
ReferenceOrigin: CFrame;
/**
* Reference mesh offset relative to parent MeshPart (in the world space)
*
* Note: this property is set up automatically by the FBX importer
*
* Tags: NotReplicated
*/
readonly ReferenceOriginWorld: CFrame;
/**
* This property is intended for fine-tuning purposes and is highly optional.
*
* Allows slight shrinking/expanding of the resulting render mesh, without affecting any other layers. This is useful in rare cases when the clothing mesh does not precisely fit the underlying clothing layers (the cage is usually slightly overestimated atop the real shape to avoid layer interpenetration). Even slight overestimation has the tendency to accumulate, especially when there are a lot of layers. While this is usually not critical, some items like backpacks may be problematic.
*
* Valid range is -1 to 1. A value of -1 will maximally expand while a value of 1 will maximally shrink. A value of 0 (default) has no effect.
*/
ShrinkFactor: number;
}
/** The WrapTarget object defines a target. A target is the 3D body with only an outer surface, or an Outer Cage.
*
* This target, often an Avatar, is what 3D accessories (using WrapLayer) will be applied to, allowing multiple accessories items to naturally layer over the source target.
*/
interface WrapTarget extends BaseWrap {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WrapTarget: unique symbol;
/**
* Defines how much the body mesh can be compressed by clothing. Super tight clothing may lead to an intersection between the clothing mesh and body mesh. To solve this visual artifact, the deformer can compress the body mesh slightly to solve possible intersections.
*
* Valid range is 0 to 1. A value of 0 will compress the body mesh as much as necessary to ensure that the intersections are eliminated (visible body parts might look a little bit deformed). A value of 1 will prevent the body mesh from being compressed (may lead to visible intersections or Z-fighting). A value of 0.9 (default) is a reasonable default that solves most of the intersections without introducing any significant body deformation.
*/
Stiffness: number;
}
/** A Beam object connects two [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s by drawing a texture between them.
*
* Setting up a Beam
* -----------------
*
* To display, beams must be a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) with their [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) and [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1) properties set to [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s also descending from the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace).
*
* The beam's appearance can be customised using the range of properties available.
*
* Beam Curvature
* --------------
*
* Beams are configured to use a cubic [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve). This means they are not constrained to straight lines, and the curve of the beam can be modified by changing [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0), [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) and the orientation of the beam's [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s.
*
* Cubic Bézier curves are formed of four control points. They are determined as follows:
*
* * **P0**: The start of the beam, the position of [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)
* * **P1**: [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0) studs away from [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0), in [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)'s positive X direction.
* * **P2**: [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) studs away from [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1), in [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)'s negative X direction.
* * **P3**: The end of the beam, the position of [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)
*
* The beam starts at P0, goes towards P1, and arrives at P3, from the direction of P2. The beam will not necessarily pass through P1 and P2.
*
* See the image below for a visual demonstration.
*
* 
*/
interface Beam extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Beam: unique symbol;
/**
* The [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) originates from.
*
* A [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s Attachment0 is the first control point on the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve). The orientation of Attachment0, alongside the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0), property determine the position of the second control point.
*
* For the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) where the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) ends see [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1).
*
* For more information how a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) curves, see [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0).
*/
Attachment0: Attachment | undefined;
/**
* The [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) ends at.
*
* A [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s Attachment1 is the fourth and final control point on the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve). The orientation of Attachment1, alongside the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) property, determine the position of the third control point.
*
* For the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) where the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) starts see [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0).
*
* For more information how a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) curves, see [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1).
*/
Attachment1: Attachment | undefined;
/**
* Scales the light emitted from [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam).
* By default, this property is 1 and can set to any number within the range \[0, 10000\].
* Increasing the value of [LightInfluence](https://developer.roblox.com/en-us/api-reference/property/Beam/LightInfluence) decreases the effect of **Brightness**. **Brightness** doesn't have any effect when [LightInfluence](https://developer.roblox.com/en-us/api-reference/property/Beam/LightInfluence) is 1.
*/
Brightness: number;
/**
* Determines the color of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam).
*
* If the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) is set, this color will be applied to the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s texture. If no [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) has been set then the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will appear as a solid bar colored in accordance with this property.
*
* Beams and ColorSequences
* ------------------------
*
* This property is a [ColorSequence](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequence), allowing the color to be configured to vary across the length of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam). Take for example the following [ColorSequence](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequence).
*
* local colorSequence = ColorSequence.new({
* ColorSequenceKeypoint.new(0, Color3.fromRGB(255, 0, 0)), -- red
* ColorSequenceKeypoint.new(0.5, Color3.fromRGB(0, 255, 0)), -- green
* ColorSequenceKeypoint.new(1, Color3.fromRGB(0, 0, 255)), -- blue
* }
* )
*
* Applying this [ColorSequence](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequence) to a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) would yield the following result:
*
* 
*
* Note the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s coloration also depends on the number of [Beam.Segments](https://developer.roblox.com/en-us/api-reference/property/Beam/Segments) the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) has. Each segment of the beam can only show a transition between two colors. Therefore a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will need to have at least n-1 segments in order for the color to display correctly, where n is the number of [ColorSequenceKeypoint](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequenceKeypoint)s in the [ColorSequence](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequence)
*/
Color: ColorSequence;
/**
* Determines, along with [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) the position of the first control point in the Beam's Bézier curve.
*
* The position of this point can be determined by the following equation:
*
* local controlPoint1 = Beam.Attachment0.WorldPosition + (Beam.Attachment0.CFrame.rightVector \* Beam.CurveSize0)
*
* Beam Curvature
* --------------
*
* Beams are configured to use a cubic [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve). This means they are not constrained to straight lines, and the curve of the beam can be modified by changing CurveSize0, [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) and the orientation of the beam's [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s.
*
* Cubic Bézier curves are formed of four control points. They are determined as follows:
*
* * **P0**: The start of the beam, the position of [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)
* * **P1**: CurveSize0 studs away from [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0), in [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)'s positive X direction.
* * **P2**: [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) studs away from [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1), in [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)'s negative X direction.
* * **P3**: The end of the beam, the position of [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)
*
* The beam starts at P0, goes towards P1, and arrives at P3, from the direction of P2. The beam will not necessarily pass through P1 and P2.
*
* See the images below for a visual demonstration.
*
* 
* 
*/
CurveSize0: number;
/**
* Determines, along with [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) the position of the first control point in the Beam's Bézier curve.
*
* The position of this point can be determined by the following equation:
*
* local controlPoint2 = Beam.Attachment1.WorldPosition - (Beam.Attachment1.CFrame.rightVector \* Beam.CurveSize1)
*
* Beam Curvature
* --------------
*
* Beams are configured to use a cubic [Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve). This means they are not constrained to straight lines, and the curve of the beam can be modified by changing [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0), CurveSize1 and the orientation of the beam's [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s.
*
* Cubic Bézier curves are formed of four control points. They are determined as follows:
*
* * **P0**: The start of the beam, the position of [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)
* * **P1**: [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0) studs away from [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0), in [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0)'s positive X direction.
* * **P2**: CurveSize1 studs away from [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1), in [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)'s negative X direction.
* * **P3**: The end of the beam, the position of [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1)
*
* The beam starts at P0, goes towards P1, and arrives at P3, from the direction of P2. The beam will not necessarily pass through P1 and P2.
*
* See the images below for a visual demonstration.
*
* 
* 
*/
CurveSize1: number;
/**
* Determines whether the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) is visible or not.
*
* When this property is set to false, the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [Beam.Segments](https://developer.roblox.com/en-us/api-reference/property/Beam/Segments) will not be displayed.
*/
Enabled: boolean;
/**
* Determines whether the [Beam.Segments](https://developer.roblox.com/en-us/api-reference/property/Beam/Segments) of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will always face the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) regardless of its orientation.
*
* A [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) has no depth, and is hence a two dimensional projection existing in three dimensional space. This means that, by default, a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) is not visible from every angle.
*
* When FaceCamera is set to true, the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will always be orientated towards the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera).
*/
FaceCamera: boolean;
/**
* Determines to what degree the colors of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) are blended with the colors behind it.
*
* The LightEmission property determines the blending of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) with the colors behind it. It should be set in the range \[0, 1\]. A value of 0 uses normal blending modes, and a value of 1 will use additive blending. The value of the additive blending is determined by this property.
*
* Pictured below are two sets of overlapping [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s. The right one has its LightEmission set to 1, so the texture appears brighter due to the additive blending on the overlaps.
*
* 
*
* This property should not be confused with [Beam.LightInfluence](https://developer.roblox.com/en-us/api-reference/property/Beam/LightInfluence), which determines how particles are affected by environment light. This property does not cause the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) to light the environment. To do that, consider using a [SurfaceLight](https://developer.roblox.com/en-us/api-reference/class/SurfaceLight).
*/
LightEmission: number;
/**
* Determines the degree to which the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) is influenced by the environment's lighting.
*
* LightInfluence is clamped between 0 and 1. When LightInfluence is 0, the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will be unaffected by the environment's lighting. When LightInfluence is 1 however, it will be fully affected by lighting (as a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) would be).
*
* For an example of this, and a demonstration of how this property interacts with [Beam.LightEmission](https://developer.roblox.com/en-us/api-reference/property/Beam/LightEmission), please see the images below.
*
* 
*
* 
*/
LightInfluence: number;
/**
* Sets how many straight segments the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) is made up of.
*
* This value can be any integer greater than 0. The default value is 10.
*
* Beam Segments and curvature
* ---------------------------
*
* Rather than being a perfect curve, a beam is made up of straight segments. The more segments, the higher the resoloution of the curve. See the image below for a demonstration of this:
*
* 
*
* For more information on how a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) is configured to curve, see the page for [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0).
*
* Beam Segments with Color and Transparency
* -----------------------------------------
*
* The [Beam.Color](https://developer.roblox.com/en-us/api-reference/property/Beam/Color) and [Beam.Transparency](https://developer.roblox.com/en-us/api-reference/property/Beam/Transparency) properties require a certain number of segments to display correctly. This is because each segment can only show a transition between two colors or transparencies. Therefore a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) requires at least n-1 segments to display correctly, where n is the number of keypoint associated with the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s [Beam.Color](https://developer.roblox.com/en-us/api-reference/property/Beam/Color) and [Beam.Transparency](https://developer.roblox.com/en-us/api-reference/property/Beam/Transparency).
*/
Segments: number;
/**
* The content ID of the texture to be displayed on the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam).
*
* If the Texture property of the beam is not set the beam will be displayed as a solid line. This also occurs when the texture is set to an invalid content ID or the image associated with the texture has not yet loaded.
*
* The appearance of the texture can be further modified by other [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) properties including [Beam.Color](https://developer.roblox.com/en-us/api-reference/property/Beam/Color) and [Beam.Transparency](https://developer.roblox.com/en-us/api-reference/property/Beam/Transparency).
*
* The scaling of the texture is determined by the [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode), [Beam.TextureLength](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureLength), [Beam.Width0](https://developer.roblox.com/en-us/api-reference/property/Beam/Width0) and [Beam.Width1](https://developer.roblox.com/en-us/api-reference/property/Beam/Width1) properties.
*/
Texture: string;
/**
* Sets the length of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s texture if [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) is 'Wrap' or 'Static'. If [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) is 'Stretch' then it determines the size of the texture relative to the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s length.
*
* Beam texture behavior
* ---------------------
*
* How a [Beam's](https://developer.roblox.com/en-us/api-reference/class/Beam) texture scales or repeats is dependent on the [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) property.
*
* When [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) is 'Wrap' the size of the repeating texture is equal to TextureLength in studs. For an example of this see the image below:
*
* 
*
* Note, the 'Static' [TextureMode](https://developer.roblox.com/en-us/api-reference/enum/TextureMode) type is not used for [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s and therefore behaves identically to 'Wrap'.
*
* When [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) is set to 'Stretch' however the texture will be stretched relative to the beam's length. The size of the texture relative to the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s length will be one over the TextureLength. In practice, this means the texture will repeat TextureLength times. For an example of this see the image below:
*
* 
*/
TextureLength: number;
/**
* Determines the manner in which the [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) scales and repeats.
*
* Beam Texture Behavior
* ---------------------
*
* How a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s texture scales or repeats is dependent on the TextureMode property.
*
* When TextureMode is 'Wrap' the size of the repeating texture corresponds to [Beam.TextureLength](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureLength) in studs. For an example of this see the image below:
*
* 
*
* Note, the 'Static' [TextureMode](https://developer.roblox.com/en-us/api-reference/enum/TextureMode) type is not used for [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s and therefore behaves identically to 'Wrap'.
*
* When [Beam.TextureMode](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureMode) is set to 'Stretch' however the texture will be stretched relative to the beam's length. The size of the texture relative to the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s length will be one over the [Beam.TextureLength](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureLength). In practice, this means the texture will repeat [Beam.TextureLength](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureLength) times. For an example of this see the image below:
*
* 
*/
TextureMode: Enum.TextureMode;
/**
* Determines the speed at which the [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) image moves along the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam).
*
* When TextureSpeed is positive, the beam's texture will move from [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) to [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1). This direction can be inverted by setting TextureSpeed to a negative number.
*
* Note the speed at which the texture moves is relative to the length of the texture. Meaning the more stretched the beam's [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) is, the faster it will move at the same TextureSpeed.
*/
TextureSpeed: number;
/**
* Determines the transparency of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) across its segments.
*
* Beams and Transparency
* ----------------------
*
* This property is a [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence), allowing the transparency to be configured to vary across the length of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam). Take for example the following [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence).
*
* local numberSequence = NumberSequence.new({
* NumberSequenceKeypoint.new(0, 1), -- transparent
* NumberSequenceKeypoint.new(0.5, 0), -- opaque
* NumberSequenceKeypoint.new(1, 1), -- transparent
* }
* )
*
* Applying this [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence) to a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) would yield the following result:
*
* 
*
* Note the [Beam's](https://developer.roblox.com/en-us/api-reference/class/Beam) transparency also depends on the number of [Beam.Segments](https://developer.roblox.com/en-us/api-reference/property/Beam/Segments) the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) has. Each segment of the beam can only show a transition between two transparencies. Therefore a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will need to have at least n-1 segments in order to display correctly, where n is the number of [NumberSequenceKeypoint](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequenceKeypoint)s in the [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence)
*/
Transparency: NumberSequence;
/**
* The width in studs of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) at its base.
*
* The beam will be Width0 studs wide at [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) and the width will change linearly to [Beam.Width1](https://developer.roblox.com/en-us/api-reference/property/Beam/Width1) studs at [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1). For a visual demonstration of this, see the image below.
*
* 
*
* The width properties should not be confused with [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0) and [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) which control the curvature of the beam.
*/
Width0: number;
/**
* The width in studs of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) at its end.
*
* The beam will be [Beam.Width0](https://developer.roblox.com/en-us/api-reference/property/Beam/Width0) studs wide at [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) and the width will change linearly to Width1 studs at [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1). For a visual demonstration of this, see the image below.
*
* 
*
* The width properties should not be confused with [Beam.CurveSize0](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize0) and [Beam.CurveSize1](https://developer.roblox.com/en-us/api-reference/property/Beam/CurveSize1) which control the curvature of the beam.
*/
Width1: number;
/**
* The distance, in studs, the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s display is offset by relative to the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera).
*
* When ZOffset is 0, the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam) will be displayed in its standard position between [Beam.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment0) and [Beam.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Beam/Attachment1). ZOffset can be both positive and negative.
*
* This property can be particularly useful when using multiple [Beams](https://developer.roblox.com/en-us/api-reference/class/Beam) between the same [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s. Here, ZOffset can be used to layer the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s and avoid [Z-fighting](https://en.wikipedia.org/wiki/Z-fighting). For example:
*
* See the image below for a visual demonstration of ZOffset:
*
* 
*/
ZOffset: number;
/**
* Sets the current offset of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s texture cycle.
*
* The offset of a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s texture cycle represents the progress of the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)s texture animation. Hence, a [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s texture cycle can be reset as follows:
*
* beam:SetTextureOffset(0)
*
* Where manual control is not required over the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam)'s texture cycle, [Beam.TextureSpeed](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureSpeed) can be used instead to animate the [Beam](https://developer.roblox.com/en-us/api-reference/class/Beam). Although, for illustrative purposes, a similar function can be achieved with SetTextureOffset.
*
* local RunService = game:GetService("RunService")
* while true do
* for i = 1, 0, -0.01 do
* RunService.RenderStepped:Wait()
* beam:SetTextureOffset(i)
* end
* end
*
* Notes
* -----
*
* * The given offset parameter is expected to be a value between 0 and 1, but greater values can still be used
* * The texture cycle wraps at 0 and 1, meaning the texture is in the same position when the offset is 0 or at 1
* * If the [Beam.Texture](https://developer.roblox.com/en-us/api-reference/property/Beam/Texture) property is not set, this function will do nothing
* * Increasing the offset will act in the inverse direction to the [Beam.TextureSpeed](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureSpeed) property. Meaning, it will move the texture in the opposite direction to the direction the texture animates when [Beam.TextureSpeed](https://developer.roblox.com/en-us/api-reference/property/Beam/TextureSpeed) is more than 0
*/
SetTextureOffset(this: Beam, offset?: number): void;
}
/** An object that allows events defined in one server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script) to be subscribed to by another script for one-way communication.
*
* BindableEvents do not allow for communication between the server and client. If you are looking for this functionality use [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent).
*
* BindableEvents vs BindableFunctions
* -----------------------------------
*
* Unlike BindableEvents, [BindableFunctions](https://developer.roblox.com/en-us/api-reference/class/BindableFunction) allow for two-way communication between two scripts:
*
* * When a script fires a BindableEvent it does not yield for a return. The script continues executing as the event is handled by the subscribed script asynchronously.
* * When a script invokes a BindableFunction, however, that script yields until the event is handled and returned by the subscribed script synchronously. This allows for scripts to effectively pass data during and after an event.
*
* BindableEvents vs RemoteEvents
* ------------------------------
*
* While BindableEvents allow for one-way communication server-server scripts or client-client [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript), [RemoteEvents](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) allow for one-way communicate the server and client. For more information on RemoteEvents, read the [Remote Functions and Events](https://developer.roblox.com/en-us/articles/remote-functions-and-events) article.
*
* Parameter Limitations
* ---------------------
*
* Any type of Roblox object such as an [Enumeration](https://developer.roblox.com/api-reference/enum), [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), or userdata can be passed as a parameter when a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) is fired or a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.
*
* ### Mixed Tables
*
* If a Table is passed as an argument to a BindableEvent it must be an array without missing entries or have string keys, not a mixture, or else the string keys will be lost.
*
* Avoid passing a mixed table (some values indexed by number and others by key), as **only the data indexed by number will be passed**. For example, when the server receives the `colorData` table illustrated below, it only sees indices 1 and 2 containing `"Blue"` and `"Yellow"` while the other data is lost in the transfer. Note, however, that **sub-tables** do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data is preserved.
*
* Metatables are not preserved.
*
* ### Non-String Indices
*
* If any indices of a passed table are non-string type ([Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), userdata, function, another table, etc.), those indices will be converted to a string.
*
* \-- Mixed table
* local colorData = {}
* colorData\[1\] = "Blue"
* colorData\[2\] = "Yellow"
* colorData\["Color1"\] = "Green"
* colorData\["Color2"\] = "Red"
*
* -- Table with two key-indexed sub-tables
* local playerData = {}
* playerData\["CharData"\] = {
* -- All children indexed by key
* CharName = "Diva Dragonslayer",
* CharClass = "Knight"
* }
* playerData\["Inventory"\] = {
* -- All children numerically indexed
* "Sword",
* "Bow",
* "Rope"
* }
*
* ### Functions
*
* Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.
*/
interface BindableEvent extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BindableEvent: unique symbol;
/**
* Calling this method will fire the [BindableEvent.Event](https://developer.roblox.com/en-us/api-reference/event/BindableEvent/Event) event.
*
* This function does not yield, even if no script has connected to the “Event” event and even if a connected function yields.
*
* Parameter Limitations
* ---------------------
*
* Any type of Roblox object such as an [Enumeration](https://developer.roblox.com/api-reference/enum), [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), or userdata can be passed as a parameter when a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) is fired or a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.
*
* ### Mixed Tables
*
* If a Table is passed as an argument to a BindableEvent it must be an array without missing entries or have string keys, not a mixture, or else the string keys will be lost.
*
* Avoid passing a mixed table (some values indexed by number and others by key), as **only the data indexed by number will be passed**. For example, when the server receives the `colorData` table illustrated below, it only sees indices 1 and 2 containing `"Blue"` and `"Yellow"` while the other data is lost in the transfer. Note, however, that **sub-tables** do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data is preserved.
*
* Metatables are not preserved.
*
* ### Non-String Indices
*
* If any indices of a passed table are non-string type ([Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), userdata, function, another table, etc.), those indices will be converted to a string.
*
* \-- Mixed table
* local colorData = {}
* colorData\[1\] = "Blue"
* colorData\[2\] = "Yellow"
* colorData\["Color1"\] = "Green"
* colorData\["Color2"\] = "Red"
*
* -- Table with two key-indexed sub-tables
* local playerData = {}
* playerData\["CharData"\] = {
* -- All children indexed by key
* CharName = "Diva Dragonslayer",
* CharClass = "Knight"
* }
* playerData\["Inventory"\] = {
* -- All children numerically indexed
* "Sword",
* "Bow",
* "Rope"
* }
*
* ### Functions
*
* Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.
*/
Fire(this: BindableEvent, ...args: Parameters): void;
/**
* This event is fired when any script calls the [BindableEvent:Fire](https://developer.roblox.com/en-us/api-reference/function/BindableEvent/Fire) method is called, using the same arguments as parameters.
*
* Parameter Limitations
* ---------------------
*
* Any type of Roblox object such as an [Enumeration](https://developer.roblox.com/api-reference/enum), [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), or userdata can be passed as a parameter when a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) is fired or a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.
*
* ### Mixed Tables
*
* If a Table is passed as an argument to a BindableEvent it must be an array without missing entries or have string keys, not a mixture, or else the string keys will be lost.
*
* Avoid passing a mixed table (some values indexed by number and others by key), as **only the data indexed by number will be passed**. For example, when the server receives the `colorData` table illustrated below, it only sees indices 1 and 2 containing `"Blue"` and `"Yellow"` while the other data is lost in the transfer. Note, however, that **sub-tables** do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data is preserved.
*
* Metatables are not preserved.
*
* ### Non-String Indices
*
* If any indices of a passed table are non-string type ([Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), userdata, function, another table, etc.), those indices will be converted to a string.
*
* \-- Mixed table
* local colorData = {}
* colorData\[1\] = "Blue"
* colorData\[2\] = "Yellow"
* colorData\["Color1"\] = "Green"
* colorData\["Color2"\] = "Red"
*
* -- Table with two key-indexed sub-tables
* local playerData = {}
* playerData\["CharData"\] = {
* -- All children indexed by key
* CharName = "Diva Dragonslayer",
* CharClass = "Knight"
* }
* playerData\["Inventory"\] = {
* -- All children numerically indexed
* "Sword",
* "Bow",
* "Rope"
* }
*
* ### Functions
*
* Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.
*/
readonly Event: RBXScriptSignal;
}
/** An object that allows you to give access to functions to external scripts. Functions put in BindableFunctions will not be replicated, therefore making it impossible to use these objects to pass functions between scripts. Functions are invoked through [BindableFunction:Invoke](https://developer.roblox.com/en-us/api-reference/function/BindableFunction/Invoke), which calls [BindableFunction.OnInvoke](https://developer.roblox.com/en-us/api-reference/property/BindableFunction/OnInvoke).
*
* BindableFunctions do not allow for communication between the server and client. If you are looking for this functionality use [RemoteFunctions](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction).
*
* BindableEvents vs BindableFunctions
* -----------------------------------
*
* Unlike BindableFunctions, [BindableEvents](https://developer.roblox.com/en-us/api-reference/class/BindableEvent) only allow for one-way communication between two scripts:
*
* * When a script invokes a BindableFunction it yields until the event is handled and returned by the subscribed script synchronously. This allows for scripts to effectively pass data during and after an event.
* * When a script fires a BindableEvent, however, it does not yield for a return. The script continues executing as the event is handled by the subscribed script asynchronously.
*
* BindableFunctions vs RemoteFunctions
* ------------------------------------
*
* While BindableFunctions allow for two-way communication server-server scripts or client-client [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript), [RemoteFunctions](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) allow for two-way communicate the server and client. For more information on RemoteFunctions, read the [Remote Functions and Events](https://developer.roblox.com/en-us/articles/remote-functions-and-events) article.
*
* Limitations
* -----------
*
* Invocations will **yield** until the corresponding callback is found. If the callback was never set, the script that invokes it will not resume execution.
*
* ### Subscription
*
* Only one function can be bound to [BindableFunction:Invoke](https://developer.roblox.com/en-us/api-reference/function/BindableFunction/Invoke) at a time. If you assign multiple functions, only the last one assigned will be used.
*
* ### Parameter Limitations
*
* Any type of Roblox object such as an [Enumeration](https://developer.roblox.com/api-reference/enum), [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), or userdata can be passed as a parameter when a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) is fired or a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.
*
* #### Table Identity
*
* Copies of tables are produced when passed as arguments to or returned from the OnInvoke callback. This means that means that tables passed as arguments will not be exactly equivalent to those provided on invocation, and tables returned to the invoker will not be exactly equivalent to the ones returned by the OnInvoke callback. You can demonstrate this by running the following script in a BindableFunction:
*
* local bindableFunction = script.Parent
*
* bindableFunction.OnInvoke = function (t)
* print("OnInvoke", tostring(t), t)
* t = {bar = "foo"}
* print("OnInvoke2", tostring(t), t)
* return t
* end
*
* local t = {foo = "bar"}
* print("Subscriber", tostring(t), t)
* local retVal = script.Parent:Invoke(t)
* print("return", tostring(retVal), retVal)
*
* The above code may produce the following results in the output. Notice how the memory addresses of every table printed are completely different from each other, indicating they each represent different tables:
*
* 13:55:22.228 Subscriber table: 0xc7daaba4d5307f10 ▶ {...} - Publisher:11
* 13:55:22.229 OnInvoke table: 0x2ee92a7818e7d210 ▶ {...} - Publisher:4
* 13:55:22.229 OnInvoke2 table: 0xfa4ee529ddadf290 ▶ {...} - Publisher:6
* 13:55:22.229 return table: 0x35b7bc1bc323d510 ▶ {...} - Publisher:13
*
* #### Mixed Tables
*
* Avoid passing a mixed table (some values indexed by number and others by key), as **only the data indexed by number will be passed**. For example, when the server receives the `colorData` table illustrated below, it only sees indices 1 and 2 containing `"Blue"` and `"Yellow"` while the other data is lost in the transfer. Note, however, that **sub-tables** do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data is preserved.
*
* Metatables are not preserved.
*
* #### Non-String Indices
*
* If any indices of a passed table are non-string type ([Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), userdata, function, another table, etc.), those indices will be converted to a string.
*
* \-- Mixed table
* local colorData = {}
* colorData\[1\] = "Blue"
* colorData\[2\] = "Yellow"
* colorData\["Color1"\] = "Green"
* colorData\["Color2"\] = "Red"
*
* -- Table with two key-indexed sub-tables
* local playerData = {}
* playerData\["CharData"\] = {
* -- All children indexed by key
* CharName = "Diva Dragonslayer",
* CharClass = "Knight"
* }
* playerData\["Inventory"\] = {
* -- All children numerically indexed
* "Sword",
* "Bow",
* "Rope"
* }
*
* #### Functions
*
* Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.
*/
interface BindableFunction extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BindableFunction: unique symbol;
/**
* Invoke will call the [BindableFunction.OnInvoke](https://developer.roblox.com/en-us/api-reference/property/BindableFunction/OnInvoke) callback and return any values that were returned by the callback (if any).
*
* Limitations
* -----------
*
* Invocations will **yield** until the corresponding callback is found. If the callback was never set, the script that invokes it will not resume execution.
*
* ### Subscription
*
* Only one function can be bound to [BindableFunction:Invoke](https://developer.roblox.com/en-us/api-reference/function/BindableFunction/Invoke) at a time. If you assign multiple functions, only the last one assigned will be used.
*
* ### Parameter Limitations
*
* Any type of Roblox object such as an [Enumeration](https://developer.roblox.com/api-reference/enum), [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), or userdata can be passed as a parameter when a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) is fired or a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) invoked. Lua types such as numbers, strings, and booleans can also be passed, although there are some limitations on how data can be passed.
*
* #### Table Identity
*
* Copies of tables are produced when passed as arguments to or returned from the OnInvoke callback. This means that means that tables passed as arguments will not be exactly equivalent to those provided on invocation, and tables returned to the invoker will not be exactly equivalent to the ones returned by the OnInvoke callback. You can demonstrate this by running the following script in a BindableFunction:
*
* local bindableFunction = script.Parent
*
* bindableFunction.OnInvoke = function (t)
* print("OnInvoke", tostring(t), t)
* t = {bar = "foo"}
* print("OnInvoke2", tostring(t), t)
* return t
* end
*
* local t = {foo = "bar"}
* print("Subscriber", tostring(t), t)
* local retVal = script.Parent:Invoke(t)
* print("return", tostring(retVal), retVal)
*
* The above code may produce the following results in the output. Notice how the memory addresses of every table printed are completely different from each other, indicating they each represent different tables:
*
* 13:55:22.228 Subscriber table: 0xc7daaba4d5307f10 ▶ {...} - Publisher:11
* 13:55:22.229 OnInvoke table: 0x2ee92a7818e7d210 ▶ {...} - Publisher:4
* 13:55:22.229 OnInvoke2 table: 0xfa4ee529ddadf290 ▶ {...} - Publisher:6
* 13:55:22.229 return table: 0x35b7bc1bc323d510 ▶ {...} - Publisher:13
*
* #### Mixed Tables
*
* Avoid passing a mixed table (some values indexed by number and others by key), as **only the data indexed by number will be passed**. For example, when the server receives the `colorData` table illustrated below, it only sees indices 1 and 2 containing `"Blue"` and `"Yellow"` while the other data is lost in the transfer. Note, however, that **sub-tables** do not need to be indexed in the same way as their parent — in other words, as long as each individual sub-table is indexed with the same type, all of the data is preserved.
*
* Metatables are not preserved.
*
* #### Non-String Indices
*
* If any indices of a passed table are non-string type ([Instance](https://developer.roblox.com/en-us/api-reference/class/Instance), userdata, function, another table, etc.), those indices will be converted to a string.
*
* \-- Mixed table
* local colorData = {}
* colorData\[1\] = "Blue"
* colorData\[2\] = "Yellow"
* colorData\["Color1"\] = "Green"
* colorData\["Color2"\] = "Red"
*
* -- Table with two key-indexed sub-tables
* local playerData = {}
* playerData\["CharData"\] = {
* -- All children indexed by key
* CharName = "Diva Dragonslayer",
* CharClass = "Knight"
* }
* playerData\["Inventory"\] = {
* -- All children numerically indexed
* "Sword",
* "Bow",
* "Rope"
* }
*
* #### Functions
*
* Functions passed as parameters will not be replicated, therefore making it impossible to use these objects to pass functions between scripts.
*
* Tags: Yields
*/
Invoke(this: BindableFunction, ...args: Parameters): ReturnType;
OnInvoke: T | undefined;
}
/** BodyMover is the abstract base class for the set of legacy objects that exert forces to [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in different ways. In general, the subclasses of BodyMover can be placed into one of two categories based on the type of force(s) they exert:
*
* Translational Force
* -------------------
*
* * [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce): Exert a force relative to world coordinates
* * [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition): Exert force to maintain a certain world position
* * [BodyVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyVelocity): Exert force to maintain a certain velocity
*
* Rotational Force (Torque)
* -------------------------
*
* * [BodyThrust](https://developer.roblox.com/en-us/api-reference/class/BodyThrust): Exert a force relative to object coordinates, which applies torque if positioned in a certain way
* * [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro): Exert torque to maintain a certain orientation
* * [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity): Exert torque to maintain a certain angular velocity
*
* An exception is the [RocketPropulsion](https://developer.roblox.com/en-us/api-reference/class/RocketPropulsion) class, which exerts **both** translational and rotational forces to cause a part to track down another part.
*/
interface BodyMover extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyMover: unique symbol;
}
/** **Note**
*
* This body mover has been superseded by [AngularVelocity](AngularVelocity). It's highly recommended that you use AngularVelocity for future work.
*
* The BodyAngularVelocity object applies a [torque](https://en.wikipedia.org/wiki/Torque) (or **rotational force**) on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) such that it maintains a constant [angular velocity](https://en.wikipedia.org/wiki/Angular_velocity) as determined by its [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity) property. This allows for the creation of parts that continually rotate. It is the rotational counterpart to a [BodyVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyVelocity). If you would like to maintain a constant [angular displacement](https://en.wikipedia.org/wiki/Angular_displacement), use a [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro) instead.
*
* 
*
* The [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity) property (visualized above as a green line) controls the goal angular velocity of the applied torque: the direction of the [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) is the axis which the part rotates around, and the magnitude is the speed in **radians/s**. The [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/MaxTorque) property controls the maximum amount of torque that can be applied to the object, while the [P](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/P) property controls the amount of [power](https://en.wikipedia.org/wiki/Power_(physics)) used in applying the torque.
*
* **Tip:** Regarding the [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity) property, you can multiply a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) by `math.rad(360)`, or **2π**, in order to convert [angular frequency](https://en.wikipedia.org/wiki/Angular_frequency) (rotations per second) into the desired [angular velocity](https://en.wikipedia.org/wiki/Angular_velocity) (radians per second). For example: Setting [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity) to `Vector3.new(0, 1, 0) * math.rad(360)` ≈ `Vector3.new(0, 6.283, 0)` will cause a part to spin around the Y axis once per second.
*
* 
*/
interface BodyAngularVelocity extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyAngularVelocity: unique symbol;
/**
* The AngularVelocity property is a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) which determines the goal angular velocity a [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity) should maintain through the exertion of torque. For this property, the direction of the vector is the axis of rotation. The magnitude is the angular velocity in **radians per second**. By default, this property is `(0, 2, 0)`.
*
* **Tip:** You can multiply a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) by `math.rad(360)`, or **2π**, in order to convert [angular frequency](https://en.wikipedia.org/wiki/Angular_frequency) (rotations per second) into the desired [angular velocity](https://en.wikipedia.org/wiki/Angular_velocity) (radians per second). For example: Setting [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity) to `Vector3.new(0, 1, 0) * math.rad(360)` ≈ `Vector3.new(0, 6.283, 0)` will cause a part to spin around the Y axis once per second.
*
* To better understand how the axis of rotation is determined from this property, imagine that there is an axle running between the part's position and the part's position plus this property as a global offset. This axle determines in what orientation the object will spin. The length of the axle determines the angular speed in radians per second. In the animation below, the [Part](https://developer.roblox.com/en-us/api-reference/class/Part) contains a [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity) and is floating in the air (using a [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition)). The [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity) has the default AngularVelocity of `(0, 2, 0)`, and this vector is visualized with a superimposed green line. It represents the axis of rotation. If we were to make the axle longer, like `(0, 4, 0)`, the part would spin faster.
*
* 
*
* As for the direction of rotation (counterclockwise or clockwise), use a **right-hand rule**: make a thumbs up with your right hand, and point **your thumb** it in the direction of the vector. The direction in which your fingers curl is the direction of the goal angular velocity.
*/
AngularVelocity: Vector3;
/**
* The MaxTorque property determines the limit of the torque that may be exerted on each world axis. If a part isn't moving, consider raising this value (and also check that it is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) or attached to another anchored part). See also [P](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/P) (power).
*/
MaxTorque: Vector3;
/**
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying torque in order to reach the goal [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/BodyAngularVelocity/AngularVelocity). The higher this value, the more power will be used and the faster it will be used.
*/
P: number;
}
/** **Note**
*
* This body mover has been superseded by [VectorForce](VectorForce). It's highly recommended that you use VectorForce for future work.
*
* The BodyForce object applies (or exerts) a force on the part to which it is parented. If the magnitude of such a force is great enough, parts can begin to accelerate. See [Newton's First Law of Motion](https://www.grc.nasa.gov/www/K-12/airplane/newton.html). The force is determined by the [BodyForce.Force](https://developer.roblox.com/en-us/api-reference/property/BodyForce/Force) property, and is defined on the three world axes.
*
* A BodyForce alone cannot apply a torque (it cannot cause the parent to rotate on its own). To apply a force at a specific point (e.g. to apply torque for angular acceleration) or apply forces relative to the orientation of the part, use a [BodyThrust](https://developer.roblox.com/en-us/api-reference/class/BodyThrust) instead.
*
* Forces Relative to Parent
* -------------------------
*
* Using the `CFrame:vectorToWorldSpace(Vector3)` method, it is possible to translate a force vector that is relative to the part into the world vector necessary for [Force](https://developer.roblox.com/en-us/api-reference/property/BodyForce/Force). For example, to apply a force to the left an object (no matter which way it's facing), try:
*
* magnitude = 100
* left = Vector3.new(-1, 0, 0) \* magnitude -- You could also use Vector3.FromNormalId(Enum.NormalId.Left)
* bodyForce.Force = bodyForce.Parent.CFrame:vectorToWorldSpace(left)
*
* You can also use a [BodyThrust](https://developer.roblox.com/en-us/api-reference/class/BodyThrust) with a [Location](https://developer.roblox.com/en-us/api-reference/property/BodyThrust/Location) of `(0, 0, 0)`, then set the [Force](https://developer.roblox.com/en-us/api-reference/property/BodyThrust/Force) for the same effect.
*
* Anti-gravity
* ------------
*
* BodyForce is commonly used to counteract the effects of [Gravity](https://developer.roblox.com/en-us/api-reference/property/Workspace/Gravity) on a per-part basis by simply applying a force in the +Y direction. See the code samples for more information.
*/
interface BodyForce extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyForce: unique symbol;
/**
* The Force property determines the magnitude of force exerted on each axis, relative to the world.
*/
Force: Vector3;
}
/** **Note**
*
* This body mover has been superseded by [AlignOrientation](AlignOrientation). It's highly recommended that you use AlignOrientation for future work.
*
* The **BodyGyro** object applies a torque (rotational force) on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) such that it maintains a constant angular displacement, or orientation. This allows for the creation of parts that point in a certain direction, as if a real gyroscope were acting upon it. Essentially, it's the rotational counterpart to a [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition).
*
* If you would like to maintain a constant angular velocity, use a [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity) instead.
*
* The [CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame) property controls the goal orientation. Only the angular components of the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) are used; position will make no difference. [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque) limits the amount of angular force that may be applied, [P](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/P) controls the power used in achieving the goal orientation, and [D](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/D) controls dampening behavior.
*
* Setting the Orientation
* -----------------------
*
* Like all [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) properties, the [BodyGyro.CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame) property isn't editable in the **Properties** window of Studio. Since there's no physical component to a **BodyGyro**, you should use scripting to set the [BodyGyro.CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame).
*
* A common technique for setting the goal orientation is to set the [BodyGyro.CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame) to a part's [CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame). For example:
*
* workspace.Part.BodyGyro.CFrame = workspace.Part.CFrame
*
* You can also use a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) **constructor** which initializes rotation such as `CFrame.fromAxisAngle`, `CFrame.fromEulerAnglesXYZ`, or `CFrame.fromEulerAnglesYXZ`. Alternatively, you can use the following structure to make the body gyro “look at” a `targetPosition`.
*
* CFrame.new(BodyGyro.Parent.Position, targetPosition)
*
* Troubleshooting
* ---------------
*
* * If the assembly isn't moving at all, it most likely has mass larger than what the **BodyGyro** can move. Try raising the [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque) and/or [P](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/P) (power) properties. You should also check that no [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) parts are within the assembly or in the way of the assembly.
* * If the assembly isn't moving on all axes, double check the axis in question has sufficient [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque). Alternatively, if the part allows movement on an axis and shouldn't, be sure the [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque) is non-zero on that axis and refine the manner in which you are setting the **BodyGyro** [CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame).
* * If the assembly is moving too quickly, consider raising the [D](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/D) (dampening) property.
* * If the assembly is moving too slowly, consider lowering the [D](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/D) (dampening) property. Also consider raising the [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque) and/or [P](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/P) (power) properties.
* * Any assembly containing a part that contains a **BodyGyro** or [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) will not be simulated when interacting with a player unless that player is the [network owner](https://developer.roblox.com/en-us/articles/network-ownership) of the assembly.
*/
interface BodyGyro extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyGyro: unique symbol;
/**
* The CFrame property (not to be confused with [BasePart.CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame)) determines the target orientation towards which torque will be exerted. Since [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro) does not apply translational force, the translational/positional component of the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame), `CFrame.p`, is ignored. Consider using one of the following CFrame constructors in setting this property: `CFrame.fromAxisAngle`, `CFrame.fromEulerAnglesXYZ` or `CFrame.fromEulerAnglesYXZ`. Beware of [gimbal lock](https://en.wikipedia.org/wiki/Gimbal_lock) as you choose which of these methods and what angles (in radians). Additionally, you could use `CFrame.new(gyro.Parent.Position, targetPosition)` in order to have the BodyGyro “look at” a targetPosition ([Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3)).
*/
CFrame: CFrame;
/**
* The D property is how much **dampening** will be applied to the torque used to reach the goal [CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame). When the part approaches the goal orientation it needs to decelerate, otherwise it will rotate past the goal and have to stop and re-accelerate back toward the goal. This is often creates undesirable **rubber-banding** effect, so applying dampening using this property is how that effect is avoided. The higher this value is set, the greater the dampening curve becomes, or the slower the part will approach the goal orientation.
*/
D: number;
/**
* The MaxTorque property determines the limit on the amount of torque that may be applied on each axis in reaching the goal orientation ([CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame)). If a part isn't moving, consider increasing this value (also check that it is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) or attached to any anchored parts).
*/
MaxTorque: Vector3;
/**
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying torque in order to reach the goal [CFrame](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/CFrame). The higher this value, the more power will be used and the faster it will be used.
*/
P: number;
}
/** This body mover has been superseded by [AlignPosition](https://developer.roblox.com/en-us/api-reference/class/AlignPosition). It's highly recommended that you use [AlignPosition](https://developer.roblox.com/en-us/api-reference/class/AlignPosition) for future work.
*
* The **BodyPosition** object applies a force on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) such that it will maintain a constant position in the world. The [Position](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/Position) property, not to be confused with [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position), controls the target world position. This is the translational counterpart to a [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro). If you need further control on a force applied to an object, consider using a [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce) or [BodyThrust](https://developer.roblox.com/en-us/api-reference/class/BodyThrust) instead.
*
* The strength of the force applied by this object is controlled by several factors, namely the distance to the goal position: the force is stronger when farther away from the goal. This is amplified by [P](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/P) (power). The present velocity will also dampen the force applied by this object, and this is amplified by [D](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/D) (dampening). The resulting force is then capped by [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/MaxForce). Note the force applied on the part to achieve the goal position may vary on a per-axis basis.
*
* Troubleshooting
* ---------------
*
* * If the assembly isn't moving, it's likely the [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/MaxForce) is too low. Also check for any [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) parts within the assembly or in the way of the assembly.
* * If the assembly is moving horizontally but not vertically, it's likely the [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/MaxForce) is strong enough to overcome friction but not gravity. Consider raising the **Y** component of [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/MaxForce) in order to get the object off the ground.
* * If the assembly is **overshooting** the goal position and springing back, it's likely the [D](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/D) (dampening) is too low. Alternatively, the [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/MaxForce) and/or [P](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/P) may be too high.
* * Any assembly containing a part that contains a **BodyPosition** or a [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro) will not be simulated when interacting with a player unless that player is the [network owner](https://developer.roblox.com/en-us/articles/network-ownership) of the assembly.
*/
interface BodyPosition extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyPosition: unique symbol;
/**
* The D property determines how much **dampening** will be applied to the force used toward reaching the goal `BodyPostion/Position|Position`. When the part approaches the goal position it needs to decelerate, otherwise it will move past the goal and have to stop and re-accelerate back toward the goal. This is often creates undesirable **rubber-banding** effect, so applying dampening using this property is how that effect is avoided. The higher this value is set, the greater the dampening curve becomes, or the slower the part will approach the goal position.
*/
D: number;
/**
* The MaxForce property determines the limit on the amount of force that may be applied on each axis in reaching the goal [Position](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/Position). If a part isn't moving, consider increasing this value (also check that it is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) or attached to any anchored parts).
*/
MaxForce: Vector3;
/**
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying force in order to reach the goal [Position](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/Position). The higher this value, the more power will be used and the faster it will be used.
* The force the [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) exerts increases as the difference between the part's current position and the goal position increases. This property is multiplied to this force to either amplify or diminish it.
*/
P: number;
/**
* The Position property determines the goal position towards which the [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) will apply force.
*/
Position: Vector3;
/**
* This function returns the last force in the object.
*/
GetLastForce(this: BodyPosition): Vector3;
/**
* Fired when the Parent of the BodyPosition reaches the desired [BodyPosition.Position](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/Position) (within .1 studs). Once this event fires it will not fire again until [BodyPosition.Position](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/Position) is updated.
*/
readonly ReachedTarget: RBXScriptSignal<() => void>;
}
/** **Note**
*
* This body mover has been superseded by [VectorForce](VectorForce). It's highly recommended that you use VectorForce for future work.
*
* The BodyThrust object applies (or exerts) a force relative to the part to which it is parented at a specific location. It behaves similar to a [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce), except that this object's force applies at a specific point ([BodyThrust.Location](https://developer.roblox.com/en-us/api-reference/property/BodyThrust/Location)), allowing you to exert a [torque](https://en.wikipedia.org/wiki/Torque) (rotational force). To apply a force dynamically so that a part maintains a constant angular velocity, use a [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity) instead. To apply a force dynamically so that a part maintains a constant orientation (angular position), use a [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro).
*/
interface BodyThrust extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyThrust: unique symbol;
/**
* The Force property determines the amount of force exerted on each axis relative to the part. Unlike [BodyForce.Force](https://developer.roblox.com/en-us/api-reference/property/BodyForce/Force), this property is relative to the part and not the world. The force is exerted at the [Location](https://developer.roblox.com/en-us/api-reference/property/BodyThrust/Location), which is also relative to the part.
*/
Force: Vector3;
/**
* The Location property determines the relative offset from the center part at which the [BodyThrust.Force](https://developer.roblox.com/en-us/api-reference/property/BodyThrust/Force) is exerted. This is the primary means for turning force into torque.
*/
Location: Vector3;
}
/** The BodyVelocity object applies a [force](https://en.wikipedia.org/wiki/Force) on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) such that it will maintain a constant velocity. The [BodyVelocity.Velocity](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/Velocity) property, not to be confused wtih [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity), controls the goal velocity. This is the translational counterpart to a [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity). If you need the part to move toward a goal position, use a [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) instead. If you need further control on a force applied to an object, consider using a [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce) or [BodyThrust](https://developer.roblox.com/en-us/api-reference/class/BodyThrust) instead.
*
* The strength of the force applied by this object is controlled by several factors, namely the difference between the part's current velocity and the goal velocity. This is multiplied by [P](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/P) (power) to either amplify or diminish it. The resulting force is then capped by [MaxForce](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/MaxForce). By setting [BodyVelocity.Velocity](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/Velocity) to `(0, 0, 0)` it is possible to simulate [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) behavior with less strictness.
*/
interface BodyVelocity extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyVelocity: unique symbol;
/**
* The MaxForce property determines the limit on the amount of force that may be applied on each axis in reaching the goal [Velocity](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/Velocity). If a part isn't moving, consider increasing this value (also check that it is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) or attached to any anchored parts).
*/
MaxForce: Vector3;
/**
* **Note**: This property is ignored if PGS is enabled via Workspace.PGSPhysicsSolverEnabled, which is enabled by default.
*
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying force in order to reach the goal [Velocity](https://developer.roblox.com/en-us/api-reference/property/BodyVelocity/Velocity). The higher this value, the more power will be used and the faster it will be used.
* The force the [BodyVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyVelocity) exerts increases as the difference between the part's current velocity and the goal velocity increases. This property is multiplied to this force to either amplify or diminish it.
*/
P: number;
/**
* The Velocity property (not to be confused with [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity)) determines the target velocity towards which force will be exerted. It is specified relative to the world, not the part.
*/
Velocity: Vector3;
/**
* **GetLastForce** is not implemented. It will always return the 0 vector. Developers are advised to use [AlignPosition](https://developer.roblox.com/api-reference/class/AlignPosition) instead
*/
GetLastForce(this: BodyVelocity): Vector3;
/**
* Returns the last force in the object.
*/
lastForce(this: BodyVelocity): Vector3;
}
/** **Note**
*
* This body mover has been superseded by [LineForce](LineForce). It's highly recommended that you use LineForce for future work.
*
* The RocketPropulsion object applies a force on a part so that it both **follows** and **faces** a target part. It acts like a hybrid of [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) and [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro). Unlike other [BodyMover](https://developer.roblox.com/en-us/api-reference/class/BodyMover)s, a RocketPropulsion must be instructed to begin applying a force: call [Fire](https://developer.roblox.com/en-us/api-reference/function/RocketPropulsion/Fire) to start, or call [Abort](https://developer.roblox.com/en-us/api-reference/function/RocketPropulsion/Abort) to stop.
*
* Below is an animation of a blue [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with a RocketPropulsion. The [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target) is set to a tall red [Part](https://developer.roblox.com/en-us/api-reference/class/Part) that is being dragged around in a circle in Studio. Notice how the blue part homes in to the target:
* 
*
* You can detect when the part reaches its target using the [ReachedTarget](https://developer.roblox.com/en-us/api-reference/event/RocketPropulsion/ReachedTarget) event, which fires once the part is within the [TargetRadius](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TargetRadius) of the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target).
*
* RocketPropulsion has the most physics-related properties out of all the BodyMovers. It is helpful to separate the properties out into categories based on what they control:
*
* * **Goal:** [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target), [TargetOffset](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TargetOffset) and [TargetRadius](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TargetRadius)
* * **Position (Thrust):** [MaxSpeed](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/MaxSpeed), [MaxThrust](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/MaxThrust), [ThrustD](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/ThrustD) and [ThrustP](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/ThrustP)
* * **Rotation (Turn):** - [CartoonFactor](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/CartoonFactor), [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/MaxTorque), [TurnD](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TurnD) and [TurnP](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TurnP)
*
* Remember, you don't need to use both the translational and rotational force features of a RocketPropulsion: by setting [MaxThrust](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/MaxThrust) to 0, you can make a part just face the target **without** having it follow the target around (consider also using a [BodyPosition](https://developer.roblox.com/en-us/api-reference/class/BodyPosition) in addition). Similarly, by setting [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/MaxTorque) to `(0, 0, 0)`, you can have a part simply follow another object without facing it (use a [BodyGyro](https://developer.roblox.com/en-us/api-reference/class/BodyGyro) if you want the object to maintain a specific orientation).
*/
interface RocketPropulsion extends BodyMover {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RocketPropulsion: unique symbol;
/**
* The CartoonFactor property determines the tendency of the part to face the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). By default, this property is set to `0.7`. If set to `0`, the part will make no effort to face the target.
*/
CartoonFactor: number;
/**
* The MaxSpeed property determines the upper limit of the velocity at which the part will move toward the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). A [RocketPropulsion](https://developer.roblox.com/en-us/api-reference/class/RocketPropulsion) will apply a force to decelerate a part if it exceeds this speed limit.
*/
MaxSpeed: number;
/**
* The MaxThrust property determines the upper limit of the thrust that may be exerted to move the part. Parts or assemblies that have high [mass](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetMass) will require more thrust in order to to remain airborne, and thus track the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target).
*/
MaxThrust: number;
/**
* The MaxTorque property determines the upper limit on the amount of torque that may be exerted in order to rotate the part towards the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). It functions similarly to [BodyGyro.MaxTorque](https://developer.roblox.com/en-us/api-reference/property/BodyGyro/MaxTorque).
*/
MaxTorque: Vector3;
/**
* The Target property determines the object towards which the [RocketPropulsion](https://developer.roblox.com/en-us/api-reference/class/RocketPropulsion) will exert force/torque. If set to `nil`, the the [TargetOffset](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/TargetOffset) will be used instead.
*/
Target: BasePart | undefined;
/**
* The TargetOffset property determines the world offset from the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). Basically, it makes the [RocketPropulsion](https://developer.roblox.com/en-us/api-reference/class/RocketPropulsion) behave as if the target were really offset by this property. It is especially useful when Target is set to nil, since this property then acts as the target position.
*/
TargetOffset: Vector3;
/**
* The TargetRadius property determines the maximum distance from the [RocketPropulsion.Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target) the part must be in order for the [RocketPropulsion.ReachedTarget](https://developer.roblox.com/en-us/api-reference/event/RocketPropulsion/ReachedTarget) event to be fired. It does not affect the exerted forces in any way.
*/
TargetRadius: number;
/**
* The D property is used to dampen the velocity of the part in order to prevent it from overshooting the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target) and causing a **rubber-banding** effect. It behaves similarly to [BodyPosition.D](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/D).
*/
ThrustD: number;
/**
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying force in order to reach the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target) position. The higher this value, the more power will be used and the faster it will be used.
* This property works similarly to [BodyPosition.P](https://developer.roblox.com/en-us/api-reference/property/BodyPosition/P).
*/
ThrustP: number;
/**
* The D property is how much **dampening** will be applied to the torque used to face the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). When the part approaches the goal orientation it needs to decelerate, otherwise it will rotate past the goal and have to stop and re-accelerate back toward the goal. This is often creates undesirable **rubber-banding** effect, so applying dampening using this property is how that effect is avoided. The higher this value is set, the greater the dampening curve becomes, or the slower the part will approach the goal orientation.
*/
TurnD: number;
/**
* The P property determines how much [power](https://en.wikipedia.org/wiki/Power_(physics)) is used while applying torque in order to face the [Target](https://developer.roblox.com/en-us/api-reference/property/RocketPropulsion/Target). The higher this value, the more power will be used and the faster it will be used.
*/
TurnP: number;
/**
* Causes the Rocket to stop moving towards its target, making it fall.
*/
Abort(this: RocketPropulsion): void;
/**
* Causes the rocket to fly towards Target.
*/
Fire(this: RocketPropulsion): void;
/**
* Fired when the Rocket comes within TargetRadius of the Target. This is used to make the rocket work, such as make an explosion when it flies near the Target.
*/
readonly ReachedTarget: RBXScriptSignal<() => void>;
}
interface BodyPartDescription extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyPartDescription: unique symbol;
AssetId: number;
BodyPart: Enum.BodyPart;
Color: Color3;
Instance: Instance | undefined;
}
interface Breakpoint extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Breakpoint: unique symbol;
}
interface BubbleChatMessageProperties extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BubbleChatMessageProperties: unique symbol;
BackgroundColor3: Color3;
BackgroundTransparency: number;
FontFace: Font;
TailVisible: boolean;
TextColor3: Color3;
TextSize: number;
}
interface BulkImportService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BulkImportService: unique symbol;
}
interface CalloutService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CalloutService: unique symbol;
}
/** The Camera object defines a view of the 3D game world.
*
* Where the Camera object is found
* --------------------------------
*
* In an instance of the game, each client has its own Camera object associated with it. Camera objects exist only upon the viewer's client, residing in that user's local Workspace, and therefore cannot be edited directly from the server.
*
* Each client's particular Camera object can be accessed through the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) property of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) on that client.
*
* Note, [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) can also be used to find the Camera object in Roblox Studio.
*
* How the Camera object works
* ---------------------------
*
* The Camera's properties define the current view of the 3D game world. The most important of these being:
*
* * The [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property represents the position and orientation of the camera.
* * The [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) property represents the point the camera is looking at. It is important this property is set as it also represents where the game thinks you are in the world. Certain visuals will be more detailed and will update more frequently, depending on how close they are to the Focus. Roblox's default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) take care of this.
* * The [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) property is read by the game's [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) and determines how the Camera should update each frame.
* * The [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) property is read by the game's [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) and determines what object the Camera should follow.
* * The [Camera.FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView) property represents the extent of the observable world visible.
*
* How to work with the Camera
* ---------------------------
*
* Roblox's [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) update the Camera's properties every frame dependent on the current [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType). This means developers looking to control the Camera themselves have two options.
*
* 1. Setting the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) property to _'Scriptable'_. When the Camera is in _'Scriptable'_ mode the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) will not update the camera. In most cases this is the easiest option.
* 2. Replacing or modifying the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) in [StarterPlayer.StarterPlayerScripts](https://developer.roblox.com/en-us/api-reference/class/StarterPlayerScripts). This is only recommended for advanced developers.
*/
interface Camera extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Camera: unique symbol;
/**
* This property is the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) and definies its position and orientation in the 3D world.
*
* Some transformations, such as the rotation of the head when using VR devices are not reflected in this property. For this reason, developers should use [Camera:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRenderCFrame) to obtain the 'true' [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the camera.
*
* How to set the camera's CFrame
* ------------------------------
*
* You can move the camera by setting the CFrame property. However, the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) also set the CFrame property. When manually setting the CFrame property, it may be overwritten by the [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) which update every frame. There are two options to address this:
*
* 1. Set the camera [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) to _'Scriptable'_. When the camera is _'Scriptable'_ the default scripts will not update the CFrame. This method is simplest and recommended in most cases
*
* 2. Replace the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) with an alternative that doesn't interfere with the developer's desired implementation. This is only recommended when developers do not need any default camera's functionality
*
*
* How the Camera CFrame works
* ---------------------------
*
* Like all [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) data, the camera CFrame represents a position and an orientation.
*
* The most intuitive way to position and orientate the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is by using the _new_ CFrame constructor with the _pos_ and _lookAt_ parameters, for example:
*
* local pos = Vector3.new(0, 10, 0)
* local lookAt = Vector3.new(10, 0, 0)
* local cameraCFrame = CFrame.new(pos, lookAt)
* workspace.CurrentCamera.CFrame = cameraCFrame
*
* In the above example the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is positioned at _Vector3.new(0, 10, 0)_ and oriented to be looking towards _Vector3.new(10, 0, 0)_.
*
* Animating the Camera CFrame
* ---------------------------
*
* Although the camera can be placed in the manner demonstrated above, you may want to animate the Camera to smoothly move from one CFrame to another. For this, there are a number of options:
*
* 1. Creating a [Tween](https://developer.roblox.com/en-us/api-reference/class/Tween) using [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) that animates the CFrame property of the camera. See the code sample below for an example of this
* 2. Setting the camera CFrame every frame with [RunService:BindToRenderStep](https://developer.roblox.com/en-us/api-reference/function/RunService/BindToRenderStep) and the _lerp_ CFrame method
*/
CFrame: CFrame;
/**
* When using the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls), the CameraSubject property has two roles:
*
* * Defining the object the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is to follow, in the case of the _'Follow'_, _'Attach'_, _'Track'_, _'Watch'_ and _'Custom'_ [CameraTypes](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType)
* * For all [CameraTypes](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) but _'Scriptable'_, the object whose position the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) will be set to
*
* CameraSubject accepts a variety of [Instances](https://developer.roblox.com/en-us/api-reference/class/Instance). The default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) respond differently to different CameraSubject types:
*
* * [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid): By default the CameraSubject is set to the `Player/LocalPlayer|LocalPlayer's` [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The camera scripts will follow the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) factoring in the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) current state and [Humanoid.CameraOffset](https://developer.roblox.com/en-us/api-reference/property/Humanoid/CameraOffset)
* * [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart): The camera scripts will follow the position of any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), with a vertical offset in the case of [VehicleSeats](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat)
*
* You can configure the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) to follow a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) by setting the CameraSubject to the model's[Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart).
*
* The CameraSubject cannot be set to _nil_. If it is, it will revert to its previous value.
*
* To restore the CameraSubject to its default value, set it to the `Player/LocalPlayer|LocalPlayer's` [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) like so:
*
* local Players = game:GetService("Players")
*
* local localPlayer = Players.LocalPlayer
*
* local function resetCameraSubject()
* if workspace.CurrentCamera and localPlayer.Character then
* local humanoid = localPlayer.Character:FindFirstChildOfClass("Humanoid")
* if humanoid then
* workspace.CurrentCamera.CameraSubject = humanoid
* end
* end
* end
*/
CameraSubject: Humanoid | BasePart | undefined;
/**
* The default Roblox [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) have several built in behaviors. Setting the CameraType of a player's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) will toggle between these behaviors. Note some CameraType's require a valid [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) to work correctly.
*
* * Fixed: [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is stationary
* * Follow: [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) moves with the [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) and rotates to keep the subject in the center of view
* * Attach: [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) moves with the [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) at a fixed offset and will rotate as the subject rotates
* * Track: [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) moves with the [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) but does not rotate automatically
* * Watch: [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is stationary but will rotate to keep the [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) in the center of view
* * Custom: Default
* * Scriptable: No default behavior. Used by developers to script custom behavior
*
* The above only applies when you use the default Roblox [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls). If you write your own camera scripts, you can choose to listen to CameraType and implement your own behaviors or ignore the property entirely.
*
* Manually controlling the Camera
* -------------------------------
*
* In some cases you may wish to manually control the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) (for example during a cut-scene). The best way to do this is by setting the CameraType to _'Scriptable'_. The default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) will not move or update the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) on its own if CameraType is set to _'Scriptable'_. This means you can freely modify the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) using its properties and functions. For more information on positioning and orientating the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) manually see the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) page.
*
* If you want complete control over the camera at all times, you may replace the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) with your own.
*/
CameraType: Enum.CameraType;
/**
* This property has been superseded by [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) which functions identically and should be used instead.
*
* Tags: Hidden, NotReplicated
* @deprecated Use `CFrame` instead
*/
CoordinateFrame: CFrame;
/**
* Sets how many degrees in the diagonal direction (from one corner of the viewport to its opposite corner) the camera can view.
*
* See [FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView) for a more general explanation of FOV.
*
* Tags: NotReplicated
*/
DiagonalFieldOfView: number;
/**
* Field of view, often shortened to FOV, is the extent of the observable game world that can be seen on screen at a given moment. The FieldOfView property is clamped between 1 and 120 degrees and defaults at 70. Very low or very high fields of view are not recommended as they can be disorientating to players.
*
* The FieldOfView property sets how many degrees in the vertical direction (y-axis) the camera can view. Uniform scaling is enforced meaning the vertical and horizontal field of view are always related by the [aspect ratio](https://en.wikipedia.org/wiki/Aspect_ratio_(image)) of the screen. This means the FieldOfView property also determines the horizontal field of view.
*
* See the images below for an example of how different FieldOfView settings can impact the extent of the perceptive game world. At a FOV of 70, a considerable portion of the game world is visible:
*
* 
*
* However when the FOV is reduced to 30, although the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) has not changed, a much smaller portion of the game world is rendered:
*
* 
*
* Suggested uses for FieldOfView
* ------------------------------
*
* Changing FOV can produce a variety of effects, such as:
*
* * Reducing FOV to give the impression of magnification (for example when using binoculars)
* * Increasing FOV when the player is 'sprinting' to give the impression of a lack of control
*/
FieldOfView: number;
/**
* The [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) FOV must be updated to reflect [Camera/ViewportSize](https://developer.roblox.com/en-us/api-reference/class/ViewportSize) changes. The value of the FieldOfViewMode property determines which FOV value will be kept constant.
*
* For example, when the value of FieldOfViewMode is set to `FieldOfViewMode/Vertical`, the horizontal FOV is updated when the viewport is resized, while the vertical FOV is kept constant.
* On the other hand, if the value is set to `FieldOfViewMode/Diagonal`, both horizontal and vertical FOV might be changed to keep the diagonal FOV constant.
*/
FieldOfViewMode: Enum.FieldOfViewMode;
/**
* The [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) Focus is a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) that determines the area in 3D space the graphics engine will prioritize.
*
* Certain graphical operations Roblox performs, such as updating lighting, can take a lot of time or computational effort to complete. Focus tells Roblox the area in 3D space to prioritize when performing such operations. For example dynamic lighting from objects such as [PointLights](https://developer.roblox.com/en-us/api-reference/class/PointLight) may not render at distances far from the Focus.
*
* The default Roblox [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) automatically set the Focus to follow the [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) (usually a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)). However, Focus will not be automatically updated in the following cases:
*
* * When the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) is set to _'Scriptable'_
* * When the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) are not being used
*
* In these cases, you should update Focus every frame, using [RunService:BindToRenderStep](https://developer.roblox.com/en-us/api-reference/function/RunService/BindToRenderStep) function at the _'Camera'_ [RenderPriority](https://developer.roblox.com/en-us/api-reference/enum/RenderPriority).
*
* Focus has no bearing on the positioning or orientation of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) (see [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) for this).
*/
Focus: CFrame;
/**
* Un-linking the camera from a VR user's head motions can cause motion sickness. This property should only be set to false after extensive testing.
*
* Toggles whether the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) will automatically track the head motion of a player using a VR device.
*
* When HeadLocked is _true_, the engine will combine the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) with the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the user's head to render the position and orientation of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) correctly. The camera will be rendered at the following [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame):
*
* local UserInputService = game:GetService("UserInputService")
* local headCFrame = UserInputService:GetUserCFrame(Enum.UserCFrame.Head)
* renderCFrame = workspace.CurrentCamera.CFrame \* headCFrame
*
* Disabling HeadLocked
* --------------------
*
* You are recommended not to disable HeadLocked for the following reasons:
*
* * Players may experience motion sickness if an equivalent head tracking solution is not added
* * The Roblox engine performs latency optimizations when HeadLocked is true
*
* However in some circumstances you may wish to develop your own head tracking systems. For example, you may want custom camera transformations that restrict or augment the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the head.
*
* See also
* --------
*
* * [UserInputService's](https://developer.roblox.com/en-us/api-reference/class/UserInputService) [UserInputService:GetUserCFrame](https://developer.roblox.com/en-us/api-reference/function/UserInputService/GetUserCFrame) function, which can be used to obtain the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the head
* * [UserInputService's](https://developer.roblox.com/en-us/api-reference/class/UserInputService) [UserInputService:RecenterUserHeadCFrame](https://developer.roblox.com/en-us/api-reference/function/UserInputService/RecenterUserHeadCFrame) which is used to recenter the head to the current position and orientation of the VR device
* * The [Camera:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRenderCFrame) function which returns the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) combined with the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the user's head
*/
HeadLocked: boolean;
/**
* HeadScale is the scale of the user's head when using VR.
*
* The unit scale of Roblox, from the user's perspective in VR, is defined as follows:
*
* _unitScale = HeadScale (in studs) / Feet ^ 2_
*
* This means the larger the HeadScale value, the smaller the world will look from the user's perspective when using VR devices.
*
* When not using VR, this property has no effect.
*
* This property should not be confused with [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) HeadScale, which is a [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) parented to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to control its scaling.
*
* See also
* --------
*
* The following are also useful when developing for VR:
*
* * [Camera.HeadLocked](https://developer.roblox.com/en-us/api-reference/property/Camera/HeadLocked)
* * [Camera:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRenderCFrame)
*/
HeadScale: number;
/**
* The MaxAxisFieldOfView property sets how many degrees along the longest viewport axis the camera can view.
*
* When the longest axis is the vertical axis, this property will behave similar to the [FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView) property. This is generally the case when a device is in a portrait orientation.
* In a landscape orientation the longest axis will be the horizontal axis. In this case, the property describes the horizontal FOV of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* See [FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView) for a more general explanation of FOV.
*
* Tags: NotReplicated
*/
MaxAxisFieldOfView: number;
/**
* The NearPlaneZ property describes how far away the Camera's near clipping plane is in studs. The near clipping plane is a geometric plane that sits in-front of the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame). Anything between this plane and the camera will not render. This creates a cutaway view when viewing objects at very short distances. See the images below for a visual example of this:
*
* 
* 
*
* The value of NearPlaneZ varies across different platforms, but is currently always between _\-0.1_ and _\-0.5_.
*
* * Most windows systems, all Xbox systems and most iOS systems support the more precise value of _\-0.1_
* * Currently Mac and Android systems only support a NearPlaneZ of _\-0.5_, although this may change in the future
*
* Tags: NotReplicated
*/
readonly NearPlaneZ: number;
VRTiltAndRollEnabled: boolean;
/**
* ViewportSize describes the dimensions, in pixels, of the client's viewport.
*
* 
*
* * This property ignores the GUI inset applied by the top bar, meaning the center of the screen can be found at precisely at 50% of the ViewportSize in both directions
* * You can find the position of a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) in the world on the viewport using [Camera:WorldToViewportPoint](https://developer.roblox.com/en-us/api-reference/function/Camera/WorldToViewportPoint)
*
* Tags: NotReplicated
*/
readonly ViewportSize: Vector2;
/**
* This function is used by _'PopperCam'_ in the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) to ensure obstructions do not come between the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) and the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) subject.
*
* This function will check all [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) with the following exceptions:
*
* * Any [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) specified in the _ignoreList_ (including its descendants) will be ignored
* * [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) with [BasePart.CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) set to false are ignored
* * [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) with a [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) greater than 0.95 will be ignored
* Water [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) is ignored
*
* Note, as this function requires an _ignoreList_ to run, you should pass an empty table when none is required.
* @deprecated
*/
GetLargestCutoffDistance(this: Camera, ignoreList: Array): number;
/**
* This function is broken and should not be used
*
* This function returns the current 'pan' speed of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* The 'pan' speed of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) describes the speed at which the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is rotating around its [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) around the Y axis.
*
* See also
* --------
*
* * [Camera:GetTiltSpeed](https://developer.roblox.com/en-us/api-reference/function/Camera/GetTiltSpeed) for the speed at which the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is rotating around its [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) on the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) X axis
* * [Camera:PanUnits](https://developer.roblox.com/en-us/api-reference/function/Camera/PanUnits) to 'pan' the camera
* * [Camera:TiltUnits](https://developer.roblox.com/en-us/api-reference/function/Camera/TiltUnits) to 'tilt' the camera
* @deprecated
*/
GetPanSpeed(this: Camera): number;
/**
* This function returns an array of [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) that are obscuring the lines of sight between [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) and the _castPoints_.
*
* GetPartsObscuringTarget is used by the 'Invisicam' in in the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) to hide parts between the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) and [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus).
*
* Any [Instances](https://developer.roblox.com/en-us/api-reference/class/Instance) included in the _ignoreList_ array will, along with their descendants, be ignored.
*
* See below for a visual example of this function. The [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is represented by the grey camera model and the cast points are represented by the colored dots. The [Parts](https://developer.roblox.com/en-us/api-reference/class/Part) highlighted in red are the ones that would be returned.
*
* 
*
* The castPoints parameter is given as an array of [Vector3s](https://developer.roblox.com/en-us/api-reference/datatype/Vector3), for example:
*
* local castPoints = {Vector3.new(0, 10, 0), Vector3.new(0, 15, 0)}
* local ignoreList = {}
* workspace.CurrentCamera:GetPartsObscuringTarget(castPoints, ignoreList)
*
* The array of [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) returned is in an arbitrary order, and no additional raycast data is provided (for example hit position, hit material and surface normal). If this information is required, you should a [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) raycast function such as `Workspace/FindPartOnRayWithIgnoreList`.
*
* If [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) obscures a cast point, [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) obscuring the cast point between the obscuring [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) and the cast point will not be returned.
*
* Note, this function benefits from internal optimisations that make it more performant than casting a ray for each cast point individually.
*/
GetPartsObscuringTarget(this: Camera, castPoints: Array, ignoreList: Array): Array;
/**
* This function returns the actual [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) as it is rendered. This includes any roll applied using [Camera:SetRoll](https://developer.roblox.com/en-us/api-reference/function/Camera/SetRoll) and the impact of VR.
*
* VR head transformations, along with roll applied using [Camera:SetRoll](https://developer.roblox.com/en-us/api-reference/function/Camera/SetRoll) is not applied to the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property. For this reason, it is best practice to use [Camera:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRenderCFrame) to obtain the 'true' [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* For example, when using VR the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is actually rendered at the following [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame):
*
* local UserInputService = game:GetService("UserInputService")
*
* local headCFrame = UserInputService:GetUserCFrame(Enum.UserCFrame.Head)
* renderCFrame = workspace.CurrentCamera.CFrame \* headCFrame
*
* The [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) render [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) will only be changed to account for the head when the [Camera.HeadLocked](https://developer.roblox.com/en-us/api-reference/property/Camera/HeadLocked) property is true.
*/
GetRenderCFrame(this: Camera): CFrame;
/**
* This function returns, in radians, the current roll applied to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) using [Camera:SetRoll](https://developer.roblox.com/en-us/api-reference/function/Camera/SetRoll). Roll is defined as rotation around the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) Z-axis.
*
* This function only returns roll applied using the [Camera:SetRoll](https://developer.roblox.com/en-us/api-reference/function/Camera/SetRoll) function. Roll manually applied to the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) is not accounted for. To obtain the actual roll of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera), including roll manually applied, you can use the following snippet:
*
* local function getActualRoll()
* local camera = workspace.CurrentCamera
*
* local trueUp = Vector3.new(0, 1, 0)
* local cameraUp = camera:GetRenderCFrame().upVector
*
* return math.acos(trueUp:Dot(cameraUp))
* end
*/
GetRoll(this: Camera): number;
/**
* This function is broken and should not be used
*
* This function returns the current 'tilt' speed of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* The 'tilt' speed of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) describes the speed at which the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is rotating around its [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) around the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) X axis.
*
* See also
* --------
*
* [Camera:GetPanSpeed](https://developer.roblox.com/en-us/api-reference/function/Camera/GetPanSpeed) for the speed the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is rotating around the [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) around the Y axis
* [Camera:PanUnits](https://developer.roblox.com/en-us/api-reference/function/Camera/PanUnits) to 'pan' the camera
* [Camera:TiltUnits](https://developer.roblox.com/en-us/api-reference/function/Camera/TiltUnits) to 'tilt' the camera
* @deprecated
*/
GetTiltSpeed(this: Camera): number;
/**
* This function tweens the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) in a linear fashion towards a new [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) and [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) over a given duration, for example:
*
* local camera = workspace.CurrentCamera
* camera.CameraType = Enum.CameraType.Scriptable
*
* camera:Interpolate(
* CFrame.new(0, 10, 100),
* CFrame.new(0, 0, 100),
* 5
* )
*
* Throughout the tween, the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) will be orientated towards the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus).
*
* When the tween has completed, the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.InterpolationFinished](https://developer.roblox.com/en-us/api-reference/event/Camera/InterpolationFinished) event will fire.
*
* If this function is called while the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) is already tweening the older tween will be stopped (without firing [Camera.InterpolationFinished](https://developer.roblox.com/en-us/api-reference/event/Camera/InterpolationFinished)) and overridden by the new tween.
*
* Interpolate can only be used if the current [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) is _'Scriptable'_, regardless of whether the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) are being used. If it is used with any other [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) an error will be thrown.
*
* You are advised to use [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) to tween the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) instead as it is more reliable and offers a variety of easing styles. See below for an example:
*
* local TweenService = game:GetService("TweenService")
*
* local camera = workspace.CurrentCamera
* camera.CameraType = Enum.CameraType.Scriptable
*
* local tween = TweenService:Create(
* camera,
* TweenInfo.new(5, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
* {
* CFrame = CFrame.new(0, 10, 100),
* Focus = CFrame.new(0, 0, 100)
* }
* )
*
* tween:Play()
* @deprecated
*/
Interpolate(this: Camera, endPos: CFrame, endFocus: CFrame, duration: number): void;
/**
* This function pans the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) around the [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) in 45 degree increments around the Y axis.
*
* The rotation is applied to the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property.
*
* This function pans the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) in 45 degree increments, for example:
*
* workspace.CurrentCamera:PanUnits(1) -- 45 degrees
* workspace.CurrentCamera:PanUnits(-2) -- -90 degrees
*
* PanUnits does not require the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) to be _'Scriptable'_.
* @deprecated
*/
PanUnits(this: Camera, units: number): void;
/**
* This function creates a unit [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) from a 2D position on the screen (defined in pixels). This position accounts for the GUI inset. The [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) originates from the [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) equivalent of the 2D position in the world at the given depth (in studs) away from the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* As this function accounts for the GUI inset, the offset applied to GUI elements (such as from the top bar) is accounted for. This means the screen position specified will start in the top left corner below the top bar. For an otherwise identical function that does not account for the GUI offset, use [Camera:ViewportPointToRay](https://developer.roblox.com/en-us/api-reference/function/Camera/ViewportPointToRay).
*
* As the [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) created is a unit ray it is only one stud long. To create a longer ray, you can do the following:
*
* local camera = workspace.CurrentCamera
* local length = 500
* local unitRay = camera:ScreenPointToRay(100, 100)
* local ray = Ray.new(unitRay.Origin, unitRay.Direction \* length)
*/
ScreenPointToRay(this: Camera, x: number, y: number, depth?: number): Ray;
/**
* This function sets the [CameraPanMode](https://developer.roblox.com/en-us/api-reference/enum/CameraPanMode) to be used by the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) on mobile devices.
*
* When the \*'EdgeBump' [CameraPanMode](https://developer.roblox.com/en-us/api-reference/enum/CameraPanMode) is used, swipe to pan is disabled and the edge bump camera controls are enabled.
*
* SetCameraPan mode has no effect on PC / Mac users.
* @deprecated
*/
SetCameraPanMode(this: Camera, mode?: CastsToEnum): void;
/**
* This function is outdated and no longer considered best practice.
*
* This function sets the current roll, in radians, of the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera). The roll is applied after the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) and represents the rotation around the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) Z-axis.
*
* For example, the following would invert the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera):
*
* workspace.CurrentCamera:SetRoll(math.pi) -- math.pi radians = 180 degrees
*
* SetRoll has no effect on any roll applied using the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property. Roll applied using SetRoll is not reflected in the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property but is reflected in in the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) returned by[Camera:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRenderCFrame).
*
* This function can only be used when the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) is set to _'Scriptable'_, regardless of whether the default [camera scripts](http://robloxdev.com/articles/Movement-and-camera-controls) are being used. If it is used with any other [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) a warning is given in the output.
*
* Any roll applied using this function will be lost when the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) is changed from _'Scriptable'_.
*
* To obtain the roll set using this function use [Camera:GetRoll](https://developer.roblox.com/en-us/api-reference/function/Camera/GetRoll).
*
* As this function is outdated, you are advised to instead apply roll to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) using the [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property. For example:
*
* local currentCFrame = workspace.CurrentCamera.CFrame
* local rollCFrame = CFrame.Angles(0, 0, roll)
* workspace.CurrentCamera.CFrame = currentCFrame \* rollCFrame
*/
SetRoll(this: Camera, rollAngle: number): void;
/**
* This function 'tilts' the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) by rotating it around the [Camera.Focus](https://developer.roblox.com/en-us/api-reference/property/Camera/Focus) around the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) X axis by a given multiple of 10 degrees.
*
* The rotation is applied to the [Camera's](https://developer.roblox.com/en-us/api-reference/class/Camera) [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) property and is constrained between _\-81.05_ and _81.05_ degrees.
*
* This function tilts the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) in 10 degree increments, for example:
*
* workspace.CurrentCamera:TiltUnits(2) -- 20 degrees
* workspace.CurrentCamera:TiltUnits(-5) -- -50 degrees
*
* TiltUnits does not require the [Camera.CameraType](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraType) to be _'Scriptable'_.
*
* See also
* --------
*
* * [Camera:PanUnits](https://developer.roblox.com/en-us/api-reference/function/Camera/PanUnits)
* @deprecated
*/
TiltUnits(this: Camera, units: number): boolean;
/**
* This function creates a unit [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) from a 2D position on the viewport (defined in pixels). This position does not account for the GUI inset. The [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) originates from the [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) equivalent of the 2D position in the world at the given depth (in studs) away from the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera).
*
* As this function does not account for the GUI inset, the viewport position given is not equivalent to the screen position used by GUI elements. If you are not using [ScreenGui.IgnoreGuiInset](https://developer.roblox.com/en-us/api-reference/property/ScreenGui/IgnoreGuiInset) and need an otherwise identical function that accounts for the GUI offset, use [Camera:ScreenPointToRay](https://developer.roblox.com/en-us/api-reference/function/Camera/ScreenPointToRay).
*
* This function can be used in conjunction with the [Camera.ViewportSize](https://developer.roblox.com/en-us/api-reference/property/Camera/ViewportSize) property to create a ray from the centre of the screen, for example:
*
* local camera = workspace.CurrentCamera
* local viewportPoint = camera.ViewportSize / 2
* local unitRay = camera:ViewportPointToRay(viewportPoint.X, viewportPoint.Y, 0)
*
* As the [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) created is a unit ray it is only one stud long. To create a longer ray, you can do the following:
*
* local camera = workspace.CurrentCamera
* local length = 500
* local unitRay = camera:ScreenPointToRay(100, 100)
* local ray = Ray.new(unitRay.Origin, unitRay.Direction \* length)
*/
ViewportPointToRay(this: Camera, x: number, y: number, depth?: number): Ray;
/**
* This function returns the screen location and depth of a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) _worldPoint_ and whether this point is visible on the screen or not.
*
* 
*
* This function takes in account the current GUI inset (such as the space occupied by the top bar). This means the 2D position returned is in the same term as GUI positions and can be used to place GUI elements. For an otherwise identical function that ignores the GUI inset, see [Camera:WorldToViewportPoint](https://developer.roblox.com/en-us/api-reference/function/Camera/WorldToViewportPoint).
*
* For example:
*
* local camera = workspace.CurrentCamera
* local worldPoint = Vector3.new(0, 10, 0)
* local vector, onScreen = camera:WorldToScreenPoint(worldPoint)
*
* local screenPoint = Vector2.new(vector.X, vector.Y)
* local depth = vector.Z
*
* Note this function does not perform any raycasting, meaning the visible bool will be true regardless if the _worldPoint_ is obscured by [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain).
*/
WorldToScreenPoint(this: Camera, worldPoint: Vector3): LuaTuple<[Vector3, boolean]>;
/**
* This function returns the screen location and depth of a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) _worldPoint_ and whether this point is visible on the screen or not.
*
* 
*
* This function does not take in account the current GUI inset (such as the space occupied by the top bar). This means the 2D position returned is taken from the top left corner of the viewport. This means, unless you are using [ScreenGui.IgnoreGuiInset](https://developer.roblox.com/en-us/api-reference/property/ScreenGui/IgnoreGuiInset) this position is not appropriate for placing GUI elements.
*
* For an otherwise identical function that accounts for the GUI inset, see [Camera:WorldToScreenPoint](https://developer.roblox.com/en-us/api-reference/function/Camera/WorldToScreenPoint).
*
* For example:
*
* local camera = workspace.CurrentCamera
* local worldPoint = Vector3.new(0, 10, 0)
* local vector, inViewport = camera:WorldToViewportPoint(worldPoint)
*
* local viewportPoint = Vector2.new(vector.X, vector.Y)
* local depth = vector.Z
*
* Note this function does not perform any raycasting, meaning the visible bool will be true regardless if the _worldPoint_ is obscured by [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain).
*/
WorldToViewportPoint(this: Camera, worldPoint: Vector3): LuaTuple<[Vector3, boolean]>;
ZoomToExtents(this: Camera, boundingBoxCFrame: CFrame, boundingBoxSize: Vector3): void;
/**
* This event fires when the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) has finished interpolating using the [Camera:Interpolate](https://developer.roblox.com/en-us/api-reference/function/Camera/Interpolate) function.
*
* This event will not fire if a tween is interrupted due to [Camera:Interpolate](https://developer.roblox.com/en-us/api-reference/function/Camera/Interpolate) being called again.
*
* You are advised to use [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) to animate the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) instead, as it is more reliable and provides more options for easing styles.
*/
readonly InterpolationFinished: RBXScriptSignal<() => void>;
}
interface CaptureService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CaptureService: unique symbol;
PromptShareCapture(this: CaptureService, contentId: string, launchData: object, onAcceptedCallback: Callback, onDeniedCallback: Callback): void;
readonly UserCaptureSaved: RBXScriptSignal<(captureContentId: string) => void>;
}
/** Base class for objects that change a character's appearance. */
interface CharacterAppearance extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CharacterAppearance: unique symbol;
}
/** BodyColors is a utility object used by Roblox to load avatar body colors from the website.
*
* Avatars that are loaded from the website will automatically have a BodyColors object corresponding to said avatar's body color configuration.
*
* When parented inside of a character with a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), it will apply the colors to each specified limb.
*/
interface BodyColors extends CharacterAppearance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BodyColors: unique symbol;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
HeadColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
HeadColor3: Color3;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
LeftArmColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
LeftArmColor3: Color3;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
LeftLegColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
LeftLegColor3: Color3;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
RightArmColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
RightArmColor3: Color3;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
RightLegColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
RightLegColor3: Color3;
/**
* Sets the color of this limb, as a [BrickColor](https://developer.roblox.com/api-reference/datatype/BrickColor "API:BrickColor").
*/
TorsoColor: BrickColor;
/**
* Sets the color of this limb, as a [Color3](https://developer.roblox.com/api-reference/datatype/Color3 "API:Color3").
*/
TorsoColor3: Color3;
}
/** This property modifies the appearance of an R6 body part. It has no effect in R15 characters. */
interface CharacterMesh extends CharacterAppearance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CharacterMesh: unique symbol;
/**
* The texture of a CharacterMesh. It can be overridden by Shirts, Pants, T-Shirts, and the [CharacterMesh.OverlayTextureId](https://developer.roblox.com/en-us/api-reference/property/CharacterMesh/OverlayTextureId) property.
*/
BaseTextureId: number;
/**
* The part of the Character's body that is affected.
*/
BodyPart: Enum.BodyPart;
/**
* Used to load a mesh file, and apply it to the given BodyPart.
*/
MeshId: number;
/**
* The assetId of the overlay texture. The overlay covers Shirts, Pants, T-Shirts, and the [CharacterMesh.BaseTextureId](https://developer.roblox.com/en-us/api-reference/property/CharacterMesh/BaseTextureId).
*/
OverlayTextureId: number;
}
/** The base class for clothing objects. */
interface Clothing extends CharacterAppearance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Clothing: unique symbol;
/**
* This property determines the colorization to be applied to the [Clothing](https://developer.roblox.com/en-us/api-reference/class/Clothing) texture. The default colorization value is \`DataType/Color3|Color3.new(1,1,1) (white). When set to white no colorization occurs
*
* It functions similarly to [ImageLabel.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageColor3) and [Decal.Color3](https://developer.roblox.com/en-us/api-reference/property/Decal/Color3)except that it is applied to Clothing textures.
*
* It is useful for creating outfits that have many different color variations, but share the same basic look, possibly for a character creator in a roleplaying game or generating a lot of different varied NPCs.
*
* ### Examples
*
* * Outfits that fade to different colors over time
* * Outfits that have many different color variations, but share the same basic look
* * A targeting texture that changes from red to blue when you target a specific type of object
*
* The image below demonstrates the same shirt with two different colorizations. The first shirt has a red colorization and the second shirt has a blue colorization.
*
* 
*
* ### See also
*
* * [ShirtGraphic.Color3](https://developer.roblox.com/en-us/api-reference/property/ShirtGraphic/Color3), determines the colorization to be applied to the ShirtGraphic texture
*/
Color3: Color3;
}
/**  The **Pants** object displays a Pants texture from the Roblox website on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) rig. Pants cover the torso and legs, and will be covered by a [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt) on the torso. To be visible, a Pants must be a sibling of a Humanoid and have its [PantsTemplate](https://developer.roblox.com/en-us/api-reference/property/Pants/PantsTemplate) property set to an appropriate texture (such as `rbxassetid://86896501`, pictured to the right). The pants texture may be colorized using the [Clothing.Color3](https://developer.roblox.com/en-us/api-reference/property/Clothing/Color3) property.
*
* Pants are automatically loaded on [Player](https://developer.roblox.com/en-us/api-reference/class/Player) characters if their avatar is wearing one.
*
* See also
* --------
*
* * [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt), an object which works similarly with the torso and arms
* * [Making Avatar Clothing](https://developer.roblox.com/articles/How-to-Make-Shirts-and-Pants-for-Roblox-Characters), which goes into detail about creating Shirts and Pants
*/
interface Pants extends Clothing {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Pants: unique symbol;
/**
* Determines the texture of the [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants). The content ID link pointing to the pants template hosted on the Roblox website.
*
* How do I find the PantsTemplate?
* --------------------------------
*
* This content ID is different to the website URL of the pants. The content ID can be found by pasting the website URL of the pants into the PantsTemplate property in Roblox Studio, as studio will correct it. Alternatively [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) can be used to insert the pants into the workspace, for example:
*
* ```lua
* local webURL = "https://www.roblox.com/catalog/1804739/Jeans"
* local assetId = tonumber(string.match(webURL, "%d+") or 0) -- extract the number
* local success, model = pcall(function()
* return game:GetService("InsertService"):LoadAsset(assetId)
* end)
* if success then
* model.Parent = workspace
* end
* ```
*
* For a [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt) object's template, see [Shirt.ShirtTemplate](https://developer.roblox.com/en-us/api-reference/property/Shirt/ShirtTemplate).
*/
PantsTemplate: string;
}
/**  The **Shirt** object displays a Shirt texture from the Roblox website on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) rig. Shirts cover the torso and arms, and will take priority over a [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants) on the torso. To be visible, a Shirt must be a sibling of a Humanoid and have its [ShirtTemplate](https://developer.roblox.com/en-us/api-reference/property/Shirt/ShirtTemplate) property set to an appropriate texture (such as `rbxassetid://86896487`, pictured to the right). The shirt texture may be colorized using the [Clothing.Color3](https://developer.roblox.com/en-us/api-reference/property/Clothing/Color3) property.
*
* Shirts are automatically loaded on [Player](https://developer.roblox.com/en-us/api-reference/class/Player) characters if their avatar is wearing one.
*
* See also
* --------
*
* * [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants), an object which works similarly with the torso and legs
* * [Making Avatar Clothing](https://developer.roblox.com/articles/How-to-Make-Shirts-and-Pants-for-Roblox-Characters), which goes into detail about creating Shirts and Pants
*/
interface Shirt extends Clothing {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Shirt: unique symbol;
/**
* The content ID link pointing to the shirt template hosted on the Roblox website. Determines the texture of the [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt).
*
* See also [ShirtGraphic.Graphic](https://developer.roblox.com/en-us/api-reference/property/ShirtGraphic/Graphic) for the image applied to T-shirts.
*
* Finding the ShirtTemplate ID
* ----------------------------
*
* This content ID is different than the website URL of the shirt. It can be found by pasting the website URL of the shirt into the **ShirtTemplate** property in Studio, as Studio will correct it. Alternatively [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) can be used to insert the shirt into the workspace, for example:
*
* local webURL = "https://www.roblox.com/catalog/1804747/White-Shirt"
* local assetId = tonumber(string.match(webURL, "%d+") or 0) -- Extract the number
* local success, model = pcall(function()
* return game:GetService("InsertService"):LoadAsset(assetId)
* end)
* if success then
* model.Parent = workspace
* end
*/
ShirtTemplate: string;
}
/** The **ShirtGraphic** object applies a texture to the front surface of a character's torso. It is used to display t-shirts. */
interface ShirtGraphic extends CharacterAppearance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ShirtGraphic: unique symbol;
/**
* This property determines the colorization to be applied to the [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) texture. It functions similarly to [ImageLabel.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageColor3) except that it is applied to [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) textures. This is useful for creating shirt graphics that have many different color variations but share the same basic look.
*
* See Also
* --------
*
* * [Clothing.Color3](https://developer.roblox.com/en-us/api-reference/property/Clothing/Color3) which determines the colorization to be applied to the [Clothing](https://developer.roblox.com/en-us/api-reference/class/Clothing) texture
*/
Color3: Color3;
/**
* The content ID link pointing to the [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) texture hosted on the Roblox website. This property sets the texture associated with a t-shirt.
*
* Finding the ID
* --------------
*
* This content ID is different than the website URL of the t-shirt. It can be found by pasting the website URL of the t-shirt into the **Graphic** property of the [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) in Roblox Studio, as Studio will correct it. Alternatively [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) can be used to insert the t-shirt into the workspace, for example:
*
* local webURL = "https://www.roblox.com/catalog/2591161/Sword-Fight-on-the-Heights-Ring-of-Fire-T-Shirt"
* local assetId = tonumber(string.match(webURL, "%d+") or 0) -- Extract the number
*
* local success, model = pcall(function()
* return game:GetService("InsertService"):LoadAsset(assetId)
* end)
*
* if success then
* model.Parent = workspace
* end
*/
Graphic: string;
}
/** The **Chat** service houses the Lua code responsible for running the [Lua Chat System](https://developer.roblox.com/en-us/articles/lua-chat-system). Similar to [StarterPlayerScripts](https://developer.roblox.com/en-us/api-reference/class/StarterPlayerScripts), default objects like [Scripts](https://developer.roblox.com/en-us/api-reference/class/Script) and [ModuleScripts](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) are inserted into the service.
*
* In addition to housing the [Lua Chat System](https://developer.roblox.com/en-us/articles/lua-chat-system), this service also exposes functions used to filter text: [FilterStringAsync()](https://developer.roblox.com/en-us/api-reference/function/Chat/FilterStringAsync) and [FilterStringForBroadcast()](https://developer.roblox.com/en-us/api-reference/function/Chat/FilterStringForBroadcast). Note that **games which implement custom chat systems must use these functions to filter chat properly.** See [Text and Chat Filtering](https://developer.roblox.com/en-us/articles/text-and-chat-filtering) for more information.
*/
interface Chat extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Chat: unique symbol;
/**
* If true, entering a message in the chat will result in a chat bubble popping up above the player's [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character). This behavior can either be enabled by directly ticking this checkbox in Studio, or by using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript):
*
* local ChatService = game:GetService("Chat")
* ChatService.BubbleChatEnabled = true
*
* This must be done on the client, toggling this value in a server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script) will have no effect.
*
* See also
* --------
*
* Developers who are interested interested in configuring their games' bubble chat system even further should take a look at the [Bubble Chat](https://developer.roblox.com/en-us/articles/bubble-chat) article.
*/
BubbleChatEnabled: boolean;
/**
* Toggles whether the default chat framework should be automatically loaded when the game runs.
*/
readonly LoadDefaultChat: boolean;
/**
* The Chat function fires the [Chat.Chatted](https://developer.roblox.com/en-us/api-reference/event/Chat/Chatted) event with the parameters specified in this method.
*
* By default, there is a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) inside of each player's [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts) object named _BubbleChat_, which causes a dialog-like billboard to appear above the _partOrCharacter_ when the chatted event is fired.
*
* _Note:_ Since dialogs are controlled by a LocalScript, you will not be able to see any dialogs created from this method unless you are running in _Play Solo_ mode.
*/
Chat(this: Chat, partOrCharacter: BasePart | Model, message: string, color?: CastsToEnum): void;
/**
* InvokeChatCallback will call a function registered by [RegisterChatCallback](https://developer.roblox.com/en-us/api-reference/function/Chat/RegisterChatCallback), given the ChatCallbackType enum and the arguments to send the function. It will return the result of the registered function, or raise an error if no function has been registered.
*
* This function is called by the Lua Chat System so that chat callbacks may be registered to change the behavior of certain features. Unless you are replacing the default Lua Chat System with your own, you should not need to call this function. You can read about the different callback functions at [Chat:RegisterChatCallback](https://developer.roblox.com/en-us/api-reference/function/Chat/RegisterChatCallback).
*/
InvokeChatCallback(this: Chat, callbackType: CastsToEnum, callbackArguments: Array): unknown;
/**
* RegisterChatCallback binds a function to some chat system event in order to affect the behavior of the Lua chat system. The first argument determines the event (using the `ChatCallbackType` enum) to which the second argument, the function, shall be bound. The default Lua chat system uses [InvokeChatCallback](https://developer.roblox.com/en-us/api-reference/function/Chat/InvokeChatCallback) to invoke registered functions. Attempting to register a server- or client- only callback on a peer that isn't a server or client respectively will raise an error. The following sections describe in what ways registered functions will be used.
*
* OnCreatingChatWindow
* --------------------
*
* Client-only. Invoked before the client constructs the chat window. Must return a table of settings to be merged into the information returned by the ChatSettings module.
*
* OnClientFormattingMessage
* -------------------------
*
* Client-only. Invoked before the client displays a message (whether it is a player chat message, system message, or /me command). This function is invoked with the message object and may (or may not) return a table to be merged into `message.ExtraData`.
*
* OnClientSendingMessage
* ----------------------
*
* Not invoked at this time.
*
* OnServerReceivingMessage
* ------------------------
*
* Server-only. Invoked when the server receives a message from a speaker (note that speakers may not necessarily be a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) chatting). This callback is called with the Message object. The function can make changes to the Message object to change the manner in which the message is processed. **The Message object must be returned for this callback to do anything.** Setting this callback can allow the server to, for example:
*
* * Set `message.ShouldDeliver` to false in order to cancel delivery of the message to players (useful for implementing a chat blacklist)
* * Get/set the speaker's name color (`message.ExtraData.NameColor`, a Color3) on a message-by-message basis
*/
RegisterChatCallback(this: Chat, callbackType: CastsToEnum, callbackFunction: Callback): void;
/**
* **Note**
*
* For a more detailed walkthrough, take a look at the [Bubble Chat](../../articles/applying-strokes) and [Lua Chat System](articles/Lua Chat System) articles.
*
* This function customizes various settings of the in-game bubble chat.
*
* Before using this, make sure that bubble chat is enabled by setting [Chat.BubbleChatEnabled](https://developer.roblox.com/en-us/api-reference/property/Chat/BubbleChatEnabled) to true.
*
* The settings argument is a table where the keys are the names of the settings you want to edit and the values are what you want to change these settings to. Note that you don't have to include all of them in the settings argument, omitting some will result in them keeping their default value.
*
* This function is client-side only, attempting to call it on the server will trigger an error.
*/
SetBubbleChatSettings(this: Chat, settings: unknown): void;
/**
* Will return false if the player with the specified [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) is not allowed to chat because of their account settings.
*
* Tags: Yields
*/
CanUserChatAsync(this: Chat, userId: number): boolean;
/**
* Will return false if the two users cannot communicate because their account settings do not allow it.
*
* Tags: Yields
*/
CanUsersChatAsync(this: Chat, userIdFrom: number, userIdTo: number): boolean;
/**
* **Partial Deprecation Warning**
* Calling this function from the client using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) is deprecated, and will be disabled in the future. Text filtering should be done from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on the server using the similarly-named [TextService:FilterStringAsync](https://developer.roblox.com/en-us/api-reference/function/TextService/FilterStringAsync), which uses a different set of parameters and return type.
*
* Games that do not properly filter player-generated text maybe subject to moderation action. Please be sure a game properly filters text before publishing it.
*
* **FilterStringAsyc** will filter a [string](https://developer.roblox.com/en-us/articles/string) using filtering that is appropriate for the sending and receiving player. If the filtered string is to be used for a persistent message, such as the name of a shop, writing on a plaque, etc, then the function should be called with the author as both the sender and receiver.
*
* This function should be used **every time** a player can enter custom text in **any context**, most commonly using a [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox). Some examples of text to be filtered:
*
* * Custom chat messages
* * Custom character names
* * Names for a shop in a tycoon-style game
*
* Tags: Yields
*/
FilterStringAsync(this: Chat, stringToFilter: string, playerFrom: Player, playerTo: Player): string;
/**
* Filters a string sent from _playerFrom_ for broadcast to no particular target. The filtered message has more restrictions than [Chat:FilterStringAsync](https://developer.roblox.com/en-us/api-reference/function/Chat/FilterStringAsync).
*
* Some examples of where this method could be used:
*
* * \-Message walls
* * \-Cross-server shouts
* * \-User-created signs
*
* Calling FilterString from [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s is deprecated and will be disabled in the future. Text filtering should be done from server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s using FilterStringAsync.
*
* _Note:_ A game not using this filter function for custom chat or other user generated text may be subjected to moderation action.
*
* Tags: Yields
*/
FilterStringForBroadcast(this: Chat, stringToFilter: string, playerFrom: Player): string;
/**
* The FilterStringForPlayerAsync function filters a string appropriate to the given player's age settings, so they see what is appropriate to them. This function will only work if called from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on the server. If called on a client it will fail.
*
* Tags: Yields
* @deprecated Use `FilterStringAsync` instead
*/
FilterStringForPlayerAsync(this: Chat, stringToFilter: string, playerToFilterFor: Player): string;
/**
* Fires when [Chat:Chat](https://developer.roblox.com/en-us/api-reference/function/Chat/Chat) is called.
*/
readonly Chatted: RBXScriptSignal<(part: BasePart, message: string, color: Enum.ChatColor) => void>;
}
interface ChatbotUIService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ChatbotUIService: unique symbol;
}
/**  
*
* **ClickDetector** allows [Scripts](https://developer.roblox.com/en-us/api-reference/class/Script) and [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript) to receive pointer input on 3D objects through their [MouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseClick) event. They work when parented to [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), [Model](https://developer.roblox.com/en-us/api-reference/class/Model) or [Folder](https://developer.roblox.com/en-us/api-reference/class/Folder) objects. They detect basic mouse events: enter, leave, left click and right click. Touch input on [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) devices also fires click events.
*
* The default control scripts bind the ButtonR2 [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode) to interact with ClickDetectors using [ContextActionService:BindActivate](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActivate), which can also be used to override this. When using gamepads, the center dot triggers [MouseHoverEnter](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverEnter)/[MouseHoverLeave](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverLeave). The bound activation button fires [MouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseClick).
*
* Below is a simple template script for working with ClickDetectors. Paste it into a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* local clickDetector = workspace.Part.ClickDetector
*
* function onMouseClick()
* print("You clicked me!")
* end
*
* clickDetector.MouseClick:connect(onMouseClick)
*
* [MaxActivationDistance](https://developer.roblox.com/en-us/api-reference/property/ClickDetector/MaxActivationDistance) can be used to limit the distance a player may be from a ClickDetector object before it is no longer clickable.
*
* ClickDetector events fire on both the client and the server. Since a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) will only run if it descends from a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) or Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character), it's usually not useful to put a LocalScript inside a ClickDetector since the script won't run, or the object won't be clickable. If you need a LocalScript to detect ClickDetector events, [StarterPlayerScripts](https://developer.roblox.com/en-us/api-reference/class/StarterPlayerScripts) may be a better place instead.
*
* Input Priority
* --------------
*
* If multiple ClickDetectors would detect a user input, only the deepest ClickDetector will fire events. If an action bound with [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService) uses the same input as a ClickDetector, the action bound with ContextActionService will take priority over ClickDetector events. If two ClickDetectors are siblings, the first ClickDetector will take priority. [UserInputService.InputBegan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputBegan) will fire before ClickDetector events. Due to the nature of user input, you ought not depend on all [MouseHoverEnter](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverEnter) events to fire a matching [MouseHoverLeave](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverLeave) event.
*/
interface ClickDetector extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ClickDetector: unique symbol;
/**
* The CursorIcon sets the mouse icon that will be displayed when the `Mouse/mouse` hovers over this [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector).
*
* If this property is left blank, the ClickDetector will use the default icon:
*
* 
*
* To change the ClickDetector's cursor icon, set the property to the asset id or URL of the image you would like to use. For instance, setting the property to `2287179377` or [this](https://www.roblox.com/My/Item.aspx?ID=2287179377) URL changes the cursor icon to:
*
* 
*/
CursorIcon: string;
/**
* The MaxActivationDistance property controls the maximum distance, in studs, between a [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) and the [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector) for the character to be able to click it. This is used to limit from how far a player can interact with a ClickDetector.
*
* For instance, a character within `10` studs of a ClickDetector with a MaxActivationDistance of `5` would not be able to click the ClickDetector because they are out of range. If, however, the MaxActivationDistance was `15`, the character would be able to click it.
*/
MaxActivationDistance: number;
/**
* The MouseClick event fires when a player presses and releases the left mouse button while the cursor is hovering over a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Model](https://developer.roblox.com/en-us/api-reference/class/Model) with a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector). Additionally, the Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) must be within the [MaxActivationDistance](https://developer.roblox.com/en-us/api-reference/property/ClickDetector/MaxActivationDistance) of the clicked object. This event fires when using either a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Platform Support
* ----------------
*
* * On [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) platforms, this event fires when the user taps on the same model.
* * On [GamepadEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/GamepadEnabled) platforms, this event fires when the center dot is over the same model and the A button is pressed and released.
*
* Related Events
* --------------
*
* * If you want to check when a player right clicks on the ClickDetector, you can use the [RightMouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/RightMouseClick) event.
* * If you want a function to fire when a player hovers on or off of the ClickDetector without mouse clicking it you can use the [MouseHoverEnter](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverEnter) and [MouseHoverLeave](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverLeave) events.
*/
readonly MouseClick: RBXScriptSignal<(playerWhoClicked: Player) => void>;
/**
* The MouseHoverEnter event fires when the player's [mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) begins hovering over the [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector)'s parent. This event fires when using either a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Due to the nature of user input, you ought not depend on all MouseHoverEnter events to fire a matching [MouseHoverLeave](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverLeave) event.
*
* The player does not have to click the ClickDetector for this event to fire. If you want an event to execute when the player clicks, you can use [ClickDetector.MouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseClick) and [ClickDetector.RightMouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/RightMouseClick) events.
*/
readonly MouseHoverEnter: RBXScriptSignal<(playerWhoHovered: Player) => void>;
/**
* The MouseHoverLeave event fires when a player's [mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) moves off of the [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector)'s parent. This event fires when using either a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Due to the nature of user input, you ought not depend on all [MouseHoverEnter](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverEnter) events to fire a matching MouseHoverLeave event.
*
* The player does not have to click the ClickDetector for this event to fire. If you want an function to run when the player clicks, you can use [ClickDetector.MouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseClick) and [ClickDetector.RightMouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/RightMouseClick) events.
*/
readonly MouseHoverLeave: RBXScriptSignal<(playerWhoHovered: Player) => void>;
/**
* The RightMouseClick event fires when a player presses and releases the right mouse button while the cursor is hovering over a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Model](https://developer.roblox.com/en-us/api-reference/class/Model) with a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector). Additionally, the Player's [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) must be within the [MaxActivationDistance](https://developer.roblox.com/en-us/api-reference/property/ClickDetector/MaxActivationDistance) of the clicked object. This event fires when using either a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Related Events
* --------------
*
* * If you want to check when a player left clicks on the ClickDetector, you can use the [MouseClick](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseClick) event.
* * If you want a function to fire when a player hovers on or off of the ClickDetector without clicking it you can use the [MouseHoverEnter](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverEnter) and [MouseHoverLeave](https://developer.roblox.com/en-us/api-reference/event/ClickDetector/MouseHoverLeave) events.
*/
readonly RightMouseClick: RBXScriptSignal<(playerWhoClicked: Player) => void>;
}
interface DragDetector extends ClickDetector {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DragDetector: unique symbol;
ActivatedCursorIcon: string;
ApplyAtCenterOfMass: boolean;
/**
* Tags: NotReplicated
*/
Axis: Vector3;
DragFrame: CFrame;
DragStyle: Enum.DragDetectorDragStyle;
Enabled: boolean;
GamepadModeSwitchKeyCode: Enum.KeyCode;
KeyboardModeSwitchKeyCode: Enum.KeyCode;
MaxDragAngle: number;
MaxDragTranslation: Vector3;
MaxForce: number;
MaxTorque: number;
MinDragAngle: number;
MinDragTranslation: Vector3;
Orientation: Vector3;
ReferenceInstance: Instance | undefined;
ResponseStyle: Enum.DragDetectorResponseStyle;
Responsiveness: number;
RunLocally: boolean;
/**
* Tags: NotReplicated
*/
SecondaryAxis: Vector3;
TrackballRadialPullFactor: number;
TrackballRollFactor: number;
VRSwitchKeyCode: Enum.KeyCode;
/**
* Tags: NotReplicated
*/
WorldAxis: Vector3;
/**
* Tags: NotReplicated
*/
WorldSecondaryAxis: Vector3;
AddConstraintFunction(this: DragDetector, priority: number, callback: Callback): RBXScriptConnection;
GetReferenceFrame(this: DragDetector): CFrame;
RestartDrag(this: DragDetector): void;
SetDragStyleFunction(this: DragDetector, callback: Callback): void;
readonly DragContinue: RBXScriptSignal<(playerWhoDragged: Player, cursorRay: Ray, viewFrame: CFrame, vrInputFrame: CFrame | undefined, isModeSwitchKeyDown: boolean) => void>;
readonly DragEnd: RBXScriptSignal<(playerWhoDragged: Player) => void>;
readonly DragStart: RBXScriptSignal<(playerWhoDragged: Player, cursorRay: Ray, viewFrame: CFrame, hitFrame: CFrame, clickedPart: BasePart, vrInputFrame: CFrame | undefined, isModeSwitchKeyDown: boolean) => void>;
}
/** The **Clouds** object renders realistic clouds that drift slowly across the sky. Both cloud cover and density can be adjusted, as well as cloud color to achieve atmospheres like stormy skies, moody sunsets, alien worlds, etc.
*
* See the [Dynamic Clouds](https://developer.roblox.com/articles/dynamic-clouds) article for a summary of properties and expected results.
*/
interface Clouds extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Clouds: unique symbol;
/**
* This property controls the material color of cloud particles. However, cloud color is influenced by several [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) and [Atmosphere](https://developer.roblox.com/en-us/api-reference/class/Atmosphere) properties, so it is not intended as a dedicated property to simulate colored sunsets, sunrises, etc.
*
* See the [Dynamic Clouds](https://developer.roblox.com/articles/dynamic-clouds) article for a summary of properties and expected results.
*/
Color: Color3;
/**
* This property defines the cloud cover within the overall skyscape layer. Valid range is from 0 to 1 (sparse cloud cover to full cloud cover).
*
* See the [Dynamic Clouds](https://developer.roblox.com/articles/dynamic-clouds) article for a summary of properties and expected results.
*/
Cover: number;
/**
* This property controls the particulate density of clouds (the proportion of airborne water vapor particles at full cloud cover).
*
* See the [Dynamic Clouds](https://developer.roblox.com/articles/dynamic-clouds) article for a summary of properties and expected results.
*/
Density: number;
/**
* This property toggles rendering of the [Clouds](https://developer.roblox.com/en-us/api-reference/class/Clouds) object. Useful for toggling on/off different [Clouds](https://developer.roblox.com/en-us/api-reference/class/Clouds) objects that exist in the same place.
*/
Enabled: boolean;
}
interface Collaborator extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Collaborator: unique symbol;
CFrame: CFrame;
CollaboratorColor: number;
CurDocGUID: string;
CurScriptLineNumber: number;
UserId: number;
Username: string;
}
interface CollaboratorsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CollaboratorsService: unique symbol;
}
/** The [CollectionService](https://developer.roblox.com/en-us/api-reference/class/CollectionService) manages groups (collections) of instances with tags. Tags are sets of strings applied to objects that replicate from the server to the client and in Team Create. They are also serialized when places are saved. At the moment, tags are not visible within Roblox Studio except with the use of a tag-editing plugin.
*
* The primary use of [CollectionService](https://developer.roblox.com/en-us/api-reference/class/CollectionService) is to add flags and/or behaviors to Roblox objects. If you find yourself adding the same script to many different objects, perhaps a script that uses CollectionService would be better. Here are a couple examples:
*
* * In an obstacle course with many bricks that kill players, don't paste the same script in all your kill bricks! Instead, tag them with “KIllBrick”. Then, have any brick tagged as such kill the player.
* * Payers with a VIP game pass could have their [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) tagged “VIP”, and be allowed through doors that only allow VIPs.
* * When creating a freeze-tag game, you could tag frozen players' [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) objects with a “Frozen” tag. Then, use a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) to listen for the “Frozen” tag and create client-side visual effects to reduce the number of objects replicated from server to client.
*
* When working with collections and tags, it's a good idea to use an [object-oriented programming style](https://www.lua.org/pil/16.html). In almost all situations, tagged objects have their own identity, state and behavior. The pattern goes like this: when a tag is found ([CollectionService:GetTagged](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetTagged) and [CollectionService:GetInstanceAddedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceAddedSignal)), create a Lua object with the Roblox instance. When it is removed ([CollectionService:GetInstanceRemovedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceRemovedSignal)), call a cleanup/destroy method within the Lua object. See the code samples for a better idea of how this can be done.
*
* Replication
* -----------
*
* When tags replicate, **all tags on an object replicate at the same time**. Therefore, if you set a tag on an object from the client then add/remove a **different** tag on the same object from the server, the client's local tags on the object are overwritten. In [StreamingEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingEnabled) places, instances can be unloaded as they leave the client's streamed area. If such an instance re-enters the streamed area, properties and tags will be re-synchronized from the server. This can cause changes made by [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s to be overwritten/removed.
*/
interface CollectionService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CollectionService: unique symbol;
/**
* AddTag will apply a tag to an object. This method will not throw an error if the object already had the tag. Successfully adding a tag will fire a signal created by [CollectionService:GetInstanceAddedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceAddedSignal) with the given tag.
*
* **Warning:** When tagging an object, it is common that some resources are used to give the tag its functionality, e.g. event connections or tables. To prevent memory leaks, it is a good idea to clean these up (disconnect, set to nil, etc) when no longer needed for a tag. Do this when calling [CollectionService:RemoveTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/RemoveTag), calling [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) or in a function connected to a signal returned by [CollectionService:GetInstanceRemovedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceRemovedSignal).
*/
AddTag(this: CollectionService, instance: Instance, tag: string): void;
AddTag(this: Instance, tag: string): void;
GetAllTags(this: CollectionService): unknown;
/**
* GetInstanceAdded is given a tag (a string) and returns a signal which fires under two conditions:
*
* * The tag is assigned to an object within the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) (game) using [CollectionService:AddTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/AddTag)
* * An object with the given tag is added as a descendant of the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel), e.g. by setting [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) or similar
*
* Subsequent calls to this method with the same tag return the same signal object. Consider also calling [CollectionService:GetTagged](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetTagged) to get a list of objects that already have a tag (and thus won't fire the event if they already are in the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel)).
*
* See also [CollectionService:GetInstanceRemovedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceRemovedSignal), which returns an event that fires under similar conditions.
*/
GetInstanceAddedSignal(this: CollectionService, tag: string): RBXScriptSignal<(instance: Instance) => void>;
/**
* GetInstanceRemoved is given a tag (a string) and returns a signal which fires under two conditions:
*
* * The tag is removed from an object within the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) (game) using [CollectionService:RemoveTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/RemoveTag)
* * An object with the given tag is removed as a descendant of the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel), e.g. by un-setting [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) or similar
*
* Subsequent calls to this method with the same tag return the same signal object. The signal is useful for cleaning up resources used by objects that once had tags, such as disconnecting connections.
*
* See also [CollectionService:GetInstanceAddedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceAddedSignal), which returns an event that fires under similar conditions.
*/
GetInstanceRemovedSignal(this: CollectionService, tag: string): RBXScriptSignal<(instance: Instance) => void>;
/**
* GetTagged returns a table of objects with a given tag which are descendants of the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) (`game`). Such tags have been added using [CollectionService:AddTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/AddTag), and removing a tag using [CollectionService:RemoveTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/RemoveTag) will ensure this method does not return them. Although the name of this method is past-tense, this method only returns objects **presently** tagged with the given tag. It will not return objects that once had a tag but no longer have it.
*
* If you want to detect all objects with a tag, both present and future, use this method to iterate over objects while also making a connection to a signal returned by `CollectionService/GetinstanceAddedSignal`.
*
* This method does not guarantee any ordering of the returned objects. Additionally, it is possible that objects can have the given tag assigned to them, but not be a descendant of the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel), i.e. its parent is nil. This method will not return such objects.
*/
GetTagged(this: CollectionService, tag: string): Array;
/**
* GetTags is given an object and returns a table of strings, which are the tags applied to the given object.
*
* local CollectionService = game:GetService("CollectionService")
* local object = workspace.Model
* local tags = CollectionService:GetTags(object)
* print("The object " .. object:GetFullName() .. " has tags: " .. table.concat(tags, ", "))
*
* This method is useful when you want to do something with multiple tags at once on an object. However, it would be inefficient to use this method to check for the existence of a single tag. For this, use [CollectionService:HasTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/HasTag) to check for a single tag.
*/
GetTags(this: CollectionService, instance: Instance): Array;
GetTags(this: Instance): Array;
/**
* HasTag returns whether a given object has a tag
*
* * Using [CollectionService:AddTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/AddTag) to add the tag will cause this method to return true.
* * Using [CollectionService:RemoveTag](https://developer.roblox.com/en-us/api-reference/function/CollectionService/RemoveTag) to remove the tag will cause this method to return false.
*
* By extension, any tags returned by a call to `CollectionServiec/GetTags` on an object will return true when used with this method.
*/
HasTag(this: CollectionService, instance: Instance, tag: string): boolean;
HasTag(this: Instance, tag: string): boolean;
/**
* RemoveTag will remove some tag from some object. This method will not throw an error if the object did not have the tag in the first place. Successfully removing a tag will fire a signal created by [CollectionService:GetInstanceRemovedSignal](https://developer.roblox.com/en-us/api-reference/function/CollectionService/GetInstanceRemovedSignal) with the given tag.
*
* When removing a tag, it is common that some resources are used to give the tag its functionality, e.g. event connections or tables. To prevent memory leaks, it is a good idea to clean these up (disconnect, set to nil, etc) when no longer needed for a tag.
*/
RemoveTag(this: CollectionService, instance: Instance, tag: string): void;
RemoveTag(this: Instance, tag: string): void;
/**
* This function fires when a [Configuration](https://developer.roblox.com/en-us/api-reference/class/Configuration), [CustomEvent](https://developer.roblox.com/en-us/api-reference/class/CustomEvent), [CustomEventReceiver](https://developer.roblox.com/en-us/api-reference/class/CustomEventReceiver), [Dialog](https://developer.roblox.com/en-us/api-reference/class/Dialog), or [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat) is added to the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel).
* @deprecated Use `GetInstanceAddedSignal` instead
*/
readonly ItemAdded: RBXScriptSignal<(instance: Instance) => void>;
/**
* This function fires when a [Configuration](https://developer.roblox.com/en-us/api-reference/class/Configuration), [CustomEvent](https://developer.roblox.com/en-us/api-reference/class/CustomEvent), [CustomEventReceiver](https://developer.roblox.com/en-us/api-reference/class/CustomEventReceiver), [Dialog](https://developer.roblox.com/en-us/api-reference/class/Dialog), or [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat) is removed from the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel).
* @deprecated Use `GetInstanceRemovedSignal` instead
*/
readonly ItemRemoved: RBXScriptSignal<(instance: Instance) => void>;
readonly TagAdded: RBXScriptSignal<(tag: string) => void>;
readonly TagRemoved: RBXScriptSignal<(tag: string) => void>;
}
interface CommandInstance extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CommandInstance: unique symbol;
/**
* Tags: NotReplicated
*/
readonly AllowGUIAccessPoints: boolean;
/**
* Tags: NotReplicated
*/
DisplayName: string;
/**
* Tags: NotReplicated
*/
readonly Name: string;
}
interface CommandService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CommandService: unique symbol;
}
/** The Configuration object is a container object that is designed to hold value objects to make values used in [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool)s or any model using [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s more accessible.
*
* How does the Configuration object work?
* ---------------------------------------
*
* The Configuration object is just a container, and does not automatically offer any additional functionality to a [Folder](https://developer.roblox.com/en-us/api-reference/class/Folder).
*
* Configurations should hold value objects ([BrickColorValue](https://developer.roblox.com/en-us/api-reference/class/BrickColorValue), [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue), [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue), [ObjectValue](https://developer.roblox.com/en-us/api-reference/class/ObjectValue) etc). These value objects should be read by the [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) associated with the configuration to determine constants such as damage, speed or color.
*
* For example,
*
* local damage = 10
*
* Becomes:
*
* local configuration = tool:FindFirstChildWhichIsA("Configuration", true)
* damage = configuration:FindFirstChild("Damage").Value -- A NumberValue
*
* The Configuration object is intended to be placed inside a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) in a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) or [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). It was originally intended to be used with a tool that provided a GUI interface to edit these properties. However it is more common now for developers to edit these values directly in the Roblox Studio properties window.
*
* Why should I use the Configuration object?
* ------------------------------------------
*
* Use of Configurations is optional, but a number of developers chose to use them for the following reasons.
*
* * Variables held in a Configuration can be found quickly and are in a single place
* * When sharing your work, others can make changes without needing to modify your code
* * Provides a single location for variables read by multiple scripts in more complex games
*/
interface Configuration extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Configuration: unique symbol;
}
interface ConfigureServerService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ConfigureServerService: unique symbol;
}
/** The base class for Constraint-based objects. */
interface Constraint extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Constraint: unique symbol;
/**
* True if the constraint is currently active in the world.
*
* True if the constraint and both of its parts are in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the constraint's [Constraint.Enabled](https://developer.roblox.com/en-us/api-reference/property/Constraint/Enabled) property is true.
*
* Tags: NotReplicated
*/
readonly Active: boolean;
/**
* The [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) that is connected to [Constraint.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1)
*/
Attachment0: Attachment | undefined;
/**
* The [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) that is connected to [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0)
*/
Attachment1: Attachment | undefined;
/**
* The color of the constraint.
*/
Color: BrickColor;
/**
* Toggles whether or not this Constraint is enabled.
*/
Enabled: boolean;
/**
* Toggles the visibility of this Constraint.
*/
Visible: boolean;
/**
* @deprecated
*/
GetDebugAppliedForce(this: Constraint, bodyId: number): Vector3;
/**
* @deprecated
*/
GetDebugAppliedTorque(this: Constraint, bodyId: number): Vector3;
}
/** An AlignOrientation attempts to constrain its [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0)'s orientation to the goal orientation, which is determined by [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) or [CFrame](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/CFrame) depending on the [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/Mode).
*
* 
*
* By default, this constraint only applies torque on [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0)'s parent, although it can be configured to apply torque on both attachments. This torque can be limited to a max amount via [AlignOrientation.MaxTorque](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/MaxTorque).
*
* **Note**
*
* Any torque created by AlignOrientation will be applied about the center of mass of the parent of the attachments (or the center of mass of parts rigidly connected to the parents). Also note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*
* Primary axis
* ------------
*
* The behavior of an AlignOrientation is determined by its [AlignOrientation.PrimaryAxisOnly](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/PrimaryAxisOnly) property. By default this value is false and an AlignOrientation will work so that the orientation of its Attachment0 exactly matches the orientation of its goal. It will apply torque about all 3 axes to achieve this goal.
*
* If PrimaryAxisOnly is set to true, then the AlignOrientation will only apply torque if the primary axis of its Attachment0 becomes unaligned with the goal. This means that any rotation about the Attachment0's primary axis will not create a torque.
*
* Torque magnitude
* ----------------
*
* The torque used to constrain an AlignOrientation can either be configured or set to the maximum that constraints allow. Whether the torque is configurable is determined by the [AlignOrientation.RigidityEnabled](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/RigidityEnabled) property.
*
* When RigidityEnabled is true, the physics solver reacts as quickly as possible to complete the alignment. This is the same scale of force used to align other constraints, such as prismatics when their attachments are misaligned.
*
* When RigidityEnabled is false, then the force will be determined by the MaxTorque, MaxAngularVelocity, and Responsiveness. MaxForce and MaxVelocity are caps to the torque and angular velocity respectively. The actual scale of the torque is determined by the Responsiveness. The mechanism for responsiveness is a little complicated, but put simply the higher the responsiveness, the quicker the constraint will try to reach its goal.
*
* Reaction Torque
* ---------------
*
* AlignOrientations by default only apply a torque on Attachment0's parent Part. The parent Part of Attachment1 remains unaffected. However, a torque can also be applied to Attachment1 by enabling the [AlignOrientation.ReactionTorqueEnabled](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/ReactionTorqueEnabled). This will cause a torque to be applied to both Attachment0 and Attachment1 in equal and opposite directions.
*
* See also
* --------
*
* * [Body Movers Example.rbxl](https://doy2mn9upadnk.cloudfront.net/uploads/default/original/3X/e/1/e17a844750802035b24f68ddcbd83f6312b8f1d6.rbxl), a sample place showcasing body movers in various configurations.
* * [Attachments and Constraints](https://developer.roblox.com/articles/Constraints), an article outlining how to create and use attachments and constraints
*/
interface AlignOrientation extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AlignOrientation: unique symbol;
/**
* The [AlignType](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/AlignType) specifies the desired relationship between the primary axes of the `AlignOrientation/Attachment0|Attachment0` and the goal. The constraint will try to maintain this relationship by applying forces within specified limits.
*
* This property is visible in Studio and meaningful only when [AlignOrientation.PrimaryAxisOnly](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/PrimaryAxisOnly) is set _true_.
*
* ### Enums
*
* It can be set to any of the possible [AlignType](https://developer.roblox.com/en-us/api-reference/enum/AlignType) values.
*
* Name
*
* Value
*
* Description
*
* ### Parallel
*
* 0
*
* Two parallel axes
*
* ### Perpendicular
*
* 1
*
* Two perpendicular axes
*/
AlignType: Enum.AlignType;
/**
* The orientation of the CFrame determines the goal orientation of the [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation) when its [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/Mode) is [OneAttachment](https://developer.roblox.com/en-us/api-reference/enum/OrientationAlignmentMode). The translation component of the CFrame is ignored.
*/
CFrame: CFrame;
/**
* Tags: NotReplicated
*/
LookAtPosition: Vector3;
/**
* The maximum angular velocity the constraint can use to reach its goal.
*/
MaxAngularVelocity: number;
/**
* The maximum torque the constraint can use to reach its goal.
*/
MaxTorque: number;
/**
* The Mode specifies the way its constraint determines its goal orientation.
*
* OneAttachment
* -------------
*
* The constraint attempts to match the orientation of [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to the orientation of [CFrame](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/CFrame). [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) is not used.
*
* TwoAttachment
* -------------
*
* The constraint attempts to match the orientation of [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to the orientation of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1). [CFrame](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/CFrame), [PrimaryAxis](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/PrimaryAxis), and [SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/SecondaryAxis) are not used.
*/
Mode: Enum.OrientationAlignmentMode;
/**
* The [PrimaryAxis](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/PrimaryAxis) is the direction of the goal's X-Axis, represented as a unit `Vector3`. This is only used when the [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation)'s [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/Mode) is [OneAttachment](https://developer.roblox.com/en-us/api-reference/enum/OrientationAlignmentMode).
*
* Tags: NotReplicated
*/
PrimaryAxis: Vector3;
/**
* If true, the [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation) applies torque if the primary axis of its [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) becomes unaligned with the goal. This means that any rotation about the Attachment0's primary axis will not create a torque.
*/
PrimaryAxisOnly: boolean;
/**
* When true the constraint will apply torque on both Attachments to achieve the goal.
*/
ReactionTorqueEnabled: boolean;
/**
* Controls how quickly the constraint will reach its goal. Higher values will cause the attachment to align quicker. Value can be between 5 and 200.
*/
Responsiveness: number;
/**
* When true, the solver reacts as quickly as possible to complete the alignment. When false, the torque is dependent on `MaxTorque`, `MaxAngularVelocity`, and `Responsiveness`.
*/
RigidityEnabled: boolean;
/**
* The [SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/SecondaryAxis) is the direction of the goal's Y-Axis, represented as a unit `Vector3`. This is only used when the [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation)'s [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignOrientation/Mode) is [OneAttachment](https://developer.roblox.com/en-us/api-reference/enum/OrientationAlignmentMode).
*
* Tags: NotReplicated
*/
SecondaryAxis: Vector3;
}
/** An AlignPosition attempts to constrain its [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0)'s position to the goal position, which is determined by [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) or [Position](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Position) depending on the [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Mode).
*
* 
*
* **Note**
*
* If this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*
* Reaction force
* --------------
*
* AlignPositions by default only apply a force on Attachment0's parent Part. The parent Part of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) remains unaffected. However, a force can also be applied to Attachment1 by enabling the [AlignPosition.ReactionForceEnabled](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/ReactionForceEnabled). This will cause a force to be applied to both Attachment0 and Attachment1 in the direction of each other.
*
* Force location
* --------------
*
* By default the force created by an AlignPosition is applied to the parent Part of Attachment0 at the Attachment's location. The direction of the force is always towards the goal. This means that if the center of mass of the Part is not aligned with the direction of the force, a torque will be applied to the part as well as a force.
*
* AlignPositions' behaviors can be changed with the [AlignPosition.ApplyAtCenterOfMass](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/ApplyAtCenterOfMass) property. When enabled, the AlignPosition will check if other Parts are rigidly connected to the parent Part of Attachment0. If there are, then the force will be applied at the center of mass of those connected parts. If not, then the force will be applied at the center of mass of the parent part itself.
*
* Force magnitude
* ---------------
*
* The force used to constrain an AlignPosition can either be configured or set to the maximum that constraints allow. Whether the force is configurable is determined by the [AlignPosition.RigidityEnabled](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/RigidityEnabled) property.
*
* When RigidityEnabled is true, the physics solver reacts as quickly as possible to complete the alignment. This is the same scale of force used to connect other constraints, such as hinges when their attachments are separated.
*
* When RigidityEnabled is false, then the force will be determined by the [AlignPosition.MaxForce](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/MaxForce), [AlignPosition.MaxVelocity](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/MaxVelocity), and [AlignPosition.Responsiveness](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Responsiveness). MaxForce and MaxVelocity are caps to the force and velocities respectively. The actual scale of the force is determined by the Responsiveness. The mechanism for responsiveness is a little complicated, but put simply the higher the responsiveness, the quicker the constraint will try to reach its goal.
*
* See also
* --------
*
* * [Body Movers Example.rbxl](https://doy2mn9upadnk.cloudfront.net/uploads/default/original/3X/e/1/e17a844750802035b24f68ddcbd83f6312b8f1d6.rbxl), a sample place showcasing body movers in various configurations.
* * [Attachments and Constraints](https://developer.roblox.com/articles/Constraints), an article outlining how to create and use attachments and constraints
*/
interface AlignPosition extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AlignPosition: unique symbol;
/**
* When true, applies force at center of mass of Attachment0's parent Part. When false, applied at Attachment0.
*/
ApplyAtCenterOfMass: boolean;
/**
* Selects the mode for force limit. Options Uniform or Per-component
*/
ForceLimitMode: Enum.ForceLimitMode;
ForceRelativeTo: Enum.ActuatorRelativeTo;
MaxAxesForce: Vector3;
/**
* Maximum force the constraint can apply to achieve its goal. Only used if RigidityEnabled is false.
*/
MaxForce: number;
/**
* Maximum speed the Attachment can move when converging. Only used if RigidityEnabled is false.
*/
MaxVelocity: number;
/**
* The Mode specifies the way its constraint determines its goal.
*
* OneAttachment
* -------------
*
* The constraint attempts to move [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to [Position](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Position). [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) is not used.
*
* TwoAttachment
* -------------
*
* The constraint attempts to move [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to the position of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1). [Position](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Position) is not used.
*/
Mode: Enum.PositionAlignmentMode;
/**
* When the constraint's [Mode](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Mode) is set to [OneAttachment](https://developer.roblox.com/en-us/api-reference/enum/PositionAlignmentMode), it uses the [Position](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Position) as a goal to move the [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to.
*/
Position: Vector3;
/**
* If true the constraint applies force on both Attachments to achieve the goal.
*/
ReactionForceEnabled: boolean;
/**
* Controls how quickly the constraint reaches its goal. Higher values will cause the attachment(s) to align more rapidly. Value can be between 5 and 200.
*/
Responsiveness: number;
/**
* If true, the solver reacts as quickly as possible to complete the alignment. If false, the torque is dependent on [MaxForce](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/MaxForce), [MaxVelocity](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/MaxVelocity), and [Responsiveness](https://developer.roblox.com/en-us/api-reference/property/AlignPosition/Responsiveness).
*/
RigidityEnabled: boolean;
}
/** **AngularVelocity** is an object that applies a torque (up to [MaxTorque](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/MaxTorque)) on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) such that the part maintains a constant [AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/AngularVelocity). The goal angular velocity defined using world- or attachment-space coordinates by setting [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/RelativeTo).
*
* This object maintains all functionality of [BodyAngularVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyAngularVelocity), a legacy body mover. To instead apply a constant torque, use a [Torque](https://developer.roblox.com/en-us/api-reference/class/Torque) object instead. To instead apply a torque such that a constant orientation is maintained, use a [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation) instead.
*/
interface AngularVelocity extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AngularVelocity: unique symbol;
/**
* A [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) that gives the desired or target angular velocity. This vector is set in the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) expressed by the [AngularVelocity.RelativeTo](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/RelativeTo) property. Defaults to **(0, 0, 0)**.
*/
AngularVelocity: Vector3;
/**
* Magnitude of the maximum torque the constraint can apply. Defaults to **0**.
*/
MaxTorque: number;
/**
* This property, when enabled, causes the constraint to apply equal and opposite reaction forces. This is important if the two attached parts can collide, since without reaction forces collisions can create energy that would otherwise be disregarded.
*
* When enabled, the reaction forces cause the constraint to act like an angular motor between the two attachments.
*
* It is only meaningful and visible in studio when [AngularVelocity.RelativeTo](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/RelativeTo) is set to `Attachment1`.
*/
ReactionTorqueEnabled: boolean;
/**
* The [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) in which the [AngularVelocity](https://developer.roblox.com/en-us/api-reference/class/AngularVelocity) force is specified. If set to **[World](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeToWorld)**, the angular velocity vector is used as is. If set to **Attachment1**, the angular velocity is transformed by the CFrame of the assigned attachment.
*
* [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/AngularVelocity/RelativeTo) can also be set to **Attachment0**, but it makes no physical sense and will lead to unpredictable behaviors. There will be a warning in Studio but the API will not prevent setting this value.
*/
RelativeTo: Enum.ActuatorRelativeTo;
}
interface AnimationConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AnimationConstraint: unique symbol;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly C0: CFrame;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly C1: CFrame;
IsKinematic: boolean;
MaxForce: number;
MaxTorque: number;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly Part0: BasePart | undefined;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly Part1: BasePart | undefined;
Transform: CFrame;
}
/** A **BallSocketConstraint** constrains its [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) so that they occupy the same position. By default it allows both attachments to freely rotate about all of their axes, but if [BallSocketConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/LimitsEnabled) is `true`, the attachments can only rotate in a limited cone.
*
* Note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*/
interface BallSocketConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BallSocketConstraint: unique symbol;
/**
* Sets whether the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint) has a limit on rotation based on [BallSocketConstraint.UpperAngle](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/UpperAngle).
* When a [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint) has LimitsEnabled set to true, it enforces that its [Constraint.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) isn't rotated more than a set angle from its [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0).
*
* The angle that is used is the angle between the x-axes of the [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment):
*
* 
*/
LimitsEnabled: boolean;
/**
* Sets the maximum frictional torque applied to keep its [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) aligned.
*
* `MaxFrictionTorque` specifies the stiffness of the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint), i.e. how much it resists rotation around its [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment). Constrained to be greater than or equal to 0.
*/
MaxFrictionTorque: number;
/**
* The visualized radius of the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint).
*/
Radius: number;
/**
* How elastic [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by a [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint) will be when they reach the end of the range specified by [BallSocketConstraint.UpperAngle](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/UpperAngle) when [BallSocketConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/LimitsEnabled) is true. Constrained between 0 and 1.
*/
Restitution: number;
/**
* Sets whether the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint) sets a limit on twist rotation based on [BallSocketConstraint.TwistUpperAngle](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/TwistUpperAngle) and [BallSocketConstraint.TwistLowerAngle](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/TwistLowerAngle). The twist angle is
* defined as the angle between the y-axis of [Constraint.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) and the y-axis of [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0).
*
* When a [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint) has `TwistLimitsEnabled` set to true, it enforces that its [Constraint.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) isn't twisted more than a set angle from its [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0).
*/
TwistLimitsEnabled: boolean;
/**
* Sets the lower twist rotation limit of the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint), as long as [BallSocketConstraint.TwistLimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/TwistLimitsEnabled) is `true`.
*/
TwistLowerAngle: number;
/**
* Sets the upper twist rotation limit of the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint), as long as [BallSocketConstraint.TwistLimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/TwistLimitsEnabled) is `true`.
*/
TwistUpperAngle: number;
/**
* Sets the upper rotation limit of the [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint), as long as [BallSocketConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/BallSocketConstraint/LimitsEnabled) is `true`.
*/
UpperAngle: number;
}
/** A **HingeConstraint** allows two [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) to rotate about one axis, constraining the two [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) so that they both occupy the same position and that their **X** axes point in the same direction.
*
* Hinges can also be configured to actuate rotation, as follows:
*
* * If [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) is set to [Motor](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType), the hinge will attempt to rotate the attachments with the goal of reaching [HingeConstraint.AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularVelocity). This rotation is limited by both [HingeConstraint.MotorMaxAcceleration](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/MotorMaxAcceleration) and [HingeConstraint.MotorMaxTorque](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/MotorMaxTorque).
* * If [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) is set to [Servo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType), the hinge will attempt to rotate to an angle specified by [HingeConstraint.TargetAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/TargetAngle). This rotation is limited by both [HingeConstraint.AngularSpeed](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularSpeed) and [HingeConstraint.ServoMaxTorque](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ServoMaxTorque).
*
* Note that both actuated and free spinning rotation can be limited by setting [HingeConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/LimitsEnabled) to `true`. Also note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*/
interface HingeConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HingeConstraint: unique symbol;
/**
* Sets whether the rotation of the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) is actuated and, if so, what kind of actuation.
*
* When ActuatorType is set to `None` then the hinge can swing freely:
*
* 
*
* When ActuatorType is set to [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor) then the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will attempt to rotate at a constant velocity specified by [HingeConstraint.AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularVelocity). The [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will apply a torque up to [HingeConstraint.MotorMaxTorque](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/MotorMaxTorque) to achieve the desired velocity but will be limited by [HingeConstraint.MotorMaxAcceleration](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/MotorMaxAcceleration).
*
* 
*
* When ActuatorType is set to `Servo` then the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will attempt to rotate to an angle specified by [HingeConstraint.TargetAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/TargetAngle). The [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will attempt to rotate towards that goal at a target speed set by [HingeConstraint.AngularSpeed](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularSpeed). The maximum torque the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) is allowed to use to meet these goals is set by [HingeConstraint.ServoMaxTorque](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ServoMaxTorque).
*
* 
*/
ActuatorType: Enum.ActuatorType;
/**
* This property specifies the sharpness of the servo motor in reaching the [HingeConstraint.TargetAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/TargetAngle), when [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) is set to **Servo**. Larger values correspond to a faster response and smaller values results in more damping and a slower response.
*/
AngularResponsiveness: number;
/**
* The desired angular speed a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) with [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) set to [Servo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) will attempt to maintain while rotating towards its [HingeConstraint.TargetAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/TargetAngle). Measured in radians/second.
*/
AngularSpeed: number;
/**
* The angular velocity a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) with [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) set to [Motor](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) will attempt to achieve. Measured in radians/second.
*/
AngularVelocity: number;
/**
* The current angle of the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint). This angle is calculated by measuring the angle separation of the y-axes of the [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* 
*
* Note that in the above picture the x-axis of the Attachment in PartA is pointed away from the camera.
*
* Tags: NotReplicated
*/
readonly CurrentAngle: number;
/**
* Sets whether the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will limit the range of rotation. If enabled, the constraint will only allow the [HingeConstraint.CurrentAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/CurrentAngle) to be between [HingeConstraint.LowerAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/LowerAngle) and [HingeConstraint.UpperAngle](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/UpperAngle). If the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) reach the end of the limited range of rotation then they will stop rotating. If [HingeConstraint.Restitution](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/Restitution) is greater than 0 then the attachments will bounce when they hit the ends of the limited range.
*
* For example, here is the result if LowerAngle is set to -90 and UpperAngle is set to 45. Note that the x-axis of the Attachment in PartA is pointed away from the camera:
*
* 
*/
LimitsEnabled: boolean;
/**
* The minimum rotation angle the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will allow if [HingeConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/LimitsEnabled) is true. Measured in degrees.
*/
LowerAngle: number;
/**
* The maximum angular acceleration a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) with [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) set to [Motor](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply to achieve its [HingeConstraint.AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularVelocity). Measured in radians/(second squared).
*/
MotorMaxAcceleration: number;
/**
* The maximum torque a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) with [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) set to [Motor](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply when trying to reach its desired [HingeConstraint.AngularVelocity](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularVelocity).
*/
MotorMaxTorque: number;
/**
* The visualized radius of the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint).
*/
Radius: number;
/**
* How elastic [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will be when they reach the end of the range when [HingeConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/LimitsEnabled) is true. Constrained between 0 and 1.
*/
Restitution: number;
/**
* The maximum torque a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) with [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) set to [Servo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply when trying to reach its desired [HingeConstraint.AngularSpeed](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/AngularSpeed).
*/
ServoMaxTorque: number;
SoftlockServoUponReachingTarget: boolean;
/**
* The target angle a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will attempt to rotate to if its [HingeConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/ActuatorType) is set to [Servo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType). Measured in degrees.
*/
TargetAngle: number;
/**
* The maximum rotation angle the [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) will allow if [HingeConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/HingeConstraint/LimitsEnabled) is true. Measured in degrees.
*/
UpperAngle: number;
}
/** A LineForce is used to apply a force along a line between two points. As the end points of the line move, the direction of the force will change accordingly.
*
* 
*
* Direction of force
* ------------------
*
* The direction that a LineForce applies its force in is determined by its [attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) and [LineForce.ApplyAtCenterOfMass](https://developer.roblox.com/en-us/api-reference/property/LineForce/ApplyAtCenterOfMass) properties. When ApplyAtCenter of mass is false, which it is by default, the direction of the force will be from the location of [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) to the location of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1). If ApplyToCenter is true, then the direction will be from the center of mass of Attachment0's parent to the location of Attachment1. Note that if the parent of Attachment0 is rigidly connected to other parts, then the LineForce will use the center of mass of all of the parts to determine the origin of the direction.
*
* Location of force
* -----------------
*
* A LineForce will apply its force on the Parent of its Attachment0, but the location where the force is applied is determined by the LineForce's ApplyAtCenterOfMass property.
*
* When ApplyAtCenterOfMass is false, which it is by default, the force will be applied to the part at the Attachement0's location. This means that if the attachment is not at the center of the part, it can create a torque on the part.
*
* When ApplyAtCenterOfMass is set to true, the force will check if any other parts are rigidly connected to the parent part of its Attachment0. If there are, then the force will apply at the center of mass of all of the connected parts. If there are no rigid connections to other parts, the force will simply be applied at the center of mass of the part.
*
* Strength of Force
* -----------------
*
* The strength of the force applied by a LineForce is determined by the [LineForce.Magnitude](https://developer.roblox.com/en-us/api-reference/property/LineForce/Magnitude) and [LineForce.InverseSquareLaw](https://developer.roblox.com/en-us/api-reference/property/LineForce/InverseSquareLaw) properties. The InverseSquareLaw property determines whether the force is constant or not.
*
* When InverseSquareLaw is false, which is is by default, the force applied is constant, and its magnitude is equal to the magnitude defined by the Magnitude property.
*
* When InverseSquareLaw is true, then the force will scale based on how much distance there is between the two endpoints. When the distance is 1 stud, then the force's magnitude will be the value of the Magnitude property. If the two points are further away, the force will decrease. Conversely, the force will increase if the two points move closer together. This function can be used to determine the force at any given separation:
*
* ActualMagnitude = Magnitude / (Separation ^ 2)
*
* **Tip**
*
* LineForces with [InverseSquareLaw](https://developer.roblox.com/api-reference/property/LineForce/InverseSquareLaw) set to true can be used to simulate various physical systems such as gravity or electric fields.
*
* See also
* --------
*
* * [Body Movers Example.rbxl](https://doy2mn9upadnk.cloudfront.net/uploads/default/original/3X/e/1/e17a844750802035b24f68ddcbd83f6312b8f1d6.rbxl), a sample place showcasing body movers in various configurations.
* * [Attachments and Constraints](https://developer.roblox.com/articles/Constraints), an article outlining how to create and use attachments and constraints
*/
interface LineForce extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LineForce: unique symbol;
/**
* When true, applies force at center of mass of Attachment0's parent Part, and the line determining the direction of the force will start at the said center of mass. When false, the force is applied at Attachment0's location and the line determining the direction will also start at Attachment0.
*/
ApplyAtCenterOfMass: boolean;
/**
* When true, the force magnitude is multiplied by the inverse square of the distance.
*/
InverseSquareLaw: boolean;
/**
* The magnitude of the force.
*/
Magnitude: number;
/**
* The maximum absolute force that can be applied. This property is enabled only when InverseSquareLaw is also enabled. This property is mainly used to address the issue that the force of the body mover becomes infinite the closer the two attachments are, causing explosions that can't be prevented by scripts. This property bounds the force's absolute value.
*/
MaxForce: number;
/**
* Enables a reaction force (equal an opposite) to be applied to the parent of Attachment1. By default line force only applies a force on the parent of Attachment0 and uses Attachment1 as the target direction without any dynamic relationship.
*/
ReactionForceEnabled: boolean;
}
/** The **LinearVelocity** constraint applies force on a part/assembly to maintain a linear velocity.
*
* This object maintains all functionality of [BodyVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyVelocity), a legacy body mover. To instead apply a constant force, use a [VectorForce](https://developer.roblox.com/en-us/api-reference/class/VectorForce) object instead.
*/
interface LinearVelocity extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LinearVelocity: unique symbol;
ForceLimitMode: Enum.ForceLimitMode;
ForceLimitsEnabled: boolean;
/**
* The normalized [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) direction for constraining the velocity along a line, when [ VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Line**. Default is \[1, 0, 0\].
*/
LineDirection: Vector3;
/**
* Float value of the velocity when [VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Line**. Default is 0.
*/
LineVelocity: number;
MaxAxesForce: Vector3;
/**
* Maximum magnitude of the force vector the constraint can apply.
*/
MaxForce: number;
MaxPlanarAxesForce: Vector2;
/**
* [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) value of the velocity in each tangent direction of the plane, when [VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Plane**. Default is \[0, 0\].
*/
PlaneVelocity: Vector2;
/**
* The primary axis in the plane, when [VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Plane**. Value depends on the value of [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) as follows:
*
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **Attachment0**, this axis is the [Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis) of [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0).
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **Attachment1**, this axis is the [Axis](https://developer.roblox.com/en-us/api-reference/property/Attachment/Axis) of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1).
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **World**, this value must be specified in the world space.
*/
PrimaryTangentAxis: Vector3;
/**
* Sets the [ActuatorRelativeTo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo) property for the [LinearVelocity](https://developer.roblox.com/en-us/api-reference/class/LinearVelocity) constraint.
*/
RelativeTo: Enum.ActuatorRelativeTo;
/**
* The secondary axis in the plane, when [VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Plane**. Value depends on the value of [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) as follows:
*
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **Attachment0**, this axis is the [SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis) of [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0).
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **Attachment1**, this axis is the [SecondaryAxis](https://developer.roblox.com/en-us/api-reference/property/Attachment/SecondaryAxis) of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1).
* * If [RelativeTo](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/RelativeTo) is set to **World**, this value must be specified in the world space.
*/
SecondaryTangentAxis: Vector3;
/**
* [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) velocity value when [VelocityConstraintMode](https://developer.roblox.com/en-us/api-reference/property/LinearVelocity/VelocityConstraintMode) is set to **Vector**. Default is \[0, 0, 0\].
*/
VectorVelocity: Vector3;
/**
* The mode of the [LinearVelocity](https://developer.roblox.com/en-us/api-reference/class/LinearVelocity) constraint: **Line**, **Plane**, or **Vector**. Default is **Vector**.
*/
VelocityConstraintMode: Enum.VelocityConstraintMode;
}
interface PlaneConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlaneConstraint: unique symbol;
}
interface Plane extends PlaneConstraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Plane: unique symbol;
}
/** **RigidConstraint** connects the [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) and [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) with zero offset.
*
* It functions similarly to [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint), which uses two [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s directly. However, this object uses two `Attachments` instead, which makes attaching
* accessories to avatars easy to do without code as you can use attachments on the rig.
*
* In Studio, you can create a RigidConstraint in the Constraints section of the Model tab.
*/
interface RigidConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RigidConstraint: unique symbol;
}
/** A **RodConstraint** constrains two [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) to remain separated by the value specified by [RodConstraint.Length](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/Length). While the attachments remain at a set distance from one another, they can both rotate freely.
*
* By default, RodConstraints do not have angle constraints and allow each part to rotate without angular constraint. However, setting [LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitsEnabled) reveal the [LimitAngle0](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle0) and [LimitAngle1](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle1) properties, which control the maximum angle that either end of the rod may have against the respective attachment. In the image below, the two parts are joined by a RodConstraint with 45 degree limits on each end. The red part is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored).
*
* 
*
* Note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*/
interface RodConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RodConstraint: unique symbol;
/**
* The current distance between the [RodConstraint](https://developer.roblox.com/en-us/api-reference/class/RodConstraint)'s two [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* Tags: NotReplicated
*/
readonly CurrentDistance: number;
/**
* The distance apart the [RodConstraint](https://developer.roblox.com/en-us/api-reference/class/RodConstraint) attempts to keep its [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) at. Measured in studs.
*/
Length: number;
/**
* **LimitAngle0** determines the maximum angle between the rod and [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) when [LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitsEnabled) is true. Otherwise, this property is hidden in the Properties window and does nothing.
*
* In the image below, the two parts are joined by a RodConstraint with 45 degree limits on each end. The red part is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored).
*
* 
*
* See also
* --------
*
* * [RodConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitsEnabled), which determines if this property is visible and functional
* * [RodConstraint.LimitAngle1](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle1), which works for the other attachment
* * `Constriant/Attachment0`, the attachment that is affected by this property
*/
LimitAngle0: number;
/**
* **LimitAngle1** determines the maximum angle between the rod and [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) when [LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitsEnabled) is true. Otherwise, this property is hidden in the Properties window and does nothing.
*
* In the image below, the two parts are joined by a RodConstraint with 45 degree limits on each end. The red part is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored).
*
* 
*
* See also
* --------
*
* * [RodConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitsEnabled), which determines if this property is visible and functional
* * [RodConstraint.LimitAngle0](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle0), which works for the other attachment
* * `Constriant/Attachment1`, the attachment that is affected by this property
*/
LimitAngle1: number;
/**
* **LimitsEnabled** determines whether the [LimitAngle0](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle0) and [LimitAngle1](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle1) properties control the angles between the rod and the respective attachments, as well as whether those properties are visible in the Properties window in Studio.
*
* In the image below, the two parts are joined by a RodConstraint with 45 degree limits on each end. The red part is not [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored).
*
* 
*
* See also
* --------
*
* * [LimitAngle0](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle0) and [LimitAngle1](https://developer.roblox.com/en-us/api-reference/property/RodConstraint/LimitAngle1)
* * [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) and [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1)
*/
LimitsEnabled: boolean;
/**
* The visualized thickness of the RodConstraint.
*/
Thickness: number;
}
/** A RopeConstraint constrains two [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) to separate no further than the length specified by [RopeConstraint.Length](https://developer.roblox.com/en-us/api-reference/property/RopeConstraint/Length). The attachments can move closer together than this length and can both freely rotate. */
interface RopeConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RopeConstraint: unique symbol;
/**
* The current distance between the RopeConstraint's two [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* Tags: NotReplicated
*/
readonly CurrentDistance: number;
/**
* The maximum distance two [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) can be when connected with a [RopeConstraint](https://developer.roblox.com/en-us/api-reference/class/RopeConstraint). Measured in studs.
*/
Length: number;
/**
* Restitution controls how _elastic_ an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by a [RopeConstraint](https://developer.roblox.com/en-us/api-reference/class/RopeConstraint) will be when reaching the end of the rope [RopeConstraint.Length](https://developer.roblox.com/en-us/api-reference/property/RopeConstraint/Length). The value of this property is constrained between 0 and 1.
*
* A RopeConstraint with a Restitution of 0 will not bounce when its Attachments reach their maximum separation.
*
* 
*
* A RopeConstraint with a Restitution of 1 will be almost completely elastic when its Attachments reach their maximum separation.
*
* 
*/
Restitution: number;
/**
* The visualized thickness of the RopeConstraint.
*/
Thickness: number;
WinchEnabled: boolean;
WinchForce: number;
WinchResponsiveness: number;
WinchSpeed: number;
WinchTarget: number;
}
/** The base class for constraints that allow their attachments to slide along an axis. */
interface SlidingBallConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SlidingBallConstraint: unique symbol;
/**
* Sets whether the translation of the [PrismaticConstraint](https://developer.roblox.com/en-us/api-reference/class/PrismaticConstraint) is actuated and, if so, what kind of actuation.
*
* If ActuatorType is set to **None**, then the joint can slide freely:
*
* 
*
* If ActuatorType is set to **Motor**, then the PrismaticConstraint will attempt to move its [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) at a constant velocity specified by [SlidingBallConstraint.Velocity](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Velocity). The PrismaticConstraint will apply a force up to [SlidingBallConstraint.MotorMaxForce](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/MotorMaxForce) to achieve the desired velocity but will be limited by [SlidingBallConstraint.MotorMaxAcceleration](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/MotorMaxAcceleration).
*
* If ActuatorType is set to **Servo**, then the PrismaticConstraint will attempt to move its Attachments to an offset specified by [SlidingBallConstraint.TargetPosition](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/TargetPosition). The PrismaticConstraint will attempt to translate towards that goal at a target speed set by [SlidingBallConstraint.Speed](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Speed). The maximum force the PrismaticConstraint is allowed to use to meet these goals is set by [SlidingBallConstraint.ServoMaxForce](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ServoMaxForce).
*/
ActuatorType: Enum.ActuatorType;
/**
* The current offset between the [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint)'s [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* 
*
* Tags: NotReplicated
*/
readonly CurrentPosition: number;
/**
* Sets whether the [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) will limit the range of translation. If enabled, the [SlidingBallConstraint.CurrentPosition](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/CurrentPosition) of the SlidingBallConstraint will only be able to be between the values of [SlidingBallConstraint.LowerLimit](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LowerLimit) and [SlidingBallConstraint.UpperLimit](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/UpperLimit).
*
* Here is a case where the UpperLimit is 2 and the LowerLimit is 1:
*
* 
*
* Here is a case where the UpperLimit is 4 and the LowerLimit is 2. Note that in this case the attachments will never be allowed to overlap; they will always be offset:
*
* 
*/
LimitsEnabled: boolean;
/**
* This property specifies the sharpness of the linear servo motor in reaching the [SlidingBallConstraint.TargetPosition](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/TargetPosition), when the derived classes' actuator type is set to **Servo**, for example the [CylindricalConstraint](https://developer.roblox.com/en-us/api-reference/class/CylindricalConstraint) and [PrismaticConstraint](https://developer.roblox.com/en-us/api-reference/class/PrismaticConstraint). Larger values correspond to faster a response and smaller values results in more damping and a slower response.
*/
LinearResponsiveness: number;
/**
* The lower position limit along the x-axis of [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) for a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) if [SlidingBallConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LimitsEnabled) is true.
*/
LowerLimit: number;
/**
* The maximum acceleration a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) with [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply when trying to reach its desired [SlidingBallConstraint.Velocity](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Velocity).
*/
MotorMaxAcceleration: number;
/**
* The maximum force a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) with [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply when trying to reach its desired [SlidingBallConstraint.Velocity](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Velocity).
*/
MotorMaxForce: number;
/**
* How elastic [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by a SlidingBallConstraint will be when they reach the end of the range specified by [SlidingBallConstraint.UpperLimit](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/UpperLimit) and [SlidingBallConstraint.LowerLimit](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LowerLimit) when [SlidingBallConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LimitsEnabled) is set to true. Constrained between 0 and 1.
*
* * * *
*
* Restitution of 0
* ----------------
*
* 
*
* Restitution of 0.5
* ------------------
*
* 
*
* Restitution of 1
* ----------------
*
* 
*/
Restitution: number;
/**
* The maximum force a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) with [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) can apply when trying to reach its desired [SlidingBallConstraint.Speed](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Speed).
*/
ServoMaxForce: number;
/**
* The visualized size of the SlidingBallConstraint.
*/
Size: number;
SoftlockServoUponReachingTarget: boolean;
/**
* The desired speed a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) with [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) will attempt to maintain while translating towards its [SlidingBallConstraint.TargetPosition](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/TargetPosition). Measured in studs/second.
*/
Speed: number;
/**
* The target position a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) will attempt to translate to if its [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) is set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType). Measured in studs.
*/
TargetPosition: number;
/**
* The upper position limit along the x-axis of [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) for a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) if [SlidingBallConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LimitsEnabled) is true.
*/
UpperLimit: number;
/**
* The velocity a [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) with [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) set to [ActuatorType](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType) will attempt to achieve. Measured in studs/second.
*/
Velocity: number;
}
/** A **CylindricalConstraint** allows its attachments to slide along one axis and rotate about another axis. It can be thought of like a combination of a [PrismaticConstraint](https://developer.roblox.com/en-us/api-reference/class/PrismaticConstraint) and a [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint). The sliding axis is determined by the **X** axis of the constraint's [Constraint.Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0). The rotation axis is centered at the constraint's [Constraint.Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) and is angled off of the sliding constraint by the constraint's [CylindricalConstraint.InclinationAngle](https://developer.roblox.com/en-us/api-reference/property/CylindricalConstraint/InclinationAngle).
*
* This constraint, along with a [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint), is ideal for building vehicle suspension as demonstrated in [Building a Basic Car](https://developer.roblox.com/en-us/articles/building-carkit-1).
*
* Note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*/
interface CylindricalConstraint extends SlidingBallConstraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CylindricalConstraint: unique symbol;
/**
* Type of angular actuator: None, Motor, or Servo.
*/
AngularActuatorType: Enum.ActuatorType;
/**
* Enables the angular limits around the rotation axis.
*/
AngularLimitsEnabled: boolean;
/**
* This property specifies the sharpness of the angular servo motor in reaching the [CylindricalConstraint.TargetAngle](https://developer.roblox.com/en-us/api-reference/property/CylindricalConstraint/TargetAngle), when [CylindricalConstraint.AngularActuatorType](https://developer.roblox.com/en-us/api-reference/property/CylindricalConstraint/AngularActuatorType) is set to **Servo**. Larger values correspond to a faster response and smaller values results in more damping and a slower response.
*/
AngularResponsiveness: number;
/**
* Restitution of the two limits, or how elastic they are. Value in \[0, 1\].
*/
AngularRestitution: number;
/**
* Target angular speed. This value is unsigned as the servo will always move toward its target. In radians per second. Value in \[0, inf).
*/
AngularSpeed: number;
/**
* The target angular velocity of the motor in radians per second around the rotation axis. Value in \[0, inf).
*/
AngularVelocity: number;
/**
* Signed angle (in degrees) between the reference axis and the secondary axis of Attachment1 around the rotation axis. Value in \[-180, 180\].
*
* Tags: NotReplicated
*/
readonly CurrentAngle: number;
/**
* Direction of the rotation axis as an angle from the x-axis in the xy-plane of Attachment0. Value in \[-180, 180\].
*/
InclinationAngle: number;
/**
* Lower limit for the angle (in degrees) between the reference axis and the SecondaryAxis of Attachment1 around the rotation axis. Value in \[-180, 180\].
*/
LowerAngle: number;
/**
* The maximum angular acceleration of the motor in radians per second squared. Value in \[0, inf).
*/
MotorMaxAngularAcceleration: number;
/**
* The maximum torque the motor can apply to achieve the target angular velocity. The units are mass \* studs^2 / second^2. Value in \[0, inf).
*/
MotorMaxTorque: number;
/**
* Enable the visibility of the rotation axis.
*/
RotationAxisVisible: boolean;
/**
* Maximum torque the servo motor can apply. The units are mass \* studs^2 / second^2. Value in \[0, inf).
*/
ServoMaxTorque: number;
SoftlockAngularServoUponReachingTarget: boolean;
/**
* Target angle (in degrees) between the reference axis and the secondary axis of Attachment1 around the rotation axis. Value in \[-180, 180\].
*/
TargetAngle: number;
/**
* Upper limit for the angle (in degrees) between the reference axis and the SecondaryAxis of Attachment1 around the rotation axis. Value in \[-180, 180\].
*/
UpperAngle: number;
/**
* The unit vector direction of the rotation axis in world coordinates.
*
* Tags: NotReplicated
*/
readonly WorldRotationAxis: Vector3;
}
/** A **PrismaticConstraint** creates a rigid joint between two [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment), allowing them to slide along one axis but not rotate. This constrains the attachments so that their **X** axes are collinear but pointing in opposite directions. It also constrains the attachments so that their **Y** axes are parallel.
*
* This constraint inherits properties from [SlidingBallConstraint](https://developer.roblox.com/en-us/api-reference/class/SlidingBallConstraint) and can be configured to actuate translation, as follows:
*
* * If [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) is set to [Motor](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType), it will attempt to translate the attachments with the goal of reaching [SlidingBallConstraint.Velocity](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/Velocity). This translation is limited by both [SlidingBallConstraint.MotorMaxAcceleration](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/MotorMaxAcceleration) and [SlidingBallConstraint.MotorMaxForce](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/MotorMaxForce).
* * If [SlidingBallConstraint.ActuatorType](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/ActuatorType) is set to [Servo](https://developer.roblox.com/en-us/api-reference/enum/ActuatorType), it will attempt to translate the attachments to a set separation specified by [SlidingBallConstraint.TargetPosition](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/TargetPosition).
*
* Note that both actuated and free translation can be limited by setting [SlidingBallConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SlidingBallConstraint/LimitsEnabled) to `true`. Also note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*/
interface PrismaticConstraint extends SlidingBallConstraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PrismaticConstraint: unique symbol;
}
/** A **SpringConstraint** applies a force to its [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) based on spring and damper behavior. Assuming the constraint has [SpringConstraint.Stiffness](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/Stiffness), it will apply forces based on how far apart the attachments are. If the attachments are further apart than the constraint's [SpringConstraint.FreeLength](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/FreeLength), the attachments will be forced together. If they are closer than the [SpringConstraint.FreeLength](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/FreeLength), the attachments will be forced apart. In addition, if [SpringConstraint.Damping](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/Damping) is set, there will be a damping component to the applied force that scales with the velocity of the attachments.
*
* This constraint, along with a [CylindricalConstraint](https://developer.roblox.com/en-us/api-reference/class/CylindricalConstraint), is ideal for building vehicle suspension as demonstrated in [Building a Basic Car](https://developer.roblox.com/en-us/articles/building-carkit-1).
*
* Note that if this constraint attaches one part (**A**) to another part (**B**) that is anchored or connected to an anchored part (**Z**), part **A** will not be locally simulated when interacting with a player.
*
* Calculating SpringConstraint Force
* ----------------------------------
*
* The following helper function exhibits how the force of a [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) is calculated based on various properties of the constraint and its attachments.
*
* local function getSpringForce(spring)
* if not spring:IsA("SpringConstraint") then
* warn(spring .. " is not a spring constraint!")
* return
* end
*
* local currentLength = spring.CurrentLength
* local freeLength = spring.FreeLength
* if (spring.LimitsEnabled) then
* currentLength = math.clamp(currentLength, spring.MinLength, spring.MaxLength)
* freeLength = math.clamp(freeLength, spring.MinLength, spring.MaxLength)
* end
* local springLength = currentLength - freeLength
*
* local axis = spring.Attachment0.WorldPosition - spring.Attachment1.WorldPosition
* if axis.Magnitude > 0 then
* axis = axis.Unit
* end
* local effectiveVelocity = spring.Attachment0.Parent.Velocity - spring.Attachment1.Parent.Velocity
*
* -- https://en.wikipedia.org/wiki/Harmonic\_oscillator
* -- f = -k \* x - c \* dx/dt + fext
* -- Gravity may not be all of the external forces; friction may affect this, but it's harder to account for
* local forceExternal = Vector3.new(0, -workspace.Gravity, 0)
* local force = -spring.Stiffness \* springLength - spring.Damping \* axis:Dot(effectiveVelocity) + axis:Dot(forceExternal)
*
* force = math.clamp(force, -spring.MaxForce, spring.MaxForce)
* return force
* end
*/
interface SpringConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SpringConstraint: unique symbol;
/**
* The number of coils visualized on the SpringConstraint. This can only be set between 0 and 8.
*/
Coils: number;
/**
* The current distance between the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint)'s [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* Tags: NotReplicated
*/
readonly CurrentLength: number;
/**
* Damping constant for the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint). Multiplied to the velocity of the constraint's [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) to reduce the spring force applied.
*/
Damping: number;
/**
* Natural resting length of the spring.
*/
FreeLength: number;
/**
* Sets whether the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) enforces a minimum and maximum length. If the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint)'s [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) reach these limits, they will simply stop moving apart from one another without restitution. If you need restitution or elasticity at the ends of the range of motion, you can combine a [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) with another constraint that allows restitution at the end of its range, such as a [PrismaticConstraint](https://developer.roblox.com/en-us/api-reference/class/PrismaticConstraint) or [RopeConstraint](https://developer.roblox.com/en-us/api-reference/class/RopeConstraint).
*/
LimitsEnabled: boolean;
/**
* The maximum force the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) can apply on its [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment).
*
* Some spring systems can give rise to forces that grow fast leading to instability. In such cases it is recommended to set MaxForce to a reasonable value.
*/
MaxForce: number;
/**
* The maximum separation the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) will allow if [SpringConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/LimitsEnabled) is true.
*/
MaxLength: number;
/**
* The minimum separation the [SpringConstraint](https://developer.roblox.com/en-us/api-reference/class/SpringConstraint) will allow if [SpringConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/LimitsEnabled) is true.
*/
MinLength: number;
/**
* The visualized radius of the spring's coils.
*/
Radius: number;
/**
* The strength of the spring. The higher this value the more force will be applied when the attachments are separated a different length than the [SpringConstraint.FreeLength](https://developer.roblox.com/en-us/api-reference/property/SpringConstraint/FreeLength).
*/
Stiffness: number;
/**
* The visualized thickness of the spring's coils.
*/
Thickness: number;
}
/** A TorqueActuator is used to apply a torque to a part or assembly. When active, this object will find the center of mass of the part or assembly connected to its [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) and will apply a torque, spinning the part or parts.
*
* 
*
* Direction of Torque
* -------------------
*
* The direction of the spin is determined by the [Torque.Torque](https://developer.roblox.com/en-us/api-reference/property/Torque/Torque) and [Torque.RelativeTo](https://developer.roblox.com/en-us/api-reference/property/Torque/RelativeTo) properties. The Torque defines the spin about the X, Y, and Z axes. However, these axes are oriented based on the RelativeTo property.
*
* When RelativeTo is set to [Enum.ActuatorRelativeTo.Attachment0](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo), the torque will be oriented based on the local space of Attachment0. If Attachment0 moves or rotates, the torque will change to make sure it is still applying in the correct directions. Similarly, when RelativeTo is set to [Enum.ActuatorRelativeTo.Attachment1](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo), the torque will be applied based on [Attachment1's](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) orientation, regardless of the position or direction of Attachment0. Last, RelativeTo can be set to [Enum.ActuatorRelativeTo.World](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo), which will use the world coordinate system to determine the axes for rotation.
*
* See also
* --------
*
* * [Body Movers Example.rbxl](https://doy2mn9upadnk.cloudfront.net/uploads/default/original/3X/e/1/e17a844750802035b24f68ddcbd83f6312b8f1d6.rbxl), a sample place showcasing body movers in various configurations.
* * [Attachments and Constraints](https://developer.roblox.com/articles/Constraints), an article outlining how to create and use attachments and constraints
*/
interface Torque extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Torque: unique symbol;
/**
* The [CFrame](https://developer.roblox.com/api-reference/datatype/CFrame "CFrame") in which the Torque is expressed.
*/
RelativeTo: Enum.ActuatorRelativeTo;
/**
* The strength and direction of the torque.
*/
Torque: Vector3;
}
/** A torsion spring applies a torque based on a relative angle and a relative angular velocity. Specifically, torsion springs try to bring two axes from two parts together in a compliance way.
*
* This constraint is ideal for building vehicle suspension as demonstrated in [Building a Basic Car](https://developer.roblox.com/en-us/articles/building-carkit-1).
*/
interface TorsionSpringConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TorsionSpringConstraint: unique symbol;
/**
* This property indicates the number of spring coils for visualization. The default value is 8.
*/
Coils: number;
/**
* This property indicates the current angle, in degrees, of the [TorsionSpringConstraint's](https://developer.roblox.com/en-us/api-reference/class/TorsionSpringConstraint) limiting cone. The limiting cone is formed at the position of the constraint's [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) around its secondary axis with an angle equal to [MaxAngle](https://developer.roblox.com/en-us/api-reference/property/TorsionSpringConstraint/MaxAngle).
*
* Tags: NotReplicated
*/
readonly CurrentAngle: number;
/**
* This property determines how the angular velocity is dampened by the constraint and is expressed as the torsional damping `c_t` in the formula:
*
* T=-k\_t (Δ\*Θ) - c\_t (Δ⋅Θ)
*
* The value defaults to 0.01.
*
* Damping of the torsion spring causes the spring to oppose the relative angular velocity. For instance, if the two axes are rotating toward each other with an angular velocity (Δ⋅Θ < 0) an opposing torque will try to slow down this relative rotation (T>0). If the axes were rotating away from each other (Δ⋅Θ > 0) an opposing torque (T<0) will slow down this angular velocity. In both cases, the damping is resulting in a torque that opposes the motion.
*
* In the example below, developers can change the damping of the torsion spring as follows:
*
* torsionSpring.Damping = 1.0
*/
Damping: number;
/**
* This property, when enabled, limits the relative angular motion of the secondary axes of attachments through a cone constraint. The default value is false.
*
* In the example below, you can enable a cone limit on the relative motion of the secondary axes as follows:
*
* torsionSpring.LimitEnabled = true
*
* Tags: Hidden
* @deprecated Use `LimitsEnabled` instead
*/
LimitEnabled: boolean;
LimitsEnabled: boolean;
/**
* This property determines the max angle, in degrees, of the [TorsionSpringConstraint's](https://developer.roblox.com/en-us/api-reference/class/TorsionSpringConstraint) limiting cone. The limiting cone is formed at the position of the constraint's [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) around its secondary axis with an angle equal to MaxAngle. The default value is 45.0 degrees.
*
* In the example below, when [LimitEnabled](https://developer.roblox.com/en-us/api-reference/property/TorsionSpringConstraint/LimitEnabled) is `true` for the constraint, the maximum angle between the primary axes of attachments can be limited to 10 degrees for instance as follows:
*
* torsionSpring.MaxAngle = 10
*/
MaxAngle: number;
/**
* This property determines the maximum torque supported by the spring. The value defaults to 1000.0.
*
* If a part isn't moving, consider raising this value (and also check that it is not \`BasePart/Anchored|Anchored\` or attached to another anchored part).
*
* What is torque
* --------------
*
* Torque is equivalent to a force applied over a distance (T = force \* distance). The same way that applying a force translates into `pulling/pushing` an object, applying a torque results in `rotating` the object.
*
* Setting the MaxTorque
* ---------------------
*
* In the example below, you can change the maximum torque provided by the torsion spring as follows:
*
* torsionSpring.MaxTorque = 300
*/
MaxTorque: number;
/**
* When developing in studio, the spring will always be visualized, regardless of the camera distance.
*
* This property indicates the visualization radius of the spring, in studs. The default value is 0.4.
*/
Radius: number;
/**
* This property how elastic [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by a [TorsionSpringConstraint](https://developer.roblox.com/en-us/api-reference/class/TorsionSpringConstraint) are when they reach the end of the range specified by [MaxAngle](https://developer.roblox.com/en-us/api-reference/property/TorsionSpringConstraint/MaxAngle) when [LimitEnabled](https://developer.roblox.com/en-us/api-reference/property/TorsionSpringConstraint/LimitEnabled) is `true`. The value defaults to 0 and can be any floating number within the range \[0, 1\].
*
* torsionSpring.Restitution = 0
*
* What is restitution
* -------------------
*
* Restitution determines the damping effect that the constraint applies when it reaches its limits.
*
* Imagine you release a ball from some distance and it hits the ground. If the restitution of the surface is 1 then the ball will return to its original height (no energy is damped). If the restitution is 0 the ball will stick to the ground (all the energy is lost). Similarly, automobiles rely on damping for shock absorption as do some “slow-close” doors.
*
* All the values between 0 and 1 will simulate something between these to extreme cases.
*/
Restitution: number;
/**
* This property determines the magnitude of the opposing torque of the spring, in the absence of damping, and is expressed as `k_t` in the formula:
*
* T=-k\_t (Δ\*Θ) - c\_t (Δ⋅Θ)
*
* The value defaults to 100.
*
* In the absence of damping, the opposing torque of the spring is proportional to the stiffness parameter. For instance, higher stiffness results in a larger opposing torque, and smaller stiffness results in a smaller opposing torque. The larger the torque value, the faster the axes are pushed together when the relative angle is positive (or away from each other if the relative angle is negative).
*
* In the example below, developers can change the stiffness of the torsion spring as follows:
*
* torsionSpring.Stiffness = 1000
*/
Stiffness: number;
}
/** A physics constraint that ensures two axes on two rigid bodies remain perpendicular. An example use of this constraint are power transmission between the transmission and rear drive shafts of rear-wheel drive cars, robotics, etc.
*
* The constraint ensures that two attachments are co-located (similar to [BallSocketConstraint](https://developer.roblox.com/en-us/api-reference/class/BallSocketConstraint)) and that their secondary axes remain perpendicular (see the picture below). In this sense, this constraint is more restrictive than the BallSocketConstraint but is less restrictive than [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) (by one degree of freedom).
*
* 
*
* If [LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/LimitsEnabled) is `true`, then the relative motion of the primary axis of [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1) is limited by a cone. This cone is formed via [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) and its primary axis and makes an angle of [MaxAngle](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/MaxAngle) with it.
*/
interface UniversalConstraint extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_UniversalConstraint: unique symbol;
/**
* This property, when enabled, limits the relative angular motion of the primary axes of attachments through a cone constraint. The default value is false.
*
* The example below demonstrates how developers can enable a cone limit on the relative motion of the primary axes:
*
* universalConstraint.LimitsEnabled = true
*/
LimitsEnabled: boolean;
/**
* This property determines the max angle, in degrees, of the [UniversalConstraint's](https://developer.roblox.com/en-us/api-reference/class/UniversalConstraint) limiting cone. The limiting cone is formed from [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0) and its primary axis. The default value is 45.0 degrees.
*
* In order for this property to take affect, the constraint's [UniversalConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/LimitsEnabled) property must be set to `true`.
*
* For example, the code snippet below sets LimitsEnabled to true and limits the [UniversalConstraint.MaxAngle](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/MaxAngle) to 10 degrees:
*
* universalConstraint.LimitsEnabled = true
* universalConstraint.MaxAngle = 10
*/
MaxAngle: number;
/**
* This property indicates the visualization radius, in studs, of the constraint when the constraint's details are off and the constraint is selected. The default value is 0.2 studs.
*/
Radius: number;
/**
* This property determines the restitution of the two limits, or how elastic they are. The value defaults to 0 and can be any floating number in the range \[0, 1\].
*
* This property only applies when [UniversalConstraint.LimitsEnabled](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/LimitsEnabled) is set to true.
*
* The elasticity affects the [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) connected by the [UniversalConstraint](https://developer.roblox.com/en-us/api-reference/class/UniversalConstraint) when they reach the end of the range specified by [UniversalConstraint.MaxAngle](https://developer.roblox.com/en-us/api-reference/property/UniversalConstraint/MaxAngle).
*/
Restitution: number;
}
/** A VectorForce is used to apply a force to a part or assembly of parts. The direction and strength of the force is determined by a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) and can be relative to an attachment on the part, another attachment, or the world coordinate system.
*
* 
* _The image above demonstrates how VectorForce applies a force on a part relative to an Attachment_
* 
* _The image above demonstrates how VectorForce applies a force on a part relative to the part's center of mass_
*
* Location of force
* -----------------
*
* A VectorForce will apply its force on the Parent of its [Attachment0](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment0), but the location where the force is applied is determined by the [VectorForce.ApplyAtCenterOfMass](https://developer.roblox.com/en-us/api-reference/property/VectorForce/ApplyAtCenterOfMass) property.
*
* When [VectorForce.ApplyAtCenterOfMass](https://developer.roblox.com/en-us/api-reference/property/VectorForce/ApplyAtCenterOfMass) is false, which it is by default, the force will be applied to the part at the Attachement0's location. This means that if the attachment is not at the center of the part, it can create a torque on the part.
*
* When ApplyAtCenterOfMass is set to true, the force will check if any other parts are rigidly connected to the parent part of its Attachment0. If there are, then the force will apply at the center of mass of all of the connected parts. If there are no rigid connections to other parts, the force will simply be applied at the center of mass of the part.
*
* Direction of force
* ------------------
*
* The direction of the force is determined by the Vector3 defined by force, but it will also be affected by the [VectorForce.RelativeTo](https://developer.roblox.com/en-us/api-reference/property/VectorForce/RelativeTo) property.
*
* By default, [VectorForce.RelativeTo](https://developer.roblox.com/en-us/api-reference/property/VectorForce/RelativeTo) is set to [Enum.ActuatorRelativeTo.Attachment0](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo), meaning the force will be applied in the space local to the attachment. Remember that when visualizing an attachment, the yellow arrow shows the direction of positive X, and the orange bar shows the direction of positive Y. If the part the attachment is connected to rotates, the force will change direction to make sure it is still in the context of the attachment.
*
* RelativeTo can also be set to [Enum.ActuatorRelativeTo.Attachment1](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo). In this case, the force will be applied in the space local to [Attachment1](https://developer.roblox.com/en-us/api-reference/property/Constraint/Attachment1), regardless of the orientation of Attachment0 or its connected part. If Attachment1 rotates, then the force will change to stay oriented correctly.
*
* Lastly, RelativeTo can also be set to [Enum.ActuatorRelativeTo.World](https://developer.roblox.com/en-us/api-reference/enum/ActuatorRelativeTo). In this mode, the force is applied in world coordinates, regardless of the orientation of Attachment0 or its part.
*
* See also
* --------
*
* * [Body Movers Example.rbxl](https://doy2mn9upadnk.cloudfront.net/uploads/default/original/3X/e/1/e17a844750802035b24f68ddcbd83f6312b8f1d6.rbxl), a sample place showcasing body movers in various configurations.
* * [Attachments and Constraints](https://developer.roblox.com/articles/Constraints), an article outlining how to create and use attachments and constraints
*/
interface VectorForce extends Constraint {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_VectorForce: unique symbol;
/**
* This property indicates whether the force is applied at the center of mass of `VectorForce/Attachment0|Attachment0's` parent [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* When true, the force is applied at the center of mass. When false, the force is applied at Attachment0.
*
* 
*/
ApplyAtCenterOfMass: boolean;
/**
* The strength and direction of the force.
*/
Force: Vector3;
/**
* This property determines the [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) in which the force is expressed.
*
* 
*/
RelativeTo: Enum.ActuatorRelativeTo;
}
/** Service that is used to load content, or assets, into a game.
*
* The service's main use is to preload assets into a game. When a new asset such as a [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) or [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound) is used in a game, Roblox will load the content associated with it from Roblox servers. In some cases, this can be undesirable for developers as it can lead to a delay before the content loads into the game.
*
* With ContentProvider, developers can preload assets using the [ContentProvider:PreloadAsync](https://developer.roblox.com/en-us/api-reference/function/ContentProvider/PreloadAsync) function. Another useful property is [ContentProvider.RequestQueueSize](https://developer.roblox.com/en-us/api-reference/property/ContentProvider/RequestQueueSize), which can be used to measure what proportion of assets in the request queue have been downloaded.
*/
interface ContentProvider extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ContentProvider: unique symbol;
/**
* Used by the [ContentProvider](https://developer.roblox.com/en-us/api-reference/class/ContentProvider) to download assets from the Roblox website.
*
* This URL points to a Roblox hosted website from which assets are downloaded and is pulled from the AppSettings.xml file, located in the version-hash folder.
*
* It is possible to overwrite this property using the [ContentProvider:SetBaseUrl](https://developer.roblox.com/en-us/api-reference/function/ContentProvider/SetBaseUrl) function in the command bar; however, this is not recommended and may cause asset loading issues.
*
* Tags: NotReplicated
*/
readonly BaseUrl: string;
/**
* Gives the number of items in [ContentProvider](https://developer.roblox.com/en-us/api-reference/class/ContentProvider)'s request queue that need to be downloaded.
*
* Items are added to the client's request queue when an asset is used for the first time or [ContentProvider:PreloadAsync](https://developer.roblox.com/en-us/api-reference/function/ContentProvider/PreloadAsync) is called.
*
* Developers are advised not to use RequestQueueSize to create loading bars. This is because the queue size can both increase and decrease over time as new assets are added and downloaded. Developers looking to display loading progress should load assets one at a time (see example below).
*
* Tags: NotReplicated
*/
readonly RequestQueueSize: number;
GetAssetFetchStatus(this: ContentProvider, contentId: string): Enum.AssetFetchStatus;
GetAssetFetchStatusChangedSignal(this: ContentProvider, contentId: string): RBXScriptSignal;
ListEncryptedAssets(this: ContentProvider): unknown;
/**
* Usually, content is loaded only when it starts being used. That explains why it often takes a moment for an image to appear in a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject), or a [mesh](https://developer.roblox.com/en-us/api-reference/class/Mesh) to appear in a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart), or why a [sound](https://developer.roblox.com/en-us/api-reference/class/Sound) doesn't play for the first time. All because the asset has not yet finished loading. Preload is used to load this content beforehand, so that it works instantly.
* @deprecated Use `PreloadAsync` instead
*/
Preload(this: ContentProvider, contentId: string): void;
RegisterDefaultEncryptionKey(this: ContentProvider, encryptionKey: string): void;
RegisterDefaultSessionKey(this: ContentProvider, sessionKey: string): void;
RegisterEncryptedAsset(this: ContentProvider, assetId: string, encryptionKey: string): void;
RegisterSessionEncryptedAsset(this: ContentProvider, contentId: string, sessionKey: string): void;
UnregisterDefaultEncryptionKey(this: ContentProvider): void;
UnregisterEncryptedAsset(this: ContentProvider, assetId: string): void;
/**
* Yields until all of the assets associated with the given [Instances](https://developer.roblox.com/en-us/api-reference/class/Instance) have loaded and takes an array of [Instances](https://developer.roblox.com/en-us/api-reference/class/Instance) as a parameter.
*
* This can be used to pause a script and not use content until it is certain that the content has been loaded into the game.
*
* When the function is called, the engine will go through the array of instances (and all of the descendants of the passed-in instances). If any of the instances have a property that defines a link to content, such as a [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) or a [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound), then the function will attempt to load the asset from the Roblox website. If any of the assets fail to load, an error message will appear in the output, but the PreloadAsync function itself will not error and will continue executing until it has processed each passed-in instance.
*
* Tags: Yields
*/
PreloadAsync(
this: ContentProvider,
contentIdList: Array,
callback?: (contentId: string, status: Enum.AssetFetchStatus) => void,
): void;
readonly AssetFetchFailed: RBXScriptSignal<(assetId: string) => void>;
}
/** ContextActionService is a game service that allows a game to bind user input to contextual actions, or actions that are only enabled under some condition or period of time. For example, allowing a player to open a door only while close by. In code, an action is simply a string (the name of the action) used by the service to differentiate between unique actions. The action string is provided to [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) and [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction), among other member functions. If two actions are bound to the same input, the most recently bound will take priority. When the most recent action is unbound, the one bound before that takes control again. Since ContextActionService deals with user input, you can only use it in [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript) which run on the client.
*
* What is a context?
* ------------------
*
* A **context** is simply a condition during which a player may perform some action. Some examples include holding a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool), being [seated](https://developer.roblox.com/en-us/api-reference/class/Seat) in a car or standing near a door. Whatever the case may be, it is up to your [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript) to call BindAction when the context is entered and UnbindAction when the context is left.
*
* What is an action?
* ------------------
*
* An **action** is simply some input that can be performed by the player while in that context. Such an action could open/close some menu, trigger a secondary tool action or send a request to the server using [RemoteFunction:InvokeServer](https://developer.roblox.com/en-us/api-reference/function/RemoteFunction/InvokeServer). An action is identified by a unique string as the first parameter of both [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) and [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction). The string can be anything, but it should reflect the **action being performed, not the input being used**. For example, don't use “KeyH” as an action name - use “CarHorn” instead. It is best to define your actions as a constant at the top of your script since you will use it in at least three different places in your code.
*
* Why bind actions contextually?
* ------------------------------
*
* It's better to use ContextActionService's [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) than [UserInputService.InputBegan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputBegan) for most cases. For InputBegan, your connected function would have to check if the player is in the context of the action begin performed. In most cases, this is harder than just calling a function when a context is entered/left. For example, if you want to have the `H` key trigger a car horn sound while the player is sitting in it, the player might type “hello” in chat or otherwise use the `H` key for something else. It is harder to determine if something else is using the H key (like chat) - the car might honk when the player didn't mean to! If you instead use [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) and [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction) when the player enters/leaves the car, ContextActionService will make sure that `H` key presses trigger the honk action only when it is the most recently bound action. If something else (like chat) takes control, you won't have to worry about checking that.
*
* Inspecting Bound Actions
* ------------------------
*
* To see a list of actions and their bound inputs, you can inspect the “Action Bindings” tab in the Developer Console (F9 while in game). This shows all bindings - including those bound by Roblox CoreScripts and default camera/control scripts too. This is useful for debugging: check if your actions are being bound/unbound at the correct times, or if some other action is stealing input from your actions. For example, if you are attempting to bind WASD, it may be the case that default character movement scripts are binding over those same keys. Similarly, the camera control script can steal right-click input if the script runs after yours.
*
* Keyboardless Input
* ------------------
*
* ContextActionService is especially useful for supporting gamepad and touch input. For gamepad input, you might choose to bind the B button to an action that returns the user to the previous menu when they entire another menu. For touch, on-screen touch buttons can be used in place of key presses: these buttons display only while the action is bound, and the position, text and/or images of these buttons can be configured through this service. They are somewhat limited in the amount of customization provided by this service; it's usually a better idea to make your own on-screen buttons using [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) or [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton).
*/
interface ContextActionService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ContextActionService: unique symbol;
/**
* BindAction will bind an action to user input given an action handling function. Upon a matching input being performed, the action handler function will be called with the arguments listed below. Valid input enum items include those within the following: [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode), [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType) or [PlayerAction](https://developer.roblox.com/en-us/api-reference/enum/PlayerAction) . Call this function when a player **enters the context** in which an action can be performed. When the player leaves the context, call [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction) with the same `actionName`. You can manually call the action handling function of an action by using [CallFunction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/CallFunction).
*
* The code sample below shows how a [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound) can be [played](https://developer.roblox.com/en-us/api-reference/function/Sound/Play) while a key (H), game pad button, or touch screen button is pressed.
*
* local ContextActionService = game:GetService("ContextActionService")
*
* -- A car horn sound
* local honkSound = Instance.new("Sound", workspace)
* honkSound.Looped = true
* honkSound.SoundId = "rbxassetid://3017580236"
*
* local function handleAction(actionName, inputState, inputObject)
* if actionName == "HonkHorn" then
* if inputState == Enum.UserInputState.Begin then
* honkSound:Play()
* else
* honkSound:Pause()
* end
* end
* end
*
* -- When the player sits in the vehicle:
* ContextActionService:BindAction("HonkHorn", handleAction, true, Enum.KeyCode.H, Enum.KeyCode.ButtonY)
*
* -- When the player gets out:
* ContextActionService:UnbindAction("HonkHorn")
*
* Action Handler Parameters
* -------------------------
*
* The action handler functions are called with the following parameters:
*
* #
*
* Type
*
* Description
*
* 1
*
* `lua-docs/string`
*
* The same string that was originally passed to BindAction†
*
* 2
*
* [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState)
*
* The state of the input (Begin, Change, End or Cancel)\*
*
* 3
*
* [InputObject](https://developer.roblox.com/en-us/api-reference/class/InputObject)
*
* An object that contains information about the input (varies based on UserInputType)
*
* †This allows one function to handle multiple actions at once, if necessary.
* \*Cancel is sent if some input was in-progress and another action bound over the in-progress input, or if the in-progress bound action was [unbound](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction).
*
* Action Bindings Stack
* ---------------------
*
* Action bindings behave like a stack: if two actions are bound to the same user input, the **most recently bound** action handler will be used. If an action handler returns `Enum.ContextActionResult.Pass`, the next most recently bound action handler will be called, and so on until a handler sinks the input (by returning `nil` or `Enum.ContextActionResult.Sink`). When [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction) is called, the action handler is removed from the stack. This stack behavior can be overridden using [BindActionAtPriority](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActionAtPriority), where an additional priority parameter after `createTouchButton` may override the order in which actions are bound (higher before lower).
*
* Touch Buttons
* -------------
*
* In addition to input types, this function's third parameter controls whether a button is created for [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) devices. Upon the first touch button's creation, a [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui) named “ContextActionGui” is added to the [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui). Inside the ScreenGui is a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) called “ContextButtonFrame” is added. It is in this frame in which [ImageButtons](https://developer.roblox.com/en-us/api-reference/class/ImageButton) for bound actions are parented; you can use [GetButton](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetButton) to retrieve such buttons for customization.
*/
BindAction(
this: ContextActionService,
actionName: string,
functionToBind: (actionName: string, state: Enum.UserInputState, inputObject: InputObject) => void,
createTouchButton: boolean,
...inputTypes: Array
): void;
/**
* BindActionAtPriority behaves like [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) but also allows a priority to be assigned to the bound action. If multiple actions are bound to the same input, the higher priority function is called regardless of the order in which the actions were bound. In other words, this function overrides the normal “stack” behavior of BindAction.
*/
BindActionAtPriority(
this: ContextActionService,
actionName: string,
functionToBind: (actionName: string, state: Enum.UserInputState, inputObject: InputObject) => void,
createTouchButton: boolean,
priorityLevel: number,
...inputTypes: Array
): void;
/**
* This function binds _functionToBind_ to input events such as key presses, mouse movement, or controller input. The specific input types the engine listens for are listed as parameters of BindAction. Whenever a player uses any of these input types, the Roblox engine calls “functionToBind”. BindAction sets the priorityLevel via [ContextActionPriority](https://developer.roblox.com/en-us/api-reference/enum/ContextActionPriority) to Default.Value, which is 2000. Use [ContextActionService:GetButton](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetButton) to control the priority of bound events.
*
* In addition to input types, BindAction has a createTouchButton parameter. When this is set to true it creates an [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) on any device with a touchscreen. A [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui) is also created to put the context buttons into named ContextActionGui and is parented to [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui). The created ImageButton is parented to this ContextActionGui. GetButton can be used to retrieve the button that was created.
*
* If an input has more than one function bound to it, each function will be placed on a stack. A stack obeys the principle of last in first out. So the first object placed on the stack will be on the top. The next object placed on the stack becomes the top and the previous object moves one position down (like a stack of books). When the input is triggered, the function at the top of the stack is called. If the function returns Enum.ContextActionResult.Pass this will continue down the stack. To remove a function from being called by all input that it was bound by use [ContextActionService:UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction).
*
* BindAction allows control over whether or not a bound action should be processed by other actions on the stack using [ContextActionResult](https://developer.roblox.com/en-us/api-reference/enum/ContextActionResult). If Enum.ContextActionResult.Pass is returned in the callback function, every action below it in the stack (last function called gets executed first) will get a chance to process it. Anything other than Pass will be treated as Enum.ContextActionResult.Sink, including nil. It will also sink if the callback is yielded.
* @deprecated Use `BindAction` instead
*/
BindActionToInputTypes(this: ContextActionService, actionName: string, functionToBind: Callback, createTouchButton: boolean, inputTypes: Array): void;
/**
* Bind an [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode) that can be used with an [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType) to activate [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector) events and [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) objects. When the given key/button is pressed, it fires the [Mouse.Button1Down](https://developer.roblox.com/en-us/api-reference/event/Mouse/Button1Down) event on the mouse sent to [Tool.Equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped). This in turn fires the [Tool.Activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated) event if [Tool.ManualActivationOnly](https://developer.roblox.com/en-us/api-reference/property/Tool/ManualActivationOnly) is not set to true. For gamepad input, this function is called by the default control scripts in order to bind the ButtonR2 [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode).
*
* Note that the [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType) specified must be `Keyboard` or `Gamepad1` through `Gamepad8` in order to be valid.
*/
BindActivate(this: ContextActionService, userInputTypeForActivation: CastsToEnum, keyCodesForActivation: Array): void;
/**
* GetAllBoundActioninfo returns a table which maps all actions' names (those originally passed to [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction)) to a table returned by [GetBoundActionInfo](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetBoundActionInfo) when called with the action name itself. Using this function, you can inspect all presently bound actions. This is useful when debugging their priority levels or stack orders.
*/
GetAllBoundActionInfo(this: ContextActionService): Map;
/**
* GetBoundActionInfo returns a table with the following keys describing a bound action given its name. To get the same information for all actions at once, use [GetAllBoundActionInfo](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetAllBoundActionInfo).
*
* Name
*
* Type
*
* Description
*
* `stackOrder`
*
* number
*
* Describes the index of the action on the stack (increasing)
*
* `priorityLevel`\*
*
* number
*
* Describes the [priority](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActionAtPriority) level of the action
*
* `createTouchButton`
*
* bool
*
* Describes whether a touch button should be created on [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) devices
*
* `inputTypes`
*
* table
*
* The input types passed to [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) for which this action will trigger
*
* `description`†
*
* string
*
* The description of action set by [SetDescription](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetDescription)
*
* `title`†
*
* string
*
* The title of the action set by [SetTitle](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetTitle)
*
* `image`†
*
* string
*
* The image of the action's touch button set by [SetImage](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetImage)
*
* \*Priority level will still be included even if [BindActionAtPriority](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActionAtPriority) wasn't used - by default it will be 2000.
* †Indicates that this field will be `nil` if the associated method was not called for the given action.
*/
GetBoundActionInfo(this: ContextActionService, actionName: string): BoundActionInfo;
/**
* GetCurrentLocalToolIcon will return the [BackpackItem.TextureId](https://developer.roblox.com/en-us/api-reference/property/BackpackItem/TextureId) of a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) currently [equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped) by the [Player](https://developer.roblox.com/en-us/api-reference/class/Player), or `nil` if there is no such Tool or if the player lacks a [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character).
*/
GetCurrentLocalToolIcon(this: ContextActionService): string;
/**
* SetDescription will set the description of an action bound by [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction). In a list of available actions, this would be text that describes the given action.
*
* Although the name may suggest that this method is related to the family of functions that customize a touch button for actions that create them ([SetTitle](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetTitle), [SetImage](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetImage) and [SetPosition](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetPosition)), this method does not affect such a button. This method merely sets a text description of an action, and nothing more.
*/
SetDescription(this: ContextActionService, actionName: string, description: string): void;
/**
* SetPosition will set the text shown on a touch button created by [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction). Specifically, this sets the [ImageLabel.Image](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/Image) property of the [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel) within the [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) that would be returned by [GetButton](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetButton). If no such bound action exists (e.g. nothing is returned by GetButton), this function does nothing and throws no error.
*
* This function is part of a family of methods that customize the touch button of an action. Others in this family include [SetPosition](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetPosition) and [SetTitle](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetTitle).
*/
SetImage(this: ContextActionService, actionName: string, image: string): void;
/**
* SetPosition will set the text shown on a touch button created by [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction). Specifically, this sets the [GuiObject.Position](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Position) property of the [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) that would be returned by [GetButton](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetButton). If no such bound action exists (e.g. nothing is returned by GetButton), this function does nothing and throws no error.
*
* This function is part of a family of methods that customize the touch button of an action. Others in this family include [SetImage](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetImage) and [SetTitle](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetTitle).
*/
SetPosition(this: ContextActionService, actionName: string, position: UDim2): void;
/**
* SetTitle will set the text shown on a touch button created by [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction). Specifically, this sets the [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text) property of a [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) within the [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) that would be returned by [GetButton](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetButton). If no such bound action exists (e.g. nothing is returned by GetButton), this function does nothing and throws no error.
*
* This function is part of a family of methods that customize the touch button of an action. Others in this family include [SetImage](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetImage) and [SetPosition](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/SetPosition).
*/
SetTitle(this: ContextActionService, actionName: string, title: string): void;
/**
* UnbindAction will unbind an action by name from user inputs so that the action handler function will no longer be called. Call this function when the context for some action is no longer applicable, such as closing a user interface, exiting a car or [unequipping](https://developer.roblox.com/en-us/api-reference/event/Tool/Unequipped) a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). See [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) for more information on how bound actions operate.
*
* This function **will not** throw an error if there is no such action bound with the given string. Using [GetAllBoundActionInfo](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/GetAllBoundActionInfo) or the Developer Console's “Action Bindings” tab, you can find out what actions are presently bound.
*/
UnbindAction(this: ContextActionService, actionName: string): void;
/**
* UnbindActivate unbinds an [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode) used with an [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType) for activating a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) (or a [HopperBin](https://developer.roblox.com/en-us/api-reference/class/HopperBin)) using [BindActivate](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActivate). This function essentially undoes the action performed by that function.
*/
UnbindActivate(this: ContextActionService, userInputTypeForActivation: CastsToEnum, keyCodeForActivation?: CastsToEnum): void;
/**
* Removes all functions bound. No actionNames will remain. All touch buttons will be removed. If a button was manipulated manually there is no guarantee it will be cleaned up.
*/
UnbindAllActions(this: ContextActionService): void;
/**
* GetButton returns the [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) created by [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) if its third parameter was true and the device is [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled). The only parameter to this function must match exactly the name of the action originally sent to BindAction.
*
* If no such action was bound or if a button was not created, this function returns `nil`.
*
* Tags: Yields
*/
GetButton(this: ContextActionService, actionName: string): ImageButton | undefined;
/**
* Fires when the current player equips a [Tool](https://developer.roblox.com/api-reference/class/Tool "Tool").
*/
readonly LocalToolEquipped: RBXScriptSignal<(toolEquipped: Tool) => void>;
/**
* Fires when the current player unequips a [Tool](https://developer.roblox.com/api-reference/class/Tool "Tool").
*/
readonly LocalToolUnequipped: RBXScriptSignal<(toolUnequipped: Tool) => void>;
}
/** The base class for controller objects, such as the [HumanoidController](https://developer.roblox.com/en-us/api-reference/class/HumanoidController) object. */
interface Controller extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Controller: unique symbol;
/**
* Activates an overriding bind on the specified button.
*/
BindButton(this: Controller, button: CastsToEnum, caption: string): void;
/**
* Returns whether or not Button is being pressed.
*/
GetButton(this: Controller, button: CastsToEnum): boolean;
/**
* Removes the bind on button.
*/
UnbindButton(this: Controller, button: CastsToEnum): void;
/**
* Fired when the pressed state of a bound button is changed. This event can be used in conjunction with [Controller:GetButton](https://developer.roblox.com/en-us/api-reference/function/Controller/GetButton) to see whether a bound button is being pressed down or not.
*/
readonly ButtonChanged: RBXScriptSignal<(button: Enum.Button) => void>;
}
/** A HumanoidController is an internal object responsible for translating PlayerAciton movements to the user's character (specifically, their [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)).
*
* This object can be found inside of the [ControllerService](https://developer.roblox.com/en-us/api-reference/class/ControllerService), via:
*
* local ControllerService = game:GetService("ControllerService")
* local HumanoidController = ControllerService:FindFirstChildOfClass("HumanoidController")
*/
interface HumanoidController extends Controller {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HumanoidController: unique symbol;
}
/** A SkateboardController is an object responsible for translating PlayerActions to movements with a [SkateboardPlatform](https://developer.roblox.com/en-us/api-reference/class/SkateboardPlatform). */
interface SkateboardController extends Controller {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SkateboardController: unique symbol;
/**
* The direction of movement, tied to the keys A and D. Must be 1 (right), 0 (straight), or -1 (left). Will refresh back to 0 unless constantly set.
*
* Tags: NotReplicated
*/
readonly Steer: number;
/**
* The direction of movement, tied to the keys W and S. Must be an integer 1 (forward), 0 (null), or -1 (reverse). Will refresh back to 0 unless constantly set.
*
* Tags: NotReplicated
*/
readonly Throttle: number;
/**
* Fired when any input state of the skateboard controller is updated.
*
* The _axis_ is fired with either ["Throttle"](https://developer.roblox.com/articles/String "String") if the throttle state of the skateboard was updated or ["Steer"](https://developer.roblox.com/articles/String "String") if the steering state of the skateboard was updated.
*/
readonly AxisChanged: RBXScriptSignal<(axis: string) => void>;
}
/** A VehicleController is an object responsible for translating [PlayerActions](https://developer.roblox.com/api-reference/enum/PlayerActions "PlayerActions") to movements with a [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat). */
interface VehicleController extends Controller {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_VehicleController: unique symbol;
}
interface ControllerBase extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ControllerBase: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Active: boolean;
BalanceRigidityEnabled: boolean;
MoveSpeedFactor: number;
}
interface AirController extends ControllerBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AirController: unique symbol;
BalanceMaxTorque: number;
BalanceSpeed: number;
/**
* Tags: Hidden, NotReplicated
*/
LinearImpulse: Vector3;
MaintainAngularMomentum: boolean;
MaintainLinearMomentum: boolean;
MoveMaxForce: number;
TurnMaxTorque: number;
TurnSpeedFactor: number;
}
interface ClimbController extends ControllerBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ClimbController: unique symbol;
AccelerationTime: number;
BalanceMaxTorque: number;
BalanceSpeed: number;
MoveMaxForce: number;
}
interface GroundController extends ControllerBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GroundController: unique symbol;
AccelerationLean: number;
AccelerationTime: number;
BalanceMaxTorque: number;
BalanceSpeed: number;
DecelerationTime: number;
Friction: number;
FrictionWeight: number;
GroundOffset: number;
StandForce: number;
StandSpeed: number;
TurnSpeedFactor: number;
}
interface SwimController extends ControllerBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SwimController: unique symbol;
AccelerationTime: number;
PitchMaxTorque: number;
PitchSpeedFactor: number;
RollMaxTorque: number;
RollSpeedFactor: number;
}
interface ControllerManager extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ControllerManager: unique symbol;
ActiveController: ControllerBase | undefined;
BaseMoveSpeed: number;
BaseTurnSpeed: number;
ClimbSensor: ControllerSensor | undefined;
FacingDirection: Vector3;
GroundSensor: ControllerSensor | undefined;
MovingDirection: Vector3;
RootPart: BasePart | undefined;
}
/** Container class for the [HumanoidController](https://developer.roblox.com/en-us/api-reference/class/HumanoidController) among other classes. */
interface ControllerService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ControllerService: unique symbol;
}
interface CoreScriptDebuggingManagerHelper extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CoreScriptDebuggingManagerHelper: unique symbol;
}
interface CreationDBService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CreationDBService: unique symbol;
}
interface CrossDMScriptChangeListener extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CrossDMScriptChangeListener: unique symbol;
}
/** The DataModelMesh is an abstract class from which mesh classes descend.
*
* Mesh classes are objects that, when parented to [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s alter the appearance of the part to that of a predefined mesh. Note, they only alter the appearance of the part and not the physics/collision boundaries of the part. Developers looking to apply a mesh to a part that alters the part's collision should use [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s.
*
* Note the [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) and [CharacterMesh](https://developer.roblox.com/en-us/api-reference/class/CharacterMesh) classes do not descend from DataModelMesh.
*/
interface DataModelMesh extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataModelMesh: unique symbol;
/**
* The Offset of a mesh determines the distance from the [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that the mesh will be displayed.
*
* How to use mesh offset
* ----------------------
*
* The Offset property changes the relative position the mesh will be rendered at. For example, an offset of 0, 5, 0 will cause the mesh to be displayed 5 studs above the position of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* The position of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) remains unchanged, meaning the physics collision box of the part will remain in the same location. This is demonstrated in the image below where the green outline (a [SelectionBox](https://developer.roblox.com/en-us/api-reference/class/SelectionBox)) shows the extents of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* 
*
* Other uses for mesh offset
* --------------------------
*
* There are a number of interesting uses for the mesh offset property.
*
* * Offset and [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale) can be animated using [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) relatively inexpensively as the engine does not need to make any physics/collision calculations as the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is not moved.
* * Changing the relationship between the mesh and its collision extents (determined by the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart))
*/
Offset: Vector3;
/**
* The Scale of a mesh determines the size of the mesh relative to its original dimensions.
*
* How to use mesh scale
* ---------------------
*
* The scale property works slightly differently depending on the type of mesh being used. Note the size of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) remains unchanged, meaning the physics collision box of the part will remain the same.
*
* * [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) objects with `SpecialMesh/FileType` set to 'FileMesh' scale relative to the original dimensions of the mesh when it was uploaded to Roblox
* * [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh) objects or [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) objects with `SpecialMesh/FileType` set to 'Brick', 'Wedge' or 'Sphere' scale uniformly relative to the [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) of their parent
* * [CylinderMesh](https://developer.roblox.com/en-us/api-reference/class/CylinderMesh) objects or [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) objects with `SpecialMesh/FileType` set to 'Cylinder' scale relative to the [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) of their parent. Uniformly for the cylinders height axis and maintaining a 1:1 ratio for the length and width of the cylinder, using the lowest value.
* * [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) objects with `SpecialMesh/FileType` set to 'Head' currently scale in a non standard manner. Developers should not rely on this as their are plans to change this behavior
* * [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) objects with `SpecialMesh/FileType` set to 'Torso' scale in a non standard manner. Developers should not rely on this as their are plans to deprecate this mesh type.
*
* Mesh scale demonstration
* ------------------------
*
* The above behavior can be seen in the following demonstration images.
*
* Linear scaling relative to part size for 'Brick', 'Wedge' and 'Sphere' meshes.
* 
*
* Linear scaling relative to original uploaded mesh for 'FileMesh' meshes
* 
*
* Non-uniform constrained scaling for 'Cylinder' meshes
* 
*
* Other uses for mesh scale
* -------------------------
*
* There are a number of interesting uses for the mesh offset property.
*
* * [DataModelMesh.Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) and Scale can be animated using [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) relatively inexpensively as the engine does not need to make any physics/collision calculations as the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is not changed.
* * Changing the relationship between the mesh and its collision extents (determined by the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart))
*/
Scale: Vector3;
/**
* **VertexColor** determines the huge change of the [Texture](https://developer.roblox.com/en-us/api-reference/property/FileMesh/TextureId) of a [FileMesh](https://developer.roblox.com/en-us/api-reference/class/FileMesh).
*
* The image below shows two versions of the hat [“Ozzy's Formal Top Hat”](https://www.roblox.com/catalog/3690516671/Ozzys-Formal-Top-Hat). The left has a default VertexColor of (1, 1, 1), or white. The right has a VertexColor of (0, 0, 1), or blue. The RGB colors on the texture of the red and white hat are multiplied with that of the VertexColor's XYZ components.
*
* 
*
* It should be noted that this property is a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) rather than a [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3). To convert, use the following function:
*
* local function color3ToVector3(c3)
* return Vector3.new(c3.r, c3.g, c3.b)
* end
*
* Although this property allows basic modification of a texture, changing a texture entirely provides more control. See [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) for more details.
*/
VertexColor: Vector3;
}
/** This is an abstract class that [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh) and [CylinderMesh](https://developer.roblox.com/en-us/api-reference/class/CylinderMesh) inherit from. */
interface BevelMesh extends DataModelMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BevelMesh: unique symbol;
}
/** The BlockMesh object applies a 'brick' mesh to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it is parented to. It behaves identically to a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) with [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) set to 'brick'.
*
* What does a BlockMesh do?
* -------------------------
*
* A BlockMesh gives the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it was applied to a brick shaped mesh. It is identical in appearance to a standard Roblox [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* The dimensions of the mesh will scale linearly in all directions with [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size), this means a part containing a BlockMesh can be resized the same way as any other part.
*
* The additional functionality a BlockMesh brings however, is the ability to set the [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale) and [DataModelMesh.Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) properties. These allow the position and dimensions of the mesh that is displayed to be changed without changing the [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) or [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) the mesh is parented to.
*
* Note as the [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh) object does not include a texture the [DataModelMesh.VertexColor](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/VertexColor) property does not do anything.
*/
interface BlockMesh extends BevelMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BlockMesh: unique symbol;
}
/** The CylinderMesh object applies a 'cylinder' mesh to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it is parented to.
*
* What does a CylinderMesh do?
* ----------------------------
*
* A CylinderMesh gives the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it was applied to a cylinder shaped mesh.
*
* The mesh applied gives the same appearance as that due to the [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) of a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) being set to 'Cylinder' or [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) being set to 'Cylinder'. However, unlike those two cases, it is orientated so that the height of the cylinder is along the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)'s Y axis.
*
* The dimensions of the mesh scale relative to the [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This scale is uniformly along the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)'s Y axis and maintaining a 1:1 ratio for the part's X and Z axis, using the lowest value. This means the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) can be resized normally, but the cross section of the cylinder will always remain a circle and cannot be stretched or compressed.
*
* Note as the CylinderMesh object does not include a texture the [DataModelMesh.VertexColor](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/VertexColor) property does not do anything.
*
* Why use a CylinderMesh?
* -----------------------
*
* The advantage of using a mesh over setting the [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) property of a part to 'Cylinder' is that the [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale) and [DataModelMesh.Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) properties are exposed. These allow the position and dimensions of the mesh that is displayed to be changed without changing the [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) or [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) of the [Part](https://developer.roblox.com/en-us/api-reference/class/Part) the mesh is parented to.
*
* The key difference between a CylinderMesh or a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) with [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) set to 'Cylinder' is the orientation of the cylinder mesh. With a CylinderMesh, the height of the cylinder is aligned with the height (Y axis) of the part. With a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) (or [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) set to 'Cylinder'), the height of the cylinder is aligned with the X axis.
*/
interface CylinderMesh extends BevelMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CylinderMesh: unique symbol;
}
interface EditableMesh extends DataModelMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EditableMesh: unique symbol;
/**
* Tags: Hidden
*/
readonly MeshVersion: number;
AddTriangle(this: EditableMesh, vertexId0: number, vertexId1: number, vertexId2: number): number;
AddVertex(this: EditableMesh, p: Vector3): number;
FindClosestPointOnSurface(this: EditableMesh, point: Vector3): unknown;
FindClosestVertex(this: EditableMesh, toThisPoint: Vector3): number;
FindVerticesWithinSphere(this: EditableMesh, center: Vector3, radius: number): unknown;
GetAdjacentTriangles(this: EditableMesh, triangleId: number): unknown;
GetAdjacentVertices(this: EditableMesh, vertexId: number): unknown;
GetPosition(this: EditableMesh, vertexId: number): Vector3;
GetTriangleVertices(this: EditableMesh, triangleId: number): unknown;
GetTriangles(this: EditableMesh): unknown;
GetUV(this: EditableMesh, vertexId: number): Vector2;
GetVertexColor(this: EditableMesh, vertexId: number): Color3;
GetVertexColorAlpha(this: EditableMesh, vertexId: number): number;
GetVertexNormal(this: EditableMesh, vertexId: number): Vector3;
GetVertices(this: EditableMesh): unknown;
RaycastLocal(this: EditableMesh, origin: Vector3, direction: Vector3): unknown;
RemoveTriangle(this: EditableMesh, triangleId: number): void;
RemoveVertex(this: EditableMesh, vertexId: number): void;
SetPosition(this: EditableMesh, vertexId: number, p: Vector3): void;
SetUV(this: EditableMesh, vertexId: number, uv: Vector2): void;
SetVertexColor(this: EditableMesh, vertexId: number, color: Color3): void;
SetVertexColorAlpha(this: EditableMesh, vertexId: number, alpha: number): void;
SetVertexNormal(this: EditableMesh, vertexId: number, vnormal: Vector3): void;
/**
* Tags: Yields
*/
CreateMeshPartAsync(this: EditableMesh, collisionFidelity: CastsToEnum): MeshPart;
}
/** The FileMesh object applies a textured mesh to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) when parented to it. Its properties are inherited by the [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) object.
*
* What is a FileMesh?
* -------------------
*
* FileMeshes allow user uploaded meshes to be applied to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). The mesh that is applied is dependent on the [FileMesh.MeshId](https://developer.roblox.com/en-us/api-reference/property/FileMesh/MeshId) property. A texture can also be applied to this mesh using [FileMesh.TextureId](https://developer.roblox.com/en-us/api-reference/property/FileMesh/TextureId).
*
* Although it is not an abstract class, and can be used by developers, all [FileMesh](https://developer.roblox.com/en-us/api-reference/class/FileMesh) properties are inherited by the [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) object. A [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) behaves identically to the FileMesh object when its [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) is set to 'FileMesh'. Although both objects are functional, the [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) object is the official supported class.
*
* For more information on using meshes, please see the [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) page.
*/
interface FileMesh extends DataModelMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FileMesh: unique symbol;
/**
* The MeshId is the content ID of the mesh that is to be displayed.
*
* The content ID for a mesh is generated when a developer uploads a mesh to the Roblox website.
*
* How do I create a mesh?
* -----------------------
*
* Meshes can currently only be be uploaded using [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s or the game explorer. Once uploaded however, the content ID for the mesh can be used for the MeshId property. For more information on how to do this please see [this tutorial](https://developer.roblox.com/en-us/articles/mesh-parts).
*/
MeshId: string;
/**
* The TextureId is the content ID of the image that is to be applied to used for the meshes texture. When the TextureId property is set to an empty string, no texture will be applied to the mesh.
*
* How can I change the texture of a mesh?
* ---------------------------------------
*
* Using the TextureId property, the texture of a mesh can be changed without having to reupload the mesh. To do this, a new image will need to be uploaded to Roblox with the desired texture. The original texture image file can be obtained by exporting the mesh using the 'Export Selection' option in Roblox Studio. The image file will be saved alongside the exported .obj file.
*
* The new texture can then be re-uploaded to Roblox as a Decal and its content ID can be applied to the mesh using the TextureId property.
*
* How can I make a textured mesh?
* -------------------------------
*
* A mesh can only be textured if the mesh has been UV mapped. UV mapping refers to the practice of projecting a texture map onto a mesh. This cannot be done using Roblox Studio and has to be done using an external 3D modelling application such as [Blender](https://www.blender.org/).
*/
TextureId: string;
}
/** The SpecialMesh is an object that allows developers to provide a standard template or user uploaded mesh to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* What does a SpecialMesh do?
* ---------------------------
*
* The SpecialMesh object applies a mesh to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) depending on the the [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) property. A number of options are available.
*
* * **Brick** - A block shape, equivalent to a [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh)
* * **Cylinder** - A cylinder, identical to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with a [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) of 'Cylinder'
* * **FileMesh** - A user uploaded Mesh, equivalent to [FileMesh](https://developer.roblox.com/en-us/api-reference/class/FileMesh) that a texture can be applied to using the [FileMesh.TextureId](https://developer.roblox.com/en-us/api-reference/property/FileMesh/TextureId) property
* * **Head** - A character head shape
* * **Sphere** - A sphere shape, similar to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with a [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) of 'Ball' but can be freely resized on all axis
* * **Wedge** - A wedge shape, identical to a [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart)
* * **Torso** - A block with sloped sides, due to be deprecated
*
* Note, each [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType) will scale differently when using [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale), for more information on this please see the page on [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale). The SpecialMesh object also exposes the [DataModelMesh.Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) property.
*
* It is important to remember that when using a SpecialMesh, only the appearance of a part changes. The collision model of the part remains the same. For example, a character will not be able to walk correctly over a mesh as the mesh geometry is not taken into account.
*
* SpecialMesh or MeshPart?
* ------------------------
*
* There are currently two ways of using a developer created mesh. They are using a SpecialMesh with the `SpecialMesh/FileType` set to 'FileMesh', or by using a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart). Although, on the whole, the [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) object has superseded the SpecialMesh there are some differences developers should be aware of.
*
* * [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) displays correctly on the mesh when using a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) and not when using a SpecialMesh
* * [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s include the `MeshPart/CollisionFidelity` property, meaning the collision model of a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) can be set to resemble the geometry of the mesh. The SpecialMesh object by contrast, uses the parent [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s collision model
* * The mesh of a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) scales on all axis depending on the [Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) property of the [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart), the mesh of a SpecialMesh does not
* * The SpecialMesh object includes the [Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) and [Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale) properties whereas [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s do not
* * The [MeshId](https://developer.roblox.com/en-us/api-reference/property/FileMesh/MeshId) property of a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) can be changed by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) during runtime. The [MeshId](https://developer.roblox.com/en-us/api-reference/property/MeshPart/MeshId) property of a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) can not.
*
* In most, but not all cases, using a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) is more suitable. As [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s are a relatively new feature however, developers should expect some of the above behaviour to change.
*
* Uploading a custom mesh
* -----------------------
*
* Although a developer uploaded mesh can be used on a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh), meshes can currently only be be uploaded using [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s or the game explorer. For more information on how to do this please see [this tutorial](https://developer.roblox.com/en-us/articles/mesh-parts).
*/
interface SpecialMesh extends FileMesh {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SpecialMesh: unique symbol;
/**
* The mesh that the [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh)object applies to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) depends on the MeshType property. A number of options are available.
*
* * **Brick** - A block shape, equivalent to a [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh)
* * **Cylinder** - A cylinder, identical to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with a [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) of 'Cylinder'
* * **FileMesh** - A user uploaded Mesh, equivalent to [FileMesh](https://developer.roblox.com/en-us/api-reference/class/FileMesh) that a texture can be applied to using the [FileMesh.TextureId](https://developer.roblox.com/en-us/api-reference/property/FileMesh/TextureId) property
* * **Head** - A character head shape
* * **Sphere** - A sphere shape, similar to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) with a [Part.Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape) of 'Ball' but can be freely resized on all axis
* * **Wedge** - A wedge shape, identical to a [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart)
* * **Torso** - A block with sloped sides, due to be deprecated
*
* Note, each MeshType will scale differently when using [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale), for more information on this please see the page on [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale).
*/
MeshType: Enum.MeshType;
}
interface DataModelPatchService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataModelPatchService: unique symbol;
}
interface DataStoreGetOptions extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreGetOptions: unique symbol;
UseCache: boolean;
}
/** An object that specifies additional parameters for a [GlobalDataStore:IncrementAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/IncrementAsync) call.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreIncrementOptions extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreIncrementOptions: unique symbol;
/**
* This function gets custom metadata associated with this [DataStoreIncrementOptions](https://developer.roblox.com/en-us/api-reference/class/DataStoreIncrementOptions) instance.
*/
GetMetadata(this: DataStoreIncrementOptions): object;
/**
* This function sets custom metadata used by [GlobalDataStore:IncrementAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/IncrementAsync) to associate metadata with a key. Metadata should be in key-value pair form.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
SetMetadata(this: DataStoreIncrementOptions, attributes: object): void;
}
/** Object describing data store information such as name, created time, and time last updated. This object is a member of the [DataStoreListingPages](https://developer.roblox.com/en-us/api-reference/class/DataStoreListingPages) object returned by [DataStoreService:ListDataStoresAsync](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/ListDataStoresAsync).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreInfo extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreInfo: unique symbol;
/**
* This property indicates when the data store was created in milliseconds since epoch.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly CreatedTime: number;
/**
* This property indicates the name of the data store. It is used as a unique identifier to retrieve a data store instance with [DataStoreService:GetDataStore](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly DataStoreName: string;
/**
* This property indicates the last time the data store was updated in milliseconds since epoch.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly UpdatedTime: number;
}
/** Object representing a key on a [DataStoreKeyPages](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyPages) object. It contains the key name as [DataStoreKey.KeyName](https://developer.roblox.com/en-us/api-reference/property/DataStoreKey/KeyName). This object is a member of the [DataStoreKeyPages](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyPages) object returned by [DataStore:ListKeysAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListKeysAsync).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreKey extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreKey: unique symbol;
/**
* This property indicates the name of the key. This name can then be used in other operations such as [GlobalDataStore:GetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/GetAsync) and [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync).
*
* If [DataStoreOptions.AllScopes](https://developer.roblox.com/en-us/api-reference/property/DataStoreOptions/AllScopes) was set to true when accessing the data store through [DataStoreService:GetDataStore](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore), the name will include its scope as a prefix.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly KeyName: string;
}
/** An object describing information about a particular version of the key. This is returned as the second return value by [GlobalDataStore:GetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/GetAsync), [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync), [GlobalDataStore:IncrementAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/IncrementAsync), [GlobalDataStore:RemoveAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/RemoveAsync), and [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreKeyInfo extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreKeyInfo: unique symbol;
/**
* This property indicates the date and time the object was created, formatted as the number of milliseconds since epoch.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly CreatedTime: number;
/**
* This property indicates the date and time the object was last updated, formatted as the number of milliseconds since epoch.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly UpdatedTime: number;
/**
* This property uniquely identifies the version of the object. It can be passed to [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync) or [DataStore:RemoveVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/RemoveVersionAsync) to get or remove the version respectively.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly Version: string;
/**
* This function returns the metadata associated with the latest version of the object.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
GetMetadata(this: DataStoreKeyInfo): object;
/**
* This function returns an array of [UserIds](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) tagged with the object. This information is useful for adhering to [GDPR](https://developer.roblox.com/articles/managing-personal-information) policies.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
GetUserIds(this: DataStoreKeyInfo): unknown;
}
/** An instance describing version information for a key, including the version string, created time, and whether it has been marked as deleted.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreObjectVersionInfo extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreObjectVersionInfo: unique symbol;
/**
* This property indicates when the version was created in milliseconds since epoch.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly CreatedTime: number;
/**
* This property describes whether the version has been marked as deleted. Deleted versions will be permanently deleted after 30 days.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly IsDeleted: boolean;
/**
* This property uniquely identifies a particular version of the key. It can be passed to [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync) or [DataStore:RemoveVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/RemoveVersionAsync) to get or remove the version respectively.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: NotReplicated
*/
readonly Version: string;
}
/** Any object containing additional parameters that are used by [DataStoreService:GetDataStore](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore). */
interface DataStoreOptions extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreOptions: unique symbol;
/**
* This property specifies whether the [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) should work with all scopes.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
AllScopes: boolean;
/**
* This function currently has no effect.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
SetExperimentalFeatures(this: DataStoreOptions, experimentalFeatures: object): void;
}
/** **DataStoreService** exposes methods for getting [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) and [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) objects. Data stores can only be accessed by game servers, so you can only use [DataStoreService](https://developer.roblox.com/en-us/api-reference/class/DataStoreService) within a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or a [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) that is used by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script).
*
* See the [Data Stores](https://developer.roblox.com/en-us/articles/data-store) article for an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreService: unique symbol;
/**
* This function creates a [DataStore](https://developer.roblox.com/en-us/api-reference/class/DataStore) instance with the provided name and scope. Subsequent calls to this method with the same name/scope will return the same object.
*
* Using the `scope` parameter will restrict operations to that scope by automatically prepending the scope to keys in all operations done on the data store. This function also accepts an optional [DataStoreOptions](https://developer.roblox.com/en-us/api-reference/class/DataStoreOptions) instance which includes options for enabling [AllScopes](https://developer.roblox.com/en-us/api-reference/property/DataStoreOptions/AllScopes). See [here](https://developer.roblox.com/articles/Data-store#scope) for details on scope.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
GetDataStore(this: DataStoreService, name: string, scope?: string, options?: DataStoreOptions): DataStore;
/**
* This function returns the default [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore). If you want to access a specific **named** data store instead, you should use the [GetDataStore()](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore) function.
*/
GetGlobalDataStore(this: DataStoreService): DataStore;
/**
* This method returns an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore), similar to the way [GetDataStore()](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore) does with [GlobalDataStores](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore). Subsequent calls to this method with the same name/scope will return the same object.
*/
GetOrderedDataStore(this: DataStoreService, name: string, scope?: string): OrderedDataStore;
/**
* This function returns the number of data store requests that the current place can make based on the given [DataStoreRequestType](https://developer.roblox.com/en-us/api-reference/enum/DataStoreRequestType). Any requests made that exceed this budget are subject to [throttling](https://developer.roblox.com/en-us/articles/datastore-errors). Monitoring and adjusting the frequency of data store requests using this function is recommended.
*/
GetRequestBudgetForRequestType(this: DataStoreService, requestType: CastsToEnum): number;
/**
* Returns a [DataStoreListingPages](https://developer.roblox.com/en-us/api-reference/class/DataStoreListingPages) object for enumerating through all of the experience's data stores. It accepts an optional `prefix` parameter to only locate data stores whose names start with the provided prefix.
*
* Only data stores containing at least one object will be listed via this function.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
ListDataStoresAsync(this: DataStoreService, prefix?: string, pageSize?: number, cursor?: string): DataStoreListingPages;
}
/** An object that specifies additional parameters for a [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) call.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreSetOptions extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreSetOptions: unique symbol;
/**
* This function gets custom metadata associated with this [DataStoreSetOptions](https://developer.roblox.com/en-us/api-reference/class/DataStoreSetOptions) instance.
*/
GetMetadata(this: DataStoreSetOptions): object;
/**
* This function sets custom metadata used by [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) to associate metadata with a key. Metadata should be in key-value pair form.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
SetMetadata(this: DataStoreSetOptions, attributes: object): void;
}
/** The Debris service allows the developer to schedule the removal of the object without yielding any code, through the usage of the [Debris:AddItem](https://developer.roblox.com/en-us/api-reference/function/Debris/AddItem) method.
*
* After the lifetime argument has elapsed (in seconds) the object is removed in the same manner as [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy).
*
* As Debris is a service it must be created using the [ServiceProvider:GetService](https://developer.roblox.com/en-us/api-reference/function/ServiceProvider/GetService) method.
*
* **Why use Debris?**
*
* Beyond creating a bit of a mess, objects that are no longer required can use up system memory and cause the game to run slower over time. For this reason it is always advised to run the [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) function on objects you no longer need. However in many cases an object may have a specific period of utility after which it needs to be destroyed.
*
* Take the example of projectile that has just been thrown. It could be cleaned up using:
*
* wait(3)
* projectile:Destroy()
*
* However there are a number of issues with this approach. Firstly, it requires yielding the code with a wait, which is not always desirable. Secondly, before the 3 seconds have elapsed the object may have already been destroyed (for example, if it reached [Workspace.FallenPartsDestroyHeight](https://developer.roblox.com/en-us/api-reference/property/Workspace/FallenPartsDestroyHeight)).
*
* delay(3, function()
* if projectile and projectile.Parent then
* projectile:Destroy()
* end
* end)
*
* This solves the above issues, as it spawns a new thread to prevent the current one from yielding and checks to see if it can be destroyed. However at this point a simple command has already become quite complicated and an unnecessary thread is being created.
*
* This is where Debris comes in, and the following code addresses all of the above issues.
*
* Debris:AddItem(projectile, 3)
*
* Debris does not yield the current thread, does not require a new thread and will not error if the object is already destroyed. For this reason it is the recommended method for cleaning up objects with a fixed lifetime.
*/
interface Debris extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Debris: unique symbol;
/**
* Allows the developer to schedule the removal of the object without yielding any code.
*
* Registers a given [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) to the [Debris](https://developer.roblox.com/en-us/api-reference/class/Debris) service for removal after the specified delay. The first argument is the object being removed, and the second argument is the amount of time in seconds the [Debris](https://developer.roblox.com/en-us/api-reference/class/Debris) service will wait before removing the object. The delay argument is optional, if it is not specified, it defaults to 10 seconds. The delay argument is a number, so it accepts decimal points, such as '1.5', or '0.25'.
*
* ### Why use Debris?
*
* Beyond creating a bit of a mess, objects that are no longer required can use up system memory and cause the game to run slower over time. For this reason it is always advised to run the [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) function on objects you no longer need. However in many cases an object may have a specific period of utility after which it needs to be destroyed.
*
* Take the example of projectile that has just been thrown. On first thought, it could be cleaned up using:
*
* ```lua
* wait(3)
* projectile:Destroy()
* ```
*
* However there are a number of issues with this approach. Firstly, it requires yielding the code with a wait, which is not always desirable. Secondly, before the 3 seconds have elapsed the object may have already been destroyed (for example, if it reached [Workspace.FallenPartsDestroyHeight](https://developer.roblox.com/en-us/api-reference/property/Workspace/FallenPartsDestroyHeight)). In this case, the code would error as it tries to destroy an item that has already been destroyed. One answer may be:
*
* ```lua
* delay(3, function()
* if projectile and projectile.Parent then
* projectile:Destroy()
* end
* end)
* ```
*
* This solves the above issues, as it spawns a new thread to prevent the current one from yielding and checks to see if it can be destroyed. However at this point a simple command has already become quite complicated and an unnecessary thread is being created.
*
* This is where Debris comes in, and the following code addresses all of the above issues.
*
* ```lua
* Debris:AddItem(projectile, 3)
* ```
*
* Debris does not yield the current thread, does not require a new thread and will not error if the object is already destroyed. For this reason it is the recommended method for cleaning up objects with a fixed lifetime.
*/
AddItem(this: Debris, item: Instance, lifetime?: number): void;
}
interface DebuggablePluginWatcher extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggablePluginWatcher: unique symbol;
}
interface DebuggerConnection extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggerConnection: unique symbol;
}
interface LocalDebuggerConnection extends DebuggerConnection {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LocalDebuggerConnection: unique symbol;
}
interface DebuggerConnectionManager extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggerConnectionManager: unique symbol;
}
interface DebuggerLuaResponse extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggerLuaResponse: unique symbol;
}
interface DebuggerUIService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggerUIService: unique symbol;
}
interface DebuggerVariable extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DebuggerVariable: unique symbol;
}
interface DeviceIdService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DeviceIdService: unique symbol;
}
/** The Dialog object allows users to create non-player characters (NPCs) that players can talk to using a list of choices. The Dialog object can be inserted into a part such as a Humanoid's head, and then a player will see a speech bubble above the part that they can click on to start a conversation. The creator of a place can choose what choices the player can say by inserting [DialogChoice](https://developer.roblox.com/en-us/api-reference/class/DialogChoice) objects into the dialog.
*
* **See Also:**
*
* * [How to use Dialogs](https://developer.roblox.com/articles/Usage-of-dialogs)
*/
interface Dialog extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Dialog: unique symbol;
/**
* The BehaviorType of a Dialog determines whether multiple players can interact with a dialog at once. The default value for this property is SinglePlayer.
*
* SinglePlayer
* ------------
*
* When a Dialog is configured to SinglePlayer, only one player can interact with it at a time. As soon as a player engages with a dialog, other players will not be able to initiate the dialog until the first player is finished.
*
*
* While a player is engaged with a dialog, the other players will see the dialog choices of the player who started the dialog, along with the responses.
*
* MultiplePlayers
* ---------------
*
* When a Dialog is setto MultiplePlayers, any player can initiate a dialog at any time, even if another player has already initiated the dialog. Unlike SinglePlayer however, Dialogs set to MultiplePlayers will not show the dialog choices and responses to anyone but the player in the conversation.
*
* Example
* -------
*
* local singlePlayerDialog = Instance.new("Dialog")
* local singlePlayerPart = game.Workspace.SinglePlayerPart
* singlePlayerDialog.BehaviorType = Enum.DialogBehaviorType.SinglePlayer
* singlePlayerDialog.InitialPrompt = "Only one person can interact with me at once."
* singlePlayerDialog.Parent = singlePlayerPart
*
* local multiplePlayersDialog = Instance.new("Dialog")
* local multiplePlayersPart = game.Workspace.MultiplePlayersPart
* multiplePlayersDialog.BehaviorType = Enum.DialogBehaviorType.MultiplePlayers
* multiplePlayersDialog.InitialPrompt = "Any number of players can interact with me at once."
* multiplePlayersDialog.Parent = multiplePlayersPart
*/
BehaviorType: Enum.DialogBehaviorType;
/**
* The furthest distance that I player can be from the Dialog's parent to start a conversation.
*/
ConversationDistance: number;
/**
* Toggles whether the goodbye option will be displayed. If true, the dialog will display the content of [Dialog.GoodbyeDialog](https://developer.roblox.com/en-us/api-reference/property/Dialog/GoodbyeDialog) as the last option after other dialog choices. Clicking on the goodbye option will exit the dialog.
*
* GoodbyeChoiceActive = true
* --------------------------
*
* 
*
* GoodbyeChoiceActive = false
* ---------------------------
*
* 
*/
GoodbyeChoiceActive: boolean;
/**
* Sets the sentence that the dialog will show to the player when the chat ends
*/
GoodbyeDialog: string;
/**
* If true, this dialog is being used by at least one player.
*/
InUse: boolean;
/**
* Sets the first sentence that the dialog will show to the player, once a chat is commenced.
*/
InitialPrompt: string;
/**
* Sets the icon that the initial dialog displays.
*/
Purpose: Enum.DialogPurpose;
/**
* Sets the color of the NPC's speech bubble.
*/
Tone: Enum.DialogTone;
/**
* Sets the maximum distance that a dialog can be triggered from.
*/
TriggerDistance: number;
/**
* Sets the offset of the dialog relative to the dialog's parent.
*/
TriggerOffset: Vector3;
/**
* The GetCurrentPlayers function of a Dialog will return a list of [Player](https://developer.roblox.com/en-us/api-reference/class/Player) currently using the Dialog. If there are no players using the dialog then the returned list will be empty.
*/
GetCurrentPlayers(this: Dialog): Array;
/**
* Fired when a player chooses something to say, through a [Dialog](https://developer.roblox.com/en-us/api-reference/class/Dialog) instance.
*
* This event is client-side only and will not fire on the server. It should be connected to in either a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) required by a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*/
readonly DialogChoiceSelected: RBXScriptSignal<(player: Player, dialogChoice: Dialog) => void>;
}
/** Used to craft the further choices available to players who have started a dialog conversation with an NPC. */
interface DialogChoice extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DialogChoice: unique symbol;
/**
* Toggles whether the goodbye option will be displayed. If true, the dialog will display the content of [DialogChoice.GoodbyeDialog](https://developer.roblox.com/en-us/api-reference/property/DialogChoice/GoodbyeDialog) as the last option after other dialog choices. Clicking on the goodbye option will exit the dialog.
*
* GoodbyeChoiceActive = true
* --------------------------
*
* 
*
* GoodbyeChoiceActive = false
* ---------------------------
*
* 
*/
GoodbyeChoiceActive: boolean;
/**
* Sets the sentence that the dialog will show to the player when the chat ends
*/
GoodbyeDialog: string;
/**
* Sets what the NPC will say when the player chooses this DialogChoice.
*/
ResponseDialog: string;
/**
* Sets what the player will say when they choose this DialogChoice.
*/
UserDialog: string;
}
/** The **Dragger** object is a helper object used to create tools that can drag parts. It is expected (but not required) to be used with [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) events.
*
* Its implementation is primarily used in the RbxStamper library.
*/
interface Dragger extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Dragger: unique symbol;
/**
* Rotates the currently dragged part(s) by 90 degrees on the given axis.
*/
AxisRotate(this: Dragger, axis?: CastsToEnum): void;
/**
* Initializes a dragging action, specifying which parts to use when dragging.
*/
MouseDown(this: Dragger, mousePart: BasePart, pointOnMousePart: Vector3, parts: Array): void;
/**
* Tries to move the currently dragged part to the point where MouseRay hits another part.
*/
MouseMove(this: Dragger, mouseRay: Ray): void;
/**
* Stops the current dragging action (made by [MouseDown](https://developer.roblox.com/api-reference/function/Dragger/MouseDown "MouseDown"))
*/
MouseUp(this: Dragger): void;
}
interface DraggerService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DraggerService: unique symbol;
/**
* Tags: NotReplicated
*/
readonly AlignDraggedObjects: boolean;
/**
* Tags: NotReplicated
*/
readonly AngleSnapEnabled: boolean;
/**
* Tags: NotReplicated
*/
readonly AngleSnapIncrement: number;
/**
* Tags: NotReplicated
*/
readonly AnimateHover: boolean;
/**
* Tags: NotReplicated
*/
readonly CollisionsEnabled: boolean;
/**
* Tags: NotReplicated
*/
readonly DraggerCoordinateSpace: Enum.DraggerCoordinateSpace;
/**
* Tags: NotReplicated
*/
readonly DraggerMovementMode: Enum.DraggerMovementMode;
/**
* Tags: NotReplicated
*/
readonly GeometrySnapColor: Color3;
/**
* Tags: NotReplicated
*/
readonly HoverAnimateFrequency: number;
/**
* Tags: NotReplicated
*/
readonly HoverThickness: number;
/**
* Tags: NotReplicated
*/
readonly JointsEnabled: boolean;
/**
* Tags: NotReplicated
*/
readonly LinearSnapEnabled: boolean;
/**
* Tags: NotReplicated
*/
readonly LinearSnapIncrement: number;
/**
* Tags: NotReplicated
*/
readonly ShowHover: boolean;
/**
* Tags: NotReplicated
*/
ShowPivotIndicator: boolean;
}
interface EditableImage extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EditableImage: unique symbol;
Size: Vector2;
Copy(this: EditableImage, min: Vector2, max: Vector2): EditableImage;
Crop(this: EditableImage, min: Vector2, max: Vector2): void;
DrawCircle(this: EditableImage, center: Vector2, radius: number, color: Color3, transparency: number): void;
DrawImage(this: EditableImage, position: Vector2, image: EditableImage, combineType: CastsToEnum): void;
DrawLine(this: EditableImage, p1: Vector2, p2: Vector2, color: Color3, transparency: number): void;
DrawRectangle(this: EditableImage, position: Vector2, size: Vector2, color: Color3, transparency: number): void;
/**
* Tags: CustomLuaState
*/
ReadPixels(this: EditableImage, position: Vector2, size: Vector2): unknown;
Resize(this: EditableImage, size: Vector2): void;
Rotate(this: EditableImage, degrees: number, changeSize: boolean): void;
/**
* Tags: CustomLuaState
*/
WritePixels(this: EditableImage, position: Vector2, size: Vector2, pixels: Array): void;
}
interface EngineAPICloudProcessingService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EngineAPICloudProcessingService: unique symbol;
}
/** A EulerRotation Curve represents a 3D rotation curve, it groups 3 [FloatCurves](https://developer.roblox.com/en-us/api-reference/class/FloatCurve), stored as 3 FloatCurve child instances. The rotation is decomposed in 3 Euler angles channels that can be accessed via [EulerRotationCurve:X](https://developer.roblox.com/en-us/api-reference/function/EulerRotationCurve/X), [EulerRotationCurve:Y](https://developer.roblox.com/en-us/api-reference/function/EulerRotationCurve/Y), [EulerRotationCurve:Z](https://developer.roblox.com/en-us/api-reference/function/EulerRotationCurve/Z) methods. The 3 axes can be sampled simultaneously via the method [EulerRotationCurve:GetAnglesAtTime](https://developer.roblox.com/en-us/api-reference/function/EulerRotationCurve/GetAnglesAtTime) returning the 3 Euler angles as a Vector3. Similarly, [EulerRotationCurve:GetRotationAtTime](https://developer.roblox.com/en-us/api-reference/function/EulerRotationCurve/GetRotationAtTime) samples all channels simultaneously but returns a CFrame rotated by X, Y, and Z according to the specified rotation order. */
interface EulerRotationCurve extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EulerRotationCurve: unique symbol;
/**
* Euler angles rotation order
*/
RotationOrder: Enum.RotationOrder;
/**
* Samples the 3 [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurves) (X, Y, Z) at the time passed as argument. Returns the result as 3 Euler angles. If a channel curve is missing or no key is found in the curve the channel is evaluated as nil.
*/
GetAnglesAtTime(this: EulerRotationCurve, time: number): unknown;
/**
* Samples the [EulerRotationCurve](https://developer.roblox.com/en-us/api-reference/class/EulerRotationCurve) at a given time and returns the corresponding rotation. Empty Euler angles channels are interpreted as zero.
*/
GetRotationAtTime(this: EulerRotationCurve, time: number): CFrame;
/**
* Returns the [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) controlling the X Euler angle channel. It is the first child instance of type [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) named `X`. If none is found an empty [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) is created.
*/
X(this: EulerRotationCurve): FloatCurve;
/**
* Returns the [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) controlling the Y channel. It is the first child instance of type [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) named 'Y'. If none is found an empty [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) is created.
*/
Y(this: EulerRotationCurve): FloatCurve;
/**
* Returns the [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) controlling the Z channel. It is the first child instance of type [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) named `Z`. If none is found an empty [FloatCurve](https://developer.roblox.com/en-us/api-reference/class/FloatCurve) is created.
*/
Z(this: EulerRotationCurve): FloatCurve;
}
interface EventIngestService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EventIngestService: unique symbol;
}
interface ExperienceAuthService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ExperienceAuthService: unique symbol;
}
interface ExperienceInviteOptions extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ExperienceInviteOptions: unique symbol;
InviteMessageId: string;
InviteUser: number;
LaunchData: string;
PromptMessage: string;
}
interface ExperienceNotificationService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ExperienceNotificationService: unique symbol;
/**
* Tags: Yields
*/
CreateUserNotificationAsync(this: ExperienceNotificationService, userId: string, userNotification: UserNotification): Instance | undefined;
}
interface ExperienceService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ExperienceService: unique symbol;
}
/** An Explosion applies force to `BaseParts` within the explosion's [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius). This force breaks joints between parts and kills [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) characters not protected by a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField).
*
* If an explosion is instanced whilst the game is running, it will destroy itself shortly afterwards meaning they do not need to be cleaned up using the [Debris](https://developer.roblox.com/en-us/api-reference/class/Debris) service.
*
* **Explosion effects**
*
* `Humanoids` are killed by explosions as they break the character [Model](https://developer.roblox.com/en-us/api-reference/class/Model)'s neck joint. Parenting a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) to a model will protect all of its children from Explosions. This means that their joints will not be broken and thus [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s will not be killed.
*
* If a developer doesn't want joints between `BaseParts` to be broken or wants to implement their own formula for damaging [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s it is recommended they set [Explosion.DestroyJointRadiusPercent](https://developer.roblox.com/en-us/api-reference/property/Explosion/DestroyJointRadiusPercent) to 0 and use the [Explosion.Hit](https://developer.roblox.com/en-us/api-reference/event/Explosion/Hit) event to handle the result of the explosion.
*
* Explosions can also be configured to damage [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain), creating craters, this behavior is controlled by the [Explosion.ExplosionType](https://developer.roblox.com/en-us/api-reference/property/Explosion/ExplosionType) property.
*
* The effect of an Explosion is not disrupted by obstacles, this means parts shielded behind other parts will still be effected, even if the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) they are shielded behind is not anchored.
*/
interface Explosion extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Explosion: unique symbol;
/**
* Used to determine the amount of force applied to [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s caught in the [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius).
*
* Currently this level of force applied does not vary based on distance from [Explosion.Position](https://developer.roblox.com/en-us/api-reference/property/Explosion/Position). Unanchored `BaseParts` will accelerate equally away from the origin regardless of distance provided they are within the blast radius.
*
* The blast pressure determines the acceleration of parts due to an explosion. It does not determine the degree to which joints are broken. When [Explosion.DestroyJointRadiusPercent](https://developer.roblox.com/en-us/api-reference/property/Explosion/DestroyJointRadiusPercent) is equal to 1 all joints between parts in the [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius) will be destroyed provided BlastPressure is greater than 0.
*
* The BlastPressure also does not determine the amount of damage given to [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain). Provided BlastPressure is greater than 0 and [Explosion.ExplosionType](https://developer.roblox.com/en-us/api-reference/property/Explosion/ExplosionType) isn't set to Enum.ExplosionType.NoCraters the size of the crater created is determined exclusively by the [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius).
*
* Setting BlastPressure to 0 eliminates the effect of the explosion and is useful when developers want to program their own custom behavior for explosions using the [Explosion.Hit](https://developer.roblox.com/en-us/api-reference/event/Explosion/Hit) event.
*/
BlastPressure: number;
/**
* This property determines the radius of the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion), in studs. This property accepts any value between 0 and 100.
*
* This radius determines the area of effect of the Explosion, not the size of the Explosion's visuals. The size of the Explosion's visual effect is the same regardless of BlastRadius (even if BlastRadius is 0).
*
* [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s within the BlastRadius will be affected by the explosion. Meaning, if [Explosion.BlastPressure](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastPressure) is greater than 0, force will be applied to parts. The degree to which joints are broken within the BlastRadius depends on [Explosion.DestroyJointRadiusPercent](https://developer.roblox.com/en-us/api-reference/property/Explosion/DestroyJointRadiusPercent). [Explosion.Hit](https://developer.roblox.com/en-us/api-reference/event/Explosion/Hit) will fire for any every [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) within the radius.
*
* [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are considered within an [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion)'s BlastRadius even if they are only partially in range.
*/
BlastRadius: number;
/**
* Used to set the proportion of the [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius), between 0 and 1, within which all joints will be destroyed. Anything outside of this range will only have the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) force applied to it.
*
* For example, if [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius) is set to 100 and DestroyJointRadiusPercent is set to 0.5, any joints within a radius of 50 studs would be broken. Any joints between the ranges of 50 and 100 studs wouldn't be destroyed, but the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion)'s force would still be applied to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s.
*
* This property allows developers to make [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion)s 'non-lethal' to [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s by setting DestroyJointRadiusPercent to 0. This means the neck joint will not be broken when characters come into contact with the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion).
*/
DestroyJointRadiusPercent: number;
/**
* This property determines how the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) will interact with [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain). It is an Enum.ExplosionType value and can be set to one of three options.
*
* * **NoCraters** - Explosions will not damage Terrain
* * **Craters** - Explosions will create craters in Terrain
* * **CratersAndDebris** - Redundant, behaves the same as Craters
*
* If ExplosionType is set to create craters in [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain), the radius of the crater will be roughly equal to the [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius). Craters are created in all [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) materials other than water. The size of the crater is not influenced by the material, although some materials create rougher edges than others.
*/
ExplosionType: Enum.ExplosionType;
/**
* This property is the position of the center of the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion). It is defined in world-space and not influenced by the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion)'s parent.
*
* [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s will be influenced by the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) if they are within [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius) studs of the explosion's position.
*
* The effect of an explosion is instantaneous. This means that although the position of an explosion can be changed after it has been set it cannot affect two different areas. Once an explosion has been 'detonated', shortly after parenting it to a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace), it will not do so again. In some cases the visual effect of the explosion will move but it will have no effect.
*
* For this reason a new Explosion should be created if the developer wants an explosion to appear at a different position.
*/
Position: Vector3;
TimeScale: number;
/**
* This property determines whether or not the visual effect of an [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) is shown or not.
*
* When Visible is set to false, the explosion will still affect [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in its [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius), the only difference is it will not be seen.
*
* One use for this property would be for a developer to make their own custom explosion effects using a [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter), whilst retaining the default [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) functionality.
*/
Visible: boolean;
/**
* Fires when the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) hits a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) within its [Explosion.BlastRadius](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastRadius). Returns the part hit along with the distance of the part from [Explosion.Position](https://developer.roblox.com/en-us/api-reference/property/Explosion/Position).
*
* Note that the effect of an [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) is not disrupted by obstacles, this means parts shielded behind other parts will still be hit, even if the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) they are shielded behind is anchored.
*
* This event will also fire when [Explosion.BlastPressure](https://developer.roblox.com/en-us/api-reference/property/Explosion/BlastPressure) is equal to zero. This means developers can program their own custom behavior for explosions by eliminating the explosion's influence on [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s and [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain).
*
* Note that this event will fire for every [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) hit. This means it can fire multiple times for the same player character (as the character [Model](https://developer.roblox.com/en-us/api-reference/class/Model) is made up of multiple parts). For this reason when dealing custom damage using the `Explosion.Hit` event it's recommended to implement a check to see if the character has already been hit by the [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion).
*/
readonly Hit: RBXScriptSignal<(part: BasePart, distance: number) => void>;
}
interface FaceAnimatorService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FaceAnimatorService: unique symbol;
}
interface FaceControls extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FaceControls: unique symbol;
}
/** The FaceInstance class is an abstract class from which the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) class inherits. */
interface FaceInstance extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FaceInstance: unique symbol;
/**
* Sets what face of the brick the object appears on.
*/
Face: Enum.NormalId;
}
/** The Decal object is an object which applies an image to a face of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* How does a Decal work?
* ----------------------
*
* A Decal will apply an image to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it is parented to. The surface this image is applied to is dependent on the [FaceInstance.Face](https://developer.roblox.com/en-us/api-reference/property/FaceInstance/Face) property. The size of the decal is dependent on the size of the face, meaning the size and aspect ratio of a decal can be changed by changing its parent's [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size).
*
* The image a Decal applies is determined by its [Decal.Texture](https://developer.roblox.com/en-us/api-reference/property/Decal/Texture) property. Images can be uploaded to Roblox provided they adhere to the community guidelines. Information on how to upload images can be found [here](https://developer.roblox.com/en-us/articles/how-to-upload-a-decal).
*
* Alternatives to Decals
* ----------------------
*
* Although Decals have a wide variety of applications, in some cases developers may wish to pick one of the following classes instead.
*
* * For repeated tiled textures, the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) object should be used
* * To apply GUI elements, the [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) object should be used
* * If the effect of lighting on the image needs to be altered, the [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) object should be used
*/
interface Decal extends FaceInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Decal: unique symbol;
/**
* The [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3) tint of the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal).
*
* Developers should note that this property only sets the tint of the decal, rather than the color. This means, unless the image associated with the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) was originally white (RGB = 1,1,1) then the color cannot be freely changed using this property.
*
* By reducing the RGB properties of [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3) in union, developers can make a decal darker.
*/
Color3: Color3;
/**
* Acts as a multiplier for the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)'s [Decal.Transparency](https://developer.roblox.com/en-us/api-reference/property/Decal/Transparency) property. The effects are only visible to the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer).
*
* This property should be used in situations where [Decal.Transparency](https://developer.roblox.com/en-us/api-reference/property/Decal/Transparency) is being set by a different script. The benefit of LocalTransparencyModifier is that it can be changed without concern for the original [Decal.Transparency](https://developer.roblox.com/en-us/api-reference/property/Decal/Transparency) of the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)
*
* When LocalTransparencyModifier is set to 1, the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) will be completely invisible regardless of its original transparency. When it is set to 0, the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s rendered transparency will match the [Decal.Transparency](https://developer.roblox.com/en-us/api-reference/property/Decal/Transparency) value. The formula for this is:
*
* Displayed Transparency = Transparency + ((1 - Transparency) \* LocalTransparencyModifier)
*
* Note, this property should be used on the client only and will not replicate to the server.
*
* For a variant of this property for [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s, see [BasePart.LocalTransparencyModifier](https://developer.roblox.com/en-us/api-reference/property/BasePart/LocalTransparencyModifier).
*
* Tags: Hidden, NotReplicated
*/
LocalTransparencyModifier: number;
/**
* This property dictates how shiny the decal is. It takes a value between 0 and 1, where 1 is “full shininess”.
*
* Tags: NotReplicated
* @deprecated
*/
Shiny: number;
/**
* Sets the specularity, which is how the surface responds to light being shined on it.
*
* Tags: NotReplicated
* @deprecated
*/
Specular: number;
/**
* The Content ID of the image to be applied by the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal).
*
* How can I upload a Decal?
* -------------------------
*
* Images can be uploaded to Roblox provided they adhere to the community guidelines. Information on how to upload images can be found [here](https://developer.roblox.com/en-us/articles/how-to-upload-a-decal).
*
* How to find do I find a Decal's Content ID?
* -------------------------------------------
*
* Unlike with [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound) and [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) objects, the Content ID of a Decal is not the same as the number in the URL. There are two main ways of finding the Content ID of a Decal:
*
* * Paste the URL into the Texture property in Roblox Studio. Roblox will automatically update the property to the correct Content ID. Note this only works in Roblox Studio and cannot be done from Scripts or whilst the game is running.
* * Insert the Decal into the game, this is generally done through the Toolbox under 'My Decals'. The Content ID can be found in the decal that is inserted. Note, [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) can also be used if developers wish to automate this method.
*/
Texture: string;
/**
* Determines the transparency of the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) with 0 being completely opaque and 1 completely transparent.
*
* Note, [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s also respect the transparency of the original image file uploaded to Roblox. This means transparency can be changed prior to uploading to Roblox, and without the need to use the Transparency property.
*
* [Decal.LocalTransparencyModifier](https://developer.roblox.com/en-us/api-reference/property/Decal/LocalTransparencyModifier) acts as a multiplier for the Decal's transparency and should be used when the transparency of the decal is likely to be changed by another script, as is the case with player Characters.
*
* For [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s, see [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency).
*/
Transparency: number;
/**
* **ZIndex** determines the order in which decals on the same `Decal/Face|Face` of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) are rendered. Decals are rendered in **ascending** priority order, where lower values are rendered first. Therefore, a decal with a higher ZIndex renders later (and on top of) other Decals with lower ZIndex.
*
* The range of valid values is -MAX\_INT to MAX\_INT, inclusive (2,147,483,647 or (2^31 - 1)). If you are unsure if you will need to layer an decal between two already-existing decals in the future, it can be a good idea to use multiples of 100, i.e. 0, 100, 200. This ensures a large gap of ZIndex values you can use for elements rendered in-between other elements.
*
* See also
* --------
*
* * [GuiObject.ZIndex](https://developer.roblox.com/en-us/api-reference/property/GuiObject/ZIndex), a property which behaves similarly, but for GUI elements
*/
ZIndex: number;
}
/** A Texture object applies a repeating texture to the face of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* How does a Texture work?
* ------------------------
*
* A Texture will apply an image to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) it is parented to. The surface this image is applied to is dependent on the [FaceInstance.Face](https://developer.roblox.com/en-us/api-reference/property/FaceInstance/Face) property. When the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is resized, the image will repeat. The size of the repeating textures is determined by the [Texture.StudsPerTileU](https://developer.roblox.com/en-us/api-reference/property/Texture/StudsPerTileU) and `StudsPerTileV` properties.
*
* local texture = Instance.new("Texture")
* texture.Texture = "http://www.roblox.com/asset/?id=732339893" -- roblox logo
* -- 1x1 studs repeating texture
* texture.StudsPerTileU = 1
* texture.StudsPerTileV = 1
*
* The image a Texture applies is determined by its [Decal.Texture](https://developer.roblox.com/en-us/api-reference/property/Decal/Texture) property. Images can be uploaded to Roblox provided they adhere to the community guidelines. Information on how to upload images can be found [here](https://developer.roblox.com/en-us/articles/how-to-upload-a-decal). -->
*
* What is the difference between Textures and Decals?
* ---------------------------------------------------
*
* The texture object is very similar to the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) object. However, whereas the image applied by a [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) scales when the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is resized, the image applied by a Texture repeats.
*
* Repeating textures have a wide range of applications such as floor tiles and wall textures.
*
* Alternatives to Textures
* ------------------------
*
* Although Decals have a wide variety of applications, in some cases developers may wish to pick one of the following classes instead.
*
* * For non repeating images [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) object should be used
* * To apply GUI elements, the [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) object should be used
* * If the effect of lighting on the image needs to be altered, the [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) object should be used
*/
interface Texture extends Decal {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Texture: unique symbol;
/**
* **OffsetStudsU** determines how far the rendered texture is offset on the horizontal axis in studs.
*
* Example
* -------
*
*  
*
* In the screenshots above, a Part with a Texture is visible. On the left, OffsetStudsU/OffsetStudsV are both 0, so the rendered texture tiling aligns with the top-left corner of the part. On the right, both properties are set to 1 which causes the tiling to start in the center of the texture.
*
* See Also
* --------
*
* * [OffsetStudsV](https://developer.roblox.com/en-us/api-reference/property/Texture/OffsetStudsV)
*/
OffsetStudsU: number;
/**
* **OffsetStudsV** determines how far the rendered texture is offset on the horizontal axis in studs.
*
* Example
* -------
*
*  
*
* In the screenshots above, a Part with a Texture is visible. On the left, OffsetStudsU/OffsetStudsV are both 0, so the rendered texture tiling aligns with the top-left corner of the part. On the right, both properties are set to 1 which causes the tiling to start in the center of the texture.
*
* See Also
* --------
*
* * [OffsetStudsU](https://developer.roblox.com/en-us/api-reference/property/Texture/OffsetStudsU)
*/
OffsetStudsV: number;
/**
* Sets the horizontal size, in studs, of the tiled image applied by the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture).
*
* Larger values for this property will lead to the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) appearing larger, and repeating less frequently. Unlike with [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s, the size of the repeated image is unaffected by the dimensions of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). Instead, resizing the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) only increases the number of times the texture repeats.
*
* See the code snippet below for an example of how this property can be used.
*
* local texture = Instance.new("Texture")
* texture.Texture = "http://www.roblox.com/asset/?id=732339893" -- roblox logo
* -- 1x1 studs repeating texture
* texture.StudsPerTileU = 1
* texture.StudsPerTileV = 1
*
* Notes
* -----
*
* * This property can be set to very low values, but not zero
* * The horisontal / vertical distinction is relative to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s axis. Therefore, the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) will rotate along with the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*/
StudsPerTileU: number;
/**
* Sets the vertical size, in studs, of the tiled image applied by the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture).
*
* Larger values for this property will lead to the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) appearing larger, and repeating less frequently. Unlike with [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s, the size of the repeated image is unaffected by the dimensions of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). Instead, resizing the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) only increases the number of times the texture repeats.
*
* See the code snippet below for an example of how this property can be used.
*
* local texture = Instance.new("Texture")
* texture.Texture = "http://www.roblox.com/asset/?id=732339893" -- roblox logo
* -- 1x1 studs repeating texture
* texture.StudsPerTileU = 1
* texture.StudsPerTileV = 1
*
* Notes
* -----
*
* * This property can be set to very low values, but not zero
* * The horisontal / vertical distinction is relative to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s axis. Therefore, the [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) will rotate along with the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*/
StudsPerTileV: number;
}
interface FacialAnimationRecordingService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FacialAnimationRecordingService: unique symbol;
}
interface FacialAnimationStreamingServiceStats extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FacialAnimationStreamingServiceStats: unique symbol;
}
interface FacialAnimationStreamingServiceV2 extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FacialAnimationStreamingServiceV2: unique symbol;
}
interface FacialAnimationStreamingSubsessionStats extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FacialAnimationStreamingSubsessionStats: unique symbol;
}
/** The base class for the legacy motor system. */
interface Feature extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Feature: unique symbol;
/**
* Sets what side of the Parent the object is on.
*/
FaceId: Enum.NormalId;
/**
* Controls how the Feature is positioned on it's parent's surface, in correspondence to the Feature's [Feature.LeftRight](https://developer.roblox.com/en-us/api-reference/property/Feature/LeftRight) and [Feature.TopBottom](https://developer.roblox.com/en-us/api-reference/property/Feature/TopBottom) properties.
*/
InOut: Enum.InOut;
/**
* Controls whether the feature is shifted to the left, center, or right on the surface.
*/
LeftRight: Enum.LeftRight;
/**
* Controls whether the feature is shifted to the top, center, or bottom on the surface.
*/
TopBottom: Enum.TopBottom;
}
/** A Hole is an unused type of surface joint. It can be connected to a [MotorFeature](https://developer.roblox.com/en-us/api-reference/class/MotorFeature) object by using a [VelocityMotor](https://developer.roblox.com/en-us/api-reference/class/VelocityMotor). */
interface Hole extends Feature {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Hole: unique symbol;
}
/** A MotorFeature is an unused type of surface joint. It can be connected to a [Hole](https://developer.roblox.com/en-us/api-reference/class/Hole) object by using a [VelocityMotor](https://developer.roblox.com/en-us/api-reference/class/VelocityMotor). */
interface MotorFeature extends Feature {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MotorFeature: unique symbol;
}
/**
*
* **Fire** is one of several premade particle-emitting classes. Like other particle emitting objects, a Fire emits particles when parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) and while [Enabled](https://developer.roblox.com/en-us/api-reference/property/Fire/Enabled). This object is useful to create a quick visual effect in a pinch; for more detailed work it is preferable to use a [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) instead.
*
* Fire particles emit from the center of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) to which they are parented. The particles are emit toward the top (+Y) direction; however, a negative [Fire.Heat](https://developer.roblox.com/en-us/api-reference/property/Fire/Heat) may be used to emit in the bottom (-Y) direction. Using an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) as a Parent instead allows the emission position/direction to be modified by changing the [Attachment.CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame) or related properties.
*
* When [Enabled](https://developer.roblox.com/en-us/api-reference/property/Fire/Enabled) is off, existing particles continue to render until they expire. However, if the Fire's [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is set to nil all existing particles immediately disappear, similar to the behavior of [ParticleEmitter:Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear). It is possible to set the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to nil and back to the exact original object to achieve the same effect. If immediate disappearance is not desired, try moving the Fire's parent to some far away position, then [Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) the Fire after a few seconds using [Debris:AddItem](https://developer.roblox.com/en-us/api-reference/function/Debris/AddItem). This will give the existing particles time to expire.
*
* Fire objects emit no light on their own. To help create a cohesive environment around a burning object, try adding a [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) with an orange [Color](https://developer.roblox.com/en-us/api-reference/property/Light/Color). This can help your fire appear more realistic.
*
*
*
* Fire object consist of two emitters. Both of these are affected in various ways by the Fire's [Size](https://developer.roblox.com/en-us/api-reference/property/Fire/Size), [Heat](https://developer.roblox.com/en-us/api-reference/property/Fire/Heat), [Color](https://developer.roblox.com/en-us/api-reference/property/Fire/Color) and [SecondaryColor](https://developer.roblox.com/en-us/api-reference/property/Fire/SecondaryColor). The particles emit from the smaller, secondary emitter have a significantly longer lifetime (and rise farther) than those emit by the primary emitter. In the video to the right, you can see the two emitters with the distinct colors.
*
* Unlike actual flames, the Fire object **does not spread on its own**. If you notice this behavior in your game, it is happening because of a [Script](https://developer.roblox.com/en-us/api-reference/class/Script).
*/
interface Fire extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Fire: unique symbol;
/**
* The Color property determines the color of the larger particles emit by a [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire) object. It is essentially the color of the outer portion of the flame. Below, you can see the Color of the flame is set to blue to differentiate with the smaller, inner particles which have [Fire.SecondaryColor](https://developer.roblox.com/en-us/api-reference/property/Fire/SecondaryColor) set to white.
*
* 
*
* In general, the cooler flames are on the outside of a fire. Therefore, fire looks more realistic if the outer portions are red or orange-yellow. A fire that is bright all throughout doesn't look very realistic, so avoid setting this property to yellow. Try adding a [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) with the `PointLight/Color` as a sibling to the [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire). This will provide light to the surrounding environment and make it feel more cohesive with the flame particles.
*/
Color: Color3;
/**
* The Enabled property, much like [ParticleEmitter.Enabled](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Enabled), determines whether flame particles are emit. Any particles already emit will continue to render until their lifetime expires. This property is useful for keeping pre-made fire effects off until they are needed later. Since flame particles are destroyed when the [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire) object's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is set to nil, this property is useful in allowing existing particles the opportunity to expire before destroying the Fire object altogether. See the function below.
*
* local Debris = game:GetService("Debris")
* local part = script.Parent
* function douseFlames(fire)
* fire.Enabled = false -- No more new particles
* Debris:AddItem(fire, 2) -- Remove the object after a delay (after existing particles have expired)
* end
* douseFlames(part.Fire)
*/
Enabled: boolean;
/**
* The Heat property determines how fast particles are emit from the [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire) object. It is limited to the range \[-25, 25\]. Positive values are in the top (+Y) direction of the parent [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment). It also affects the [ParticleEmitter.Acceleration](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Acceleration) of the inner particles. Below, you can see the effects of higher heat on the velocity/acceleration of the flame particles (left has Heat = 9, right has Heat = 18).
*
* 
*
* Tags: NotReplicated
*/
Heat: number;
/**
* The SecondaryColor property determines the color of the smaller particles emit by a [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire) object. It is essentially the color of the inner portion of the flame. Below, you can see the SecondaryColor of the flame is set to white to differentiate with the larger, outer particles which have [Fire.Color](https://developer.roblox.com/en-us/api-reference/property/Fire/Color) set to blue. It should be noted that the inner particles use a [ParticleEmitter.LightEmission](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightEmission) of 1, so darker colors will instead cause the particles to appear transparent (and therefore black will stop rendering inner particles altogether).
*
* 
*/
SecondaryColor: Color3;
/**
* This property determines the size of the flame particles. It must be in the range of \[2, 30\]. Unlike [ParticleEmitter.Size](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Size), the actual size of the flames will not match 1-to-1 with the equivalent size in studs; it is somewhat smaller.
*
* 
*
* To make your environment more cohesive, try adding a [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) as a sibling to the [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire) object. Set the `PointLight/Brightness` and [PointLight.Range](https://developer.roblox.com/en-us/api-reference/property/PointLight/Range) proportional to this property so that larger flames produce more light.
*
* Tags: NotReplicated
*/
Size: number;
TimeScale: number;
}
/** An instance representing a 1D float curve encoded via a sorted list of [FloatCurveKeys](https://developer.roblox.com/en-us/api-reference/datatype/FloatCurveKey).
*
* [FloatCurveKeys](https://developer.roblox.com/en-us/api-reference/datatype/FloatCurveKey) are value-time points that represent the changes in value over time. The changes of a single value over time are represented by a curve. Animators can edit keys to modify a curve. The shape of the curve is dictated by the [KeyInterpolationMode](https://developer.roblox.com/en-us/api-reference/enum/KeyInterpolationMode) chosen at each key.
*/
interface FloatCurve extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FloatCurve: unique symbol;
/**
* Number of keys in the float curve.
*
* Tags: NotReplicated
*/
readonly Length: number;
/**
* Returns a copy of a key at a given index.
*/
GetKeyAtIndex(this: FloatCurve, index: number): FloatCurveKey;
/**
* The first returned value is the index of the last key with key.time <= time (or min(1,length) if no key was found). The second returned value is the index of the first key with key.time >= time or the length of the curve if no key was found satisfying the inequality.
*/
GetKeyIndicesAtTime(this: FloatCurve, time: number): unknown;
/**
* Returns a copy of all the keys in the FloatCurve as a Lua array of FloatCurveKey.
*/
GetKeys(this: FloatCurve): unknown;
/**
* Samples the float curve at a given time passed as argument.
*/
GetValueAtTime(this: FloatCurve, time: number): number | undefined;
/**
* Adds the key passed as argument to this curve. If a key exists at the same time it will be replaced. First return value is true if a key was added, false if a previous key was replaced. Second return value is the index at which the marker was added.
*/
InsertKey(this: FloatCurve, key: FloatCurveKey): unknown;
/**
* Removes a given number of Keys starting from a given index. Returns the number of keys that were removed.
*/
RemoveKeyAtIndex(this: FloatCurve, startingIndex: number, count?: number): number;
/**
* Resets this curve's keys using the FloatCurveKey array passed as argument. Keys in the keysArray are sorted in ascending time order before insertion. Keys at duplicated times are removed in a stable manner. Returns the number of keys actually inserted.
*
* Keys previously stored in this curve are removed before the keys passed as arguments are added.
*/
SetKeys(this: FloatCurve, keys: Array): number;
}
/** A simple container used to hold and organize Roblox objects. Unlike other container classes like [Model](https://developer.roblox.com/en-us/api-reference/class/Model), it offers no additional functionality.
*
* The Folder object is ideal for organizing and storing objects. It is not recommended to use folders to group [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s as [Model](https://developer.roblox.com/en-us/api-reference/class/Model)s offer a range of useful functions for moving and manipulating the parts.
*
* Folders form part of the game's hierarchy and can be accessed the same way as any object. For example:
*
* local folder = game:GetService("ReplicatedStorage"):FindFirstChild("Folder")
* local subFolder = folder:FindFirstChild("Folder")
*
* Folders behave the same way as folders in a computer file system, meaning they can also be parented to each other. They exist as a means for developers to better organize the multitude of objects required by complex games. See below for a simple example of how folders can be used to organize game objects in [ReplicatedStorage](https://developer.roblox.com/en-us/api-reference/class/ReplicatedStorage).
*
* 
*/
interface Folder extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Folder: unique symbol;
}
/** A [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) protects a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) from taking damage using the [Humanoid:TakeDamage](https://developer.roblox.com/en-us/api-reference/function/Humanoid/TakeDamage) function, and protects [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s from having their joints broken due to an [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion).
*
* ForceField Creation
* -------------------
*
* ForceFields are created when a character spawns on a [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) and the [SpawnLocation.Duration](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Duration) property is greater than zero.
*
* ForeFields influence the instance they are parented to. When parented to a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) they will protect all of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s descending from that model. They may be parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), but the part's joints will only be protected if both the part and the part it is connected to also contain ForceField.
*
* Forcefields and Joints
* ----------------------
*
* When a ForceField is parented to a character [Model](https://developer.roblox.com/en-us/api-reference/class/Model) the neck joint will be protected and thus the character can not be killed by `Explosions`. Developers can protect joints from Explosions without the need for a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) object by setting [Explosion.DestroyJointRadiusPercent](https://developer.roblox.com/en-us/api-reference/property/Explosion/DestroyJointRadiusPercent) to 0.
*
* **ForceFields and Damage**
*
* ForceFields only protect [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s from damage using the [Humanoid:TakeDamage](https://developer.roblox.com/en-us/api-reference/function/Humanoid/TakeDamage) function. Humanoids can still be damaged by setting [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) directly. For this reason, it is advised that developers use [Humanoid:TakeDamage](https://developer.roblox.com/en-us/api-reference/function/Humanoid/TakeDamage). Bearing in mind of course, that it is still possible to check if a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) exists before manually setting the humanoid's health as shown below:
*
* ```lua
* if not characterModel:FindFirstChildOfClass("ForceField") then
* humanoid.Health = humanoid.Health - 10
* end
* ```
*
* ForceField Visuals
* ------------------
*
* When [ForceField.Visible](https://developer.roblox.com/en-us/api-reference/property/ForceField/Visible) is set to true, a particle effect is created. A number of rules determine where this effect will be emitted from.
*
* When parented to a [Model](https://developer.roblox.com/en-us/api-reference/class/Model), if the model includes a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) named “Humanoid” with [Humanoid.RigType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RigType) set to R15, the effect will be emitted from the part named “UpperTorso”. Otherwise, the effect will be emitted from the part named “Torso”. The part must have the same parent as the ForceField, if it does not exist then the effect is emitted at 0, 0, 0.
*
* When parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) the effect will be emitted from the part's [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position).
*/
interface ForceField extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ForceField: unique symbol;
/**
* Determines whether or not the [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField)'s particle effect is visible.
*
* When is set to true, a particle effect is created, a number of rules determine where this effect will be emitted from.
*
* When parented to a [Model](https://developer.roblox.com/en-us/api-reference/class/Model), if the model includes a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) named “Humanoiod” with [Humanoid.RigType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RigType) set to R15, the effect will be emitted from the part named “UpperTorso”. Otherwise, the effect will be emitted from the part named “Torso”. The part must have the same parent as the ForceField, if it does not exist then the effect is emitted at 0, 0, 0.
*
* When parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) the effect will be emitted from the part's [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position).
*
* One use for this property is replacing the default particle effect with a custom effect using [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s.
*/
Visible: boolean;
}
/** The GamePassService is a service that supports legacy game passes using _Asset IDs_. [MarketplaceService](https://developer.roblox.com/en-us/api-reference/class/MarketplaceService) should be used for all new game passes.
*
* For more information about game passes, please see [this article](https://developer.roblox.com/articles/Game-Passes-One-Time-Purchases).
*
* Legacy Game Passes
* ------------------
*
* Historically, game passes on Roblox had an _Asset ID_ associated with them. Although game passes created with an _Asset ID_ still have an _Asset ID_, they now also have a _Game Pass ID_. All new game passes created today **only** have a _Game Pass ID_.
*
* You can retrieve the _Game Pass ID_ of any pass through its URL, for example the _Game Pass ID_ of the below pass is 1:
*
* > [https://www.roblox.com/game-pass/1/myGamePass](https://www.roblox.com/game-pass/1/myGamePass)
*
* Whether you are using an _Asset ID_ or a _Game Pass ID_ determines which API members you can use.
*
* Works with _Asset ID_ (Legacy)
*
* Works with _Game Pass ID_ (Current)
*
* Verify Ownership
*
* [GamePassService:
* PlayerHasPass](https://developer.roblox.com/api-reference/function/GamePassService/PlayerHasPass)
*
* [MarketplaceService:
* UserOwnsGamePassAsync](https://developer.roblox.com/api-reference/function/MarketplaceService/UserOwnsGamePassAsync)
*
* Prompt a purchase
*
* [MarketplaceService:
* PromptPurchase](https://developer.roblox.com/api-reference/function/MarketplaceService/PromptPurchase)
*
* [MarketplaceService:
* PromptGamePassPurchase](https://developer.roblox.com/api-reference/function/MarketplaceService/PromptGamePassPurchase)
*
* Prompted purchase finished
*
* [MarketplaceService.
* PromptPurchaseFinished](https://developer.roblox.com/api-reference/event/MarketplaceService/PromptPurchaseFinished)
*
* [MarketplaceService.
* PromptGamePassPurchaseFinished](https://developer.roblox.com/api-reference/event/MarketplaceService/PromptGamePassPurchaseFinished)
*
* API members that work with _Asset IDs_ **will not** work with new game passes as they do not have them.
*/
interface GamePassService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GamePassService: unique symbol;
/**
* This function will not work with new game passes, use \`MarketplaceService/UserOwnsGamePassAsync\` instead.
*
* This function returns _true_ if the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) has the specified legacy game pass.
*
* The result of this function may be cached, meaning it should not be relied on to give an up to date result.
*
* For more information about game passes, please see \[this article\]\[1\].
*
* Legacy Game Passes
* ------------------
*
* Historically, game passes on Roblox had an _Asset ID_ associated with them. Although game passes created with an _Asset ID_ still have an _Asset ID_, they now also have a _Game Pass ID_. All new game passes created today **only** have a _Game Pass ID_.
*
* You can retrieve the _Game Pass ID_ of any pass through its URL, for example the _Game Pass ID_ of the below pass is 1:
*
* https://www.roblox.com/game-pass/1/myGamePass
*
* Whether you are using an _Asset ID_ or a _Game Pass ID_ determines which API members you can use.
*
* Works with _Asset ID_ (Legacy)
*
* Works with _Game Pass ID_ (Current)
*
* Verify Ownership
*
* [GamePassService:
* PlayerHasPass](https://developer.roblox.com/api-reference/function/GamePassService/PlayerHasPass)
*
* [MarketplaceService:
* UserOwnsGamePassAsync](https://developer.roblox.com/api-reference/function/MarketplaceService/UserOwnsGamePassAsync)
*
* Prompt a purchase
*
* [MarketplaceService:
* PromptPurchase](https://developer.roblox.com/api-reference/function/MarketplaceService/PromptPurchase)
*
* [MarketplaceService:
* PromptGamePassPurchase](https://developer.roblox.com/api-reference/function/MarketplaceService/PromptGamePassPurchase)
*
* Prompted purchase finished
*
* [MarketplaceService.
* PromptPurchaseFinished](https://developer.roblox.com/api-reference/event/MarketplaceService/PromptPurchaseFinished)
*
* [MarketplaceService.
* PromptGamePassPurchaseFinished](https://developer.roblox.com/api-reference/event/MarketplaceService/PromptGamePassPurchaseFinished)
*
* API members that work with _Asset IDs_ **will not** work with new game passes as they do not have them.
*
* Tags: Yields
* @deprecated
*/
PlayerHasPass(this: GamePassService, player: Player, gamePassId: number): boolean;
}
/** The GamepadService is internally responsible for handling inputs from various controllers (such as an Xbox One controller) */
interface GamepadService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GamepadService: unique symbol;
readonly GamepadCursorEnabled: boolean;
DisableGamepadCursor(this: GamepadService): void;
EnableGamepadCursor(this: GamepadService, guiObject: GuiObject | undefined): void;
}
interface GeometryService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GeometryService: unique symbol;
CalculateConstraintsToPreserve(this: GeometryService, source: Instance, destination: Array, options?: object): unknown;
/**
* Tags: Yields
*/
IntersectAsync(this: GeometryService, part: BasePart, parts: Array, options?: object): unknown;
/**
* Tags: Yields
*/
SubtractAsync(this: GeometryService, part: BasePart, parts: Array, options?: object): unknown;
/**
* Tags: Yields
*/
UnionAsync(this: GeometryService, part: BasePart, parts: Array, options?: object): unknown;
}
interface GetTextBoundsParams extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GetTextBoundsParams: unique symbol;
Font: Font;
Size: number;
Text: string;
Width: number;
}
/** A **GlobalDataStore** exposes functions for saving and loading data for the [DataStoreService](https://developer.roblox.com/en-us/api-reference/class/DataStoreService).
*
* See the [Data Stores](https://developer.roblox.com/en-us/articles/data-store) article for an in-depth guide on data structure, management, error handling, etc.
*/
interface GlobalDataStore extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GlobalDataStore: unique symbol;
/**
* This function sets **callback** as the function to be run any time the value associated with the [data store's](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) key changes. Once every minute, OnUpdate polls for changes by other servers. Changes made on the same server will run the function immediately. In other words, functions like [IncrementAsync()](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/IncrementAsync), [SetAsync()](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync), and [UpdateAsync()](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) change the key's value in the data store and will cause the function to run.
*
* See the [Data Stores](https://developer.roblox.com/en-us/articles/data-store) article for an in-depth guide on data structure, management, error handling, etc.
*
* It's recommended that you **disconnect** the connection when the subscription to the key is no longer needed.
* @deprecated
*/
OnUpdate(this: GlobalDataStore, key: string, callback: Callback): RBXScriptConnection;
/**
* This function returns the latest value of the provided key and a [DataStoreKeyInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyInfo) instance. If the key does not exist or if the latest version has been marked as deleted, both return values will be `nil`.
*
* [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) does not support versioning and metadata, so [DataStoreKeyInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyInfo) will always be `nil` for keys in an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore).
*
* Keys are cached locally for 4 seconds after the first read. A [GlobalDataStore:GetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/GetAsync) call within these 4 seconds returns a value from the cache. Modifications to the key by [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) or [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) apply to the cache immediately and restart the 4 second timer.
*
* To get a specific version, such as a version before the latest, use [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
readonly GetAsync: unknown;
/**
* This function increments the value of a key by the provided amount (both must be integers).
*
* [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) does not support versioning, so calling this method on an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) key will overwrite the current value with the incremented value and make previous versions inaccessible.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
readonly IncrementAsync: unknown;
/**
* This function marks the specified key as deleted by creating a new “tombstone” version of the key. Prior to this, it returns the latest version prior to the remove call.
*
* After a key is removed via this function, [GlobalDataStore:GetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/GetAsync) calls for the key will return `nil`. Older versions of the key remain accessible through [DataStore:ListVersionsAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListVersionsAsync) and [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync), assuming they have not expired.
*
* [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) does not support versioning, so calling [RemoveAsync()](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/RemoveAsync) on an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) key will permanently delete it.
*
* Removed objects will be deleted permanently after 30 days.
*
* If the previous values were already deleted via [GlobalDataStore:RemoveAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/RemoveAsync) or [DataStore:RemoveVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/RemoveVersionAsync), the function will return `nil`, `nil` for value and [DataStoreKeyInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyInfo) respectively.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
readonly RemoveAsync: unknown;
/**
* This function sets the latest value, [UserIds](https://developer.roblox.com/en-us/api-reference/property/Player/UserId), and metadata for the given key.
*
* Values in data stores are versioned, meaning [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) will create a new version every time it is called. Prior versions can be accessed through [DataStore:ListVersionsAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListVersionsAsync)/[DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync) for up to 30 days at which point they are permanently deleted.
*
* [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) does not support versioning, so calling this method on an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) key will overwrite the current value and make previous versions inaccessible.
*
* Metadata definitions must always be updated with a value, even if there are no changes to the current value; otherwise the current value will be lost.
*
* Any string being stored in a data store must be valid [UTF-8](https://developer.roblox.com/en-us/api-reference/class/Articles/Lua Libraries/utf8). In UTF-8, values greater than 127 are used exclusively for encoding multi-byte codepoints, so a single byte greater than 127 will not be valid UTF-8 and the [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) attempt will fail.
*
* ##### Set vs. Update
*
* [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) is best for a quick update of a specific key, and it only counts against the write limit. However, it may cause data inconsistency if two servers attempt to set the same key at the same time.
*
* [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) is safer for handling multi-server attempts because it reads the current key value (from whatever server last updated it) before making any changes. However, it's somewhat slower because it reads before it writes, and it also counts against both the read and write limit.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
readonly SetAsync: unknown;
/**
* This function retrieves the value and metadata of a key from the data store and updates it with a new value determined by the callback function specified through the second parameter.
*
* If the update succeeds, a new version of the value will be created and prior versions will remain accessible through [DataStore:ListVersionsAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListVersionsAsync) and [DataStore:GetVersionAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/GetVersionAsync).
*
* [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) does not support versioning, so calling this function on an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore) key will overwrite the current value and make previous versions inaccessible.
*
* In cases where another game server updated the key in the short timespan between retrieving the key's current value and setting the key's value, [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) will call the function again to ensure that no data is overwritten. The function will be called as many times as needed until the data is saved **or** until the callback function returns `nil`.
*
* Any string being stored in a data store must be valid [UTF-8](https://developer.roblox.com/en-us/api-reference/class/Articles/Lua Libraries/utf8). In UTF-8, values greater than 127 are used exclusively for encoding multi-byte codepoints, so a single byte greater than 127 will not be valid UTF-8 and the [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) attempt will fail.
*
* ##### Set vs. Update
*
* [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync) is best for a quick update of a specific key, and it only counts against the write limit. However, it may cause data inconsistency if two servers attempt to set the same key at the same time.
*
* [GlobalDataStore:UpdateAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/UpdateAsync) is safer for handling multi-server attempts because it reads the current key value (from whatever server last updated it) before making any changes. However, it's somewhat slower because it reads before it writes, and it also counts against both the read and write limit.
*
* Callback Function
* -----------------
*
* The callback function accepts two arguments:
*
* * Current value of the key prior to the update.
* * [DataStoreKeyInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyInfo) instance that contains the latest version information (this argument can be ignored if metadata is not being used).
*
* In turn, the callback function returns up to three values:
*
* * The new value to set for the key.
* * An array of [UserIds](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) to associate with the key. [DataStoreKeyInfo:GetUserIds](https://developer.roblox.com/en-us/api-reference/function/DataStoreKeyInfo/GetUserIds) should be returned unless the existing IDs are being changed; otherwise all existing IDs will be cleared.
* * A Lua table containing metadata to associate with the key. [DataStoreKeyInfo:GetMetadata](https://developer.roblox.com/en-us/api-reference/function/DataStoreKeyInfo/GetMetadata) should be returned unless the existing metadata is being changed; otherwise all existing metadata will be cleared.
*
* The callback function cannot yield, so do **not** include calls like `wait()`.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
readonly UpdateAsync: unknown;
}
interface DataStore extends GlobalDataStore {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStore: unique symbol;
GetAsync(
this: DataStore,
key: string,
options?: DataStoreGetOptions,
): LuaTuple<[T | undefined, DataStoreKeyInfo]>;
IncrementAsync(
this: DataStore,
key: string,
delta?: number,
userIds?: Array,
options?: DataStoreIncrementOptions,
): LuaTuple<[number, DataStoreKeyInfo]>;
SetAsync(
this: DataStore,
key: string,
value?: unknown,
userIds?: Array,
options?: DataStoreSetOptions,
): string;
UpdateAsync(
this: DataStore,
key: string,
transformFunction: (
oldValue: O | undefined,
keyInfo: DataStoreKeyInfo | undefined,
) => LuaTuple<[newValue: R | undefined, userIds?: Array, metadata?: object]>,
): LuaTuple<[newValue: R | undefined, keyInfo: DataStoreKeyInfo]>;
RemoveAsync(this: DataStore, key: string): LuaTuple<[T | undefined, DataStoreKeyInfo | undefined]>;
/**
* This function retrieves the specified key version as well as a [DataStoreKeyInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyInfo) instance. A version identifier can be found through [DataStore:ListVersionsAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListVersionsAsync) or alternatively be the identifier returned by [GlobalDataStore:SetAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/SetAsync).
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
GetVersionAsync(
this: DataStore,
key: string,
version: string,
): LuaTuple<[value: unknown, keyInfo: DataStoreKeyInfo]>;
/**
* This function returns a [DataStoreKeyPages](https://developer.roblox.com/en-us/api-reference/class/DataStoreKeyPages) object for enumerating through keys of a data store. It accepts an optional `prefix` parameter to only locate keys whose names start with the provided prefix.
*
* If [DataStoreOptions.AllScopes](https://developer.roblox.com/en-us/api-reference/property/DataStoreOptions/AllScopes) was set to true when accessing the data store through [DataStoreService:GetDataStore](https://developer.roblox.com/en-us/api-reference/function/DataStoreService/GetDataStore), keys will be returned with all scopes as prefixes.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
ListKeysAsync(this: DataStore, prefix?: string, pageSize?: number, cursor?: string, excludeDeleted?: boolean): DataStoreKeyPages;
/**
* This function enumerates versions of the specified key in either ascending or descending order specified by a [SortDirection](https://developer.roblox.com/en-us/api-reference/enum/SortDirection) parameter. It can optionally filter the returned versions by minimum and maximum timestamp.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, and more.
*
* Tags: Yields
*/
ListVersionsAsync(this: DataStore, key: string, sortDirection?: CastsToEnum, minDate?: number, maxDate?: number, pageSize?: number): DataStoreVersionPages;
/**
* This function permanently deletes the specified version of a key. Version identifiers can be found through [DataStore:ListVersionsAsync](https://developer.roblox.com/en-us/api-reference/function/DataStore/ListVersionsAsync).
*
* Unlike [GlobalDataStore:RemoveAsync](https://developer.roblox.com/en-us/api-reference/function/GlobalDataStore/RemoveAsync), this function does not create a new “tombstone” version and the removed value cannot be retrieved later.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*
* Tags: Yields
*/
RemoveVersionAsync(this: DataStore, key: string, version: string): void;
}
/** A **OrderedDataStore** is essentially a [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) with the exception that stored values must be **positive integers**. It exposes a method [GetSortedAsync()](https://developer.roblox.com/en-us/api-reference/function/OrderedDataStore/GetSortedAsync) which allows inspection of the entries in sorted order using a [DataStorePages](https://developer.roblox.com/en-us/api-reference/class/DataStorePages) object.
*
* See the [Data Stores](https://developer.roblox.com/en-us/articles/data-store) article for an overview on using ordered data stores.
*/
interface OrderedDataStore extends GlobalDataStore {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OrderedDataStore: unique symbol;
GetAsync(this: OrderedDataStore, key: string): number | undefined;
IncrementAsync(this: OrderedDataStore, key: string, delta?: number): number;
RemoveAsync(this: OrderedDataStore, key: string): number | undefined;
SetAsync(this: OrderedDataStore, key: string, value?: unknown): void;
UpdateAsync(
this: OrderedDataStore,
key: string,
transformFunction: (oldValue: number | undefined) => number | undefined,
): number | undefined;
/**
* Returns a [DataStorePages](https://developer.roblox.com/en-us/api-reference/class/DataStorePages) object. The sort order is determined by **ascending**, the length of each page by **pageSize**, and **minValue** /**maxValue** are optional parameters which filter the results.
*
* If this function throws an error, the [error message](https://developer.roblox.com/en-us/articles/datastore-errors) will describe the problem.
*
* Tags: Yields
*/
GetSortedAsync(
this: OrderedDataStore,
ascending: boolean,
pagesize: number,
minValue?: number,
maxValue?: number,
): DataStorePages;
}
/** GroupService is a service that allows developers to fetch information about a Roblox group from within a game.
*
* Basic information on the group, including it's name, description, owner, roles and emblem can be fetched using [GroupService:GetGroupInfoAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetGroupInfoAsync). Lists of a group's allies and enemies can be fetched using [GroupService:GetAlliesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetAlliesAsync) and [GroupService:GetEnemiesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetEnemiesAsync).
*
* GroupService can also be used to fetch a list of group's a player is a member of, using [GroupService:GetGroupsAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetGroupsAsync). Note, developers wishing to verify if a player is in a group should use the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) [Player:IsInGroup](https://developer.roblox.com/en-us/api-reference/function/Player/IsInGroup) function rather than [GroupService:GetGroupsAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetGroupsAsync).
*
* The service has a number of useful applications, such as detecting if a player is an ally or enemy upon joining the game.
*/
interface GroupService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GroupService: unique symbol;
/**
* Returns a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object including information on all of the specified group's allies.
*
* This pages does not include a list of group IDs but instead a list of group information tables, mirroring the format of those returned by [GroupService:GetGroupInfoAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetGroupInfoAsync). See below for the structure of these tables.
*
* ```lua
* group = {
* Name = "Knights of the Seventh Sanctum",
* Id = 377251,
* Owner = {
* Name = "Vilicus",
* Id = 23415609
* },
* EmblemUrl = "http://www.roblox.com/asset/?id=60428602",
* Description = "We fight alongside the balance to make sure no one becomes to powerful",
* Roles = {
* [1] = {
* Name = "Apprentice",
* Rank = 1
* },
* [2] = {
* Name = "Warrior",
* Rank = 2
* },
* [3] = {
* Name = "Earth Walker",
* Rank = 255
* }
* }
* }
* ```
*
* Note, as this function returns a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object rather than an array, developers may wish to convert it to an array for ease of use (see examples).
*
* This function has a number of useful applications, including detecting if a player is a member of an allied group.
*
* For enemies, use [GroupService:GetEnemiesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetEnemiesAsync).
*
* Tags: Yields
*/
GetAlliesAsync(this: GroupService, groupId: number): StandardPages;
/**
* Returns a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object including information on all of the specified group's enemies.
*
* This pages does not include a list of group IDs but instead a list of group information tables, mirroring the format of those returned by [GroupService:GetGroupInfoAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetGroupInfoAsync). See below for the structure of these tables.
*
* ```lua
* group = {
* Name = "Knights of the Seventh Sanctum",
* Id = 377251,
* Owner = {
* Name = "Vilicus",
* Id = 23415609
* },
* EmblemUrl = "http://www.roblox.com/asset/?id=60428602",
* Description = "We fight alongside the balance to make sure no one becomes to powerful",
* Roles = {
* [1] = {
* Name = "Apprentice",
* Rank = 1
* },
* [2] = {
* Name = "Warrior",
* Rank = 2
* },
* [3] = {
* Name = "Earth Walker",
* Rank = 255
* }
* }
* }
* ```
*
* Note, as this function returns a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object rather than an array, developers may wish to convert it to an array for ease of use (see examples).
*
* This function has a number of useful applications, including detecting if a player is a member of an enemy group.
*
* For allies, use [GroupService:GetAlliesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetAlliesAsync).
*
* Tags: Yields
*/
GetEnemiesAsync(this: GroupService, groupId: number): StandardPages;
/**
* Returns a table containing information about the given group.
*
* The table returned is the same format as that returned in [GroupService:GetAlliesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetAlliesAsync) and [GroupService:GetEnemiesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetEnemiesAsync). This format can be seen below.
*
* ```lua
* group = {
* Name = "Knights of the Seventh Sanctum",
* Id = 377251,
* Owner = {
* Name = "Vilicus",
* Id = 23415609
* },
* EmblemUrl = "http://www.roblox.com/asset/?id=60428602",
* Description = "We fight alongside the balance to make sure no one becomes to powerful",
* Roles = {
* [1] = {
* Name = "Apprentice",
* Rank = 1
* },
* [2] = {
* Name = "Warrior",
* Rank = 2
* },
* [3] = {
* Name = "Earth Walker",
* Rank = 255
* }
* }
* }
* ```
*
* Note, if a group has no owner the Owner field will be set to nil.
*
* This function has a number of useful applications, including loading the latest description and logo of a group for display in a group base.
*
* Tags: Yields
*/
GetGroupInfoAsync(this: GroupService, groupId: number): GroupInfo;
/**
* **Warning**
*
* The **IsInClan** property in the returned table will always return **false** and exists for backwards compatibility. The Clans feature was sunset from the Roblox platform in 2016.
*
* This function returns a list of tables containing information on all of the groups a given [Player](https://developer.roblox.com/en-us/api-reference/class/Player) is a member of.
*
* The list returned will include an entry for every group the player is a member of. These entries are tables with the following fields.
*
* Name
*
* Description
*
* ### Name
*
* The group's name
*
* ### Id
*
* The group ID
*
* ### EmblemUrl
*
* An asset url linking to the group's thumbnail (for example: http://www.roblox.com/asset/?id=276165514)
*
* ### EmblemId
*
* The assetId of the emblem, the same which is used in the EmblemUrl
*
* ### Rank
*
* The rankId the player has (for example: 255 for the owner)
*
* ### Role
*
* The name of the player's grouprank (for example: Group Owner)
*
* ### IsPrimary
*
* A boolean indicating if this is the player's primary group
*
* ### IsInClan
*
* A boolean indicating if the player is in this group's clan
*
* Note unlike [GroupService:GetAlliesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetAlliesAsync) and [GroupService:GetEnemiesAsync](https://developer.roblox.com/en-us/api-reference/function/GroupService/GetEnemiesAsync), GetGroupsAsync returns a table rather than a [StandardPages](https://developer.roblox.com/en-us/api-reference/class/StandardPages) object.
*
* Tags: Yields
*/
GetGroupsAsync(this: GroupService, userId: number): Array;
}
/** GuiBase is an abstract class which most graphical user interface objects inherit from. */
interface GuiBase extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiBase: unique symbol;
}
/** GuiBase2d is an abstract class inherited by 2D GUI Objects. */
interface GuiBase2d extends GuiBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiBase2d: unique symbol;
/**
* AbsolutePosition is a read-only property that provides the screen position of a UI element in pixels. This represents the actual pixel position at which an element renders as a result of its ancestors' sizes and positions. The [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) also influences the AbsolutePosition. This property, [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) and [GuiBase2d.AbsoluteRotation](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteRotation) are a group of properties that all describe the final rendered orientation of a UI element.
*
* For example, on a 1920 by 1080 screen, a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) with position {0.5, 0}, {0.5, 0} would have an AbsolutePosition of (960, 540). If you were to place another Frame with position {0, 50}, {0, 50} inside that one, its AbsolutePosition would be (1010, 590). This example assumes each Frame has the defualt [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) of (0, 0), the top left corner.
*
* Tags: NotReplicated
*/
readonly AbsolutePosition: Vector2;
/**
* AbsoluteRotation is a read-only property that describes the actual screen rotation of a UI element, in degrees. This property, [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) and [GuiBase2d.AbsolutePosition](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsolutePosition) are a group of properties that all describe the final rendered orientation of a UI element. It composes (sums) each of the UI element's ancestors' [GuiObject.Rotation](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Rotation) into one value. It does **not** perform bounds checking, so its value may not be in the range 0 ≤ x < 360 degrees.
*
* For example, if FrameA has a rotation of 40 degrees, and FrameB within it has a [GuiObject.Rotation](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Rotation) of 50 degrees, then FrameB's AbsoluteRotation would be 90 degrees.
*
* Tags: NotReplicated
*/
readonly AbsoluteRotation: number;
/**
* AbsoluteSize is a read-only property that provides the screen size of a UI element in pixels. This represents the actual pixel size at which an element renders as a result of its ancestors' sizes. This property, [GuiBase2d.AbsolutePosition](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsolutePosition) and [GuiBase2d.AbsoluteRotation](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteRotation) are a group of properties that all describe the final rendered orientation of a UI element.
*
* For example, on a 1920 by 1080 screen, if FrameA exists within FrameB, and they both have a Size of {.5, 0}, {.5, 0}, then the AbsoluteSize of FrameA (the inner frame) would be (490, 270) as the [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) property determines the size of a child UI element relative to its parent. Both of the frames are set to 50% of the parent size. Since 50% of 50% is 25%, and 25% of our screen size, 1920 by 1080, is (490, 270), this would be the resultant AbsoluteSize of the inner frame.
*
* Tags: NotReplicated
*/
readonly AbsoluteSize: Vector2;
/**
* When set to true, localization will be applied to this GuiBase2d and its descendants based on the [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable) specified for this GuiBase2d.
*/
AutoLocalize: boolean;
/**
* This property is automatically set to true when a LocalizationTable's Root targets this object, or an ancestor of this object. `LocalizationTable/LocalizationTable`s, with their [LocalizationTable.Root](https://developer.roblox.com/en-us/api-reference/property/LocalizationTable/Root) property pointed at an instance, will localize all `TextLabel/TextButton` that are descendants of the root instance.
*
* Tags: Hidden, NotReplicated
* @deprecated Use `AutoLocalize` instead
*/
Localize: boolean;
/**
* A reference to a [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) to be used to apply automated localization to this GuiBase2d and its descendants.
*
*
* The \`GuiBase2d/AutoLocalize\` property must be set to true on this object and its ancestors for automated localization to be applied.
*
* You can set this to reference a LocalizationTable anywhere in the DataModel. It is not required to be a child of LocalizationService.
*
* When RootLocalizationTable is set on a GUI object then that object and all of its children will use that specific LocalizationTable and its parents for automatic text replacement, instead of using the tables under LocalizationService in an undefined order.
*
* If there is no translation available in the referenced table it will look for a translation in the parent of that table, if it is also a LocalizationTable, and so on.
*/
RootLocalizationTable: LocalizationTable | undefined;
SelectionBehaviorDown: Enum.SelectionBehavior;
SelectionBehaviorLeft: Enum.SelectionBehavior;
SelectionBehaviorRight: Enum.SelectionBehavior;
SelectionBehaviorUp: Enum.SelectionBehavior;
SelectionGroup: boolean;
readonly SelectionChanged: RBXScriptSignal<(amISelected: boolean, previousSelection: GuiObject, newSelection: GuiObject) => void>;
}
/** GuiObject is an abstract class (much like [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)) for a 2D user interface object. It defines all the properties relating to the display of a graphical user interface (GUI) object such as [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) and [GuiObject.Position](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Position). It also has some useful read-only properties like `GuiObject/AbsolutePosition`, `GuiObject/AbsoluteSize`, and `GuiObject/AbsoluteRotation`. It should be noted that [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) can have negative sizes and render normally, though [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) ought to be used to better control rendering.
*
* To manipulate the layout of a GuiObject in special ways, you can use a [UIComponent](https://developer.roblox.com/en-us/api-reference/class/UIComponent) class such as [UIListLayout](https://developer.roblox.com/en-us/api-reference/class/UIListLayout), [UIPadding](https://developer.roblox.com/en-us/api-reference/class/UIPadding) or [UIScale](https://developer.roblox.com/en-us/api-reference/class/UIScale).
*
* This class defines very simple animation methods: [GuiObject:TweenPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenPosition), [GuiObject:TweenSize](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSize) and [GuiObject:TweenSizeAndPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSizeAndPosition) are good alternatives to [TweenService](https://developer.roblox.com/en-us/api-reference/class/TweenService) for beginners.
*
* GuiObject also defines events for user input like [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter), [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap), [GuiObject.InputBegan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputBegan), [GuiObject.InputChanged](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputChanged) and [GuiObject.InputEnded](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputEnded). The last three of these mimic the events of `UserinputService` of the same name. Although it is possible to detect mouse button events on any GuiObject using [GuiObject.InputBegan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputBegan), only [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) and [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton) have dedicated events for these (e.g. `TextButton/MouseButton1Down`). This event ought not be used for general button activation since not all platforms use a mouse; see `TextButton/Activated`.
*/
interface GuiObject extends GuiBase2d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiObject: unique symbol;
/**
* This property determines whether a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) will sink input to 3D space, such as underlying models with a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector). In other words, if the player attempts to click a ClickDetector with the mouse hovering over an Active UI element, the UI will block the input from reaching the ClickDetector.
*
* For [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton) objects ([ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) and [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton)), this property determines whether [GuiButton.Activated](https://developer.roblox.com/en-us/api-reference/event/GuiButton/Activated) fires ([GuiButton.AutoButtonColor](https://developer.roblox.com/en-us/api-reference/property/GuiButton/AutoButtonColor) will still work for those as well). The events [InputBegan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputBegan), [InputChanged](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputChanged), and [InputEnded](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputEnded) work as normal no matter the value of this property.
*/
Active: boolean;
/**
* This property determines a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject), which is relative to its absolute size. The origin point determines from where the element is positioned (through [GuiObject.Position](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Position)) and from which the rendered [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) expands.
*
* A good rule of thumb for this property: if the GUI in question is aligned to the left, the X value should be 0. If horizontally centered, set to 0.5. Finally, if the element is aligned to the right, the X value ought to be 1. Similarly, set the Y value to 0, 0.5, and 1 for top, middle, and bottom for Y alignment.
*
* To understand how AnchorPoint works, try creating a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) with `Frame/Position` set to [UDim2.new(0.5, 0, 0.5, 0)](https://developer.roblox.com/en-us/api-reference/datatype/UDim2) (this will set the Frame in the center of its parent object). If you were to change `Frame/Size`, you would notice that the Frame will expand to the right and downward. The very center of the frame would also not be at the exact center of the parent object. However, if you were to set the AnchorPoint to `(0.5, 0.5)`, the Frame would expand in all directions and the center of the frame would indeed be at the parent object's center.
*/
AnchorPoint: Vector2;
/**
* This property is used to automatically size parent UI objects based on the size of its descendants. Developers can use this property to dynamically add text and other content to a UI object at edit or run time, and the size will adjust to fit that content.
*
* When AutomaticSize is set to an [Enum.AutomaticSize](https://developer.roblox.com/en-us/api-reference/enum/AutomaticSize) value to anything other than None, this UI object may resize depending on its child content.
*
* For more information on how to use this property and how it works, please see the following article: [How to use AutomaticSize](../../../articles/ui-automaticsize).
*/
AutomaticSize: Enum.AutomaticSize;
/**
* This property used to determine the color of a [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) background but is
* deprecated in favor of [BackgroundColor3](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundColor3), which should be used in new work instead.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
BackgroundColor: BrickColor;
/**
* This property determines the color of a [UI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) background (the fill color).
*
* Another property that determines the visual properties of the background is [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency). If an element's BackgroundTransparency is set to 1, neither the background nor the border will render and the element will be transparent.
*
* If your element contains text, such as a [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox), [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton), or [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel), make sure the color of your background contrasts the text's color.
*
* See also
* --------
*
* * [GuiObject.BorderColor3](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BorderColor3)
*/
BackgroundColor3: Color3;
/**
* This property determines the transparency of the [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) background and border.
*
* It does not, however, determine the transparency of text if the GUI is a `Textbox`, [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton), or [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel). Text transparency is determined `TextBox/TextTransparency|`, [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency), and [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency) respectively.
*
* If the property is set to 1, neither the background nor the border will render and the GUI will be completely transparent.
*/
BackgroundTransparency: number;
/**
* This property used to determine the color of a [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) border but is deprecated in favor of the [Color3](https://developer.roblox.com/en-us/api-reference/datatype/Color3) property BorderColor3, which should be used in new work instead.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
BorderColor: BrickColor;
/**
* The [UIStroke](https://developer.roblox.com/en-us/api-reference/class/UIStroke) component allows for more advanced border effects.
*
* BorderColor3 determines the color of a [UI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element's rectangular border (also known as the stroke color).
*
* This is separate from the UI element's [GuiObject.BackgroundColor3](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundColor3). If you set a UI element's border and background colors to the same color, you will be unable to distinguish the two.
*
* Other properties properties that determine the visual properties of the border include [GuiObject.BorderSizePixel](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BorderSizePixel) and [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency).
*
* Note that you will not be able to see an element's border if its BorderSizePixel property is set to 0.
*/
BorderColor3: Color3;
/**
* The [UIStroke](https://developer.roblox.com/en-us/api-reference/class/UIStroke) component allows for more advanced border effects.
*
* **BorderMode** determines in what manner a GuiObject's border is laid out relative to its dimensions. It does this using the enum of the same name, [BorderMode](https://developer.roblox.com/en-us/api-reference/enum/BorderMode). See the animation below to understand how the layout changes as [GuiObject.BorderSizePixel](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BorderSizePixel) increases.
*
* 
*/
BorderMode: Enum.BorderMode;
/**
* The [UIStroke](https://developer.roblox.com/en-us/api-reference/class/UIStroke) component allows for more advanced border effects.
*
* This property determines how wide a [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) border should render, in pixels.
*
* This property, [GuiObject.BorderColor3](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BorderColor3), and [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) determine how the border of a GUI element should look.
*
* The border width extends outward the perimeter of the rectangle. For instance, a GUI with a width of 100 pixels and BorderSizePixel set to 2 will actually render 102 pixels wide.
*
* Setting this to 0 will disable the border altogether.
*/
BorderSizePixel: number;
/**
* This property determines if a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) will _clip_ (or make invisible) any portion of descendant GUI elements that would otherwise render outside the bounds of the rectangle. Further descendant GUI elements can also use ClipsDescendants. The behavior is similar to a [ScrollingFrame](https://developer.roblox.com/en-us/api-reference/class/ScrollingFrame).
*
* Note that [GuiObject.Rotation](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Rotation) isn't supported by this property. If this or any ancestor GUI has a **non-zero** [GuiObject.Rotation](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Rotation), this property is **ignored** and descendant GUI elements will be rendered regardless of this property's value.
*
* The gif and code sample below demonstrate how to enabled and disable the property using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript). They also illustrate the affects the property has on descendant GUI elements.
*
* while true do
* script.Parent.ClipDescendants = true
* wait(2)
* script.Parent.ClipDescendants = false
* wait(2)
* end
*
* 
*
* In the gif below, the element labelled _Parent_ toggles between ClipsDescendants enabled and disabled every two seconds. The elements labelled _Child_ are descendants of `Parent` that are affected by changing the property. Also note that the rotated _Child_ element is not affected by the property.
*/
ClipsDescendants: boolean;
/**
* This indicates whether a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) (and its descendants) can be dragged around the screen.
* @deprecated
*/
Draggable: boolean;
/**
* Tags: NotReplicated
*/
readonly GuiState: Enum.GuiState;
Interactable: boolean;
/**
* This property controls the sorting order of a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) when using a [UIGridStyleLayout](https://developer.roblox.com/en-us/api-reference/class/UIGridStyleLayout) (such as [UIListLayout](https://developer.roblox.com/en-us/api-reference/class/UIListLayout) or [UIPageLayout](https://developer.roblox.com/en-us/api-reference/class/UIPageLayout)) with [UIGridStyleLayout.SortOrder](https://developer.roblox.com/en-us/api-reference/property/UIGridStyleLayout/SortOrder) set to [Enum.SortOrder.LayoutOrder](https://developer.roblox.com/en-us/api-reference/enum/SortOrder). It has no functionality if the GUI does not have a sibling UI Layout.
*
* It is a signed 32-bit int, so it can be set to any value from -2,147,483,648 to 2,147,483,647 (inclusive). GUIs are placed in ascending order where lower values take more priority over, and are ordered before, higher values. Values that are equal will fall back to the order they were added in.
*
* If you are unsure if you will need to add an element between two already-existing elements in the future, it can be a good idea to use multiples of 100, i.e. 0, 100, 200. This ensures a large gap of LayoutOrder values you can use for elements ordered in-between other elements.
*
* See also
* --------
*
* * [GuiObject.ZIndex](https://developer.roblox.com/en-us/api-reference/property/GuiObject/ZIndex), which determines the GUI render order instead of placement order.
*/
LayoutOrder: number;
/**
* This property sets the [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) selected when the user moves the Gamepad selector downward. If this property is left blank, the moving the Gamepad downward will not change which selected GUI.
*
* Moving the Gamepad selector downward sets the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) to this object unless the GUI is not [Selectable](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Selectable). If the specified GUI is not selectable, it will not be selected when the gamepad selected moves upward.
*
* Note that since this property can be set to a GUI element even if it is not Selectable, you should ensure that the value of a GUI's selectable property matching your expected behavior.
*
* See also
* --------
*
* * [GuiObject.NextSelectionUp](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionUp)
* * [GuiObject.NextSelectionLeft](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionLeft)
* * [GuiObject.NextSelectionRight](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionRight)
*/
NextSelectionDown: GuiObject | undefined;
/**
* This property sets the [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) selected when the user moves the Gamepad selector to the left. If this property is left blank, the moving the Gamepad left will not change which selected GUI.
*
* Moving the Gamepad selector left sets the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) to this object unless the GUI is not [Selectable](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Selectable). If the specified GUI is not selectable, it will not be selected when the gamepad selected moves upward.
*
* Note that since this property can be set to a GUI element even if it is not Selectable, you should ensure that the value of a GUI's selectable property matching your expected behavior.
*
* See also
* --------
*
* * [GuiObject.NextSelectionUp](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionUp)
* * [GuiObject.NextSelectionDown](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionDown)
* * [GuiObject.NextSelectionRight](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionRight)
*/
NextSelectionLeft: GuiObject | undefined;
/**
* This property sets the [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) selected when the user moves the Gamepad selector to the right. If this property is left blank, the moving the Gamepad right will not change which selected GUI.
*
* Moving the Gamepad selector right sets the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) to this object unless the GUI is not [Selectable](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Selectable). If the GUI is not selectable, it will not be selected when the gamepad selected moves right.
*
* Note that since this property can be set to a GUI element even if it is not Selectable, you should ensure that the value of a GUI's selectable property matching your expected behavior.
*
* See also
* --------
*
* * [GuiObject.NextSelectionUp](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionUp)
* * [GuiObject.NextSelectionDown](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionDown)
* * [GuiObject.NextSelectionLeft](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionLeft)
*/
NextSelectionRight: GuiObject | undefined;
/**
* This property sets the [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) selected when the user moves the Gamepad selector upward. If this property is left blank, the moving the Gamepad upward will not change the selected GUI.
*
* Moving the Gamepad selector upward sets the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) to this object unless the GUI is not [Selectable](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Selectable). If the specified GUI is not selectable, it will not be selected when the gamepad selected moves upward.
*
* Note that since this property can be set to a GUI element even if it is not Selectable, you should ensure that the value of a GUI's selectable property matching your expected behavior.
*
* See also
* --------
*
* * [GuiObject.NextSelectionDown](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionDown)
* * [GuiObject.NextSelectionLeft](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionLeft)
* * [GuiObject.NextSelectionRight](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionRight)
*/
NextSelectionUp: GuiObject | undefined;
/**
* This property determines a [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) pixel and scalar size using a `UDim2`. Its value can be expressed as `UDim2.new(ScalarX, PixelX, ScalarY, PixelY)` or `({ScalarX, PixelX}, {ScalarY, PixelY})`. Position is centered around a GUI's [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint).
*
* An element's position can also be set by modifying both its scalar and pixel positions at the same time. For instance, its position can be set to `({0.25, 100}, {0.25, 100})`.
*
* The scalar position is relative to the size of the parent GUI element. For example, if AnchorPoint is set to `0, 0` and Position is set to `{0, 0}, {0, 0}`, the element's top left corner renders at the top left corner of the parent element. Similarly, if AnchorPoint is set to `0, 0` and Position is set to `{0.5, 0}, {0.5, 0}`, the element's top left corner will render at the direct center of the parent element.
*
* The pixel portions of the `UDim2` value are the same regardless of the parent GUI's size. The values represent the position of the object in pixels. For example, if set to `{0, 100}, {0, 150}` the element's AnchorPoint will render with on the screen 100 pixels from the left and 150 pixels from the top.
*
* An object's actual pixel position can be read from the [GuiBase2d.AbsolutePosition](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsolutePosition) property.
*/
Position: UDim2;
/**
* This property determines the number of degrees by which a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) is rotated. Rotation is relative to the **center** of its parent GUI.
*
* A GUI's [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) does not influence it's rotation. This means that you cannot change the center of rotation since it will always be in the center of the object.
*
* Additionally, this property is **not compatible** with [GuiObject.ClipsDescendants](https://developer.roblox.com/en-us/api-reference/property/GuiObject/ClipsDescendants). If an ancestor (parent) object has ClipsDescendants enabled and this property is nonzero, then descendant GUI elements will not be clipped.
*/
Rotation: number;
/**
* This property determines whether a ~GuiObject|GUI\` can be selected when navigating GUIs using a gamepad.
*
* If this property is true, a GUI can be selected. Selecting a GUI also sets the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) property to that object.
*
* When this is false, the GUI cannot be selected. However, setting this to false when a GUI is selected will not deselect it nor change the value of the GuiService's SelectedObject property.
*
* Add [GuiObject.SelectionGained](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionGained) and [GuiObject.SelectionLost](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionLost) will not fire for the element.
* To deselect a GuiObject, you must change [GuiService's](https://developer.roblox.com/en-us/api-reference/class/GuiService) SelectedObject property.
*
* This property is useful if a GUI is connected to several GUIs via properties such as this [GuiObject.NextSelectionUp](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionUp), [GuiObject.NextSelectionDown](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionDown), [NextSelectionRight](https://developer.roblox.com/en-us/api-reference/class/GuiObject), or [NextSelectionLeft](https://developer.roblox.com/en-us/api-reference/class/GuiObject). Rather than change all of the properties so that the Gamepad cannot select the GUI, you can disable its Selectable property to temporarily prevent it from being selected. Then, when you want the gamepad selector to be able to select the GUI, simply re-enable its selectable property.
*/
Selectable: boolean;
/**
* This property overrides the default selection adornment (used for gamepads). For best results, this should point to a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*
* Note that the SelectionImageObject overlays the selected GUI with the [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) of the image. For best results when using a non-default SelectionImageObject, you should size the SelectionImageObject via the scale [UDim2](https://developer.roblox.com/en-us/api-reference/datatype/UDim2) values. This helps ensure that the object scales properly over the selected element.
*
* The default SelectionImageObject is a blue and white square outline around the selected GUI element. In the image below, the selected GUI is a white [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame).
*
* 
*
* For instance, changing the SelectionImageObject to a [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel) with red and white square outline [image](https://www.roblox.com/library/2347505468/SelectionImage-Red), [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) of 1, [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) of _UDim2(1.1, 0, 1.1, 0)_, and [GuiObject.Position](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Position) of _UDim2(-0.05, 0, -0.05, 0)_ results in the image below:
*
* 
*
* Changing the SelectionImageObject for a GUI element only affects that element. To change the SelectionImageObject for all of a user's GUI elements, you can set the [PlayerGui.SelectionImageObject](https://developer.roblox.com/en-us/api-reference/property/PlayerGui/SelectionImageObject) property.
*
* To determine or set which GUI element is selected by the user, you can use the [GuiService.SelectedObject](https://developer.roblox.com/en-us/api-reference/property/GuiService/SelectedObject) property. The user uses the gamepad to select different GUI elements, invoking the [GuiObject.NextSelectionUp](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionUp), [GuiObject.NextSelectionDown](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionDown), [GuiObject.NextSelectionLeft](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionLeft), and [GuiObject.NextSelectionRight](https://developer.roblox.com/en-us/api-reference/property/GuiObject/NextSelectionRight) events.
*/
SelectionImageObject: GuiObject | undefined;
SelectionOrder: number;
/**
* This property determines a [GUI's](https://developer.roblox.com/en-us/api-reference/class/GuiObject) scalar and pixel size using a `UDim2`. Its value can be expressed as `UDim2.new(ScalarX, PixelX, ScalarY, PixelY)` or `({ScalarX, PixelX}, {ScalarY, PixelY})`.
*
* The scalar size is relative to the scalar size of parent GUI elements, if any. For example, if the GUI's scalar size is `UDim2.new(0.5, 0, 0.5, 0)` and it is not the descendant of a GUI, then it will occupy half of the screen horizontally and vertically. However, if the GUI is the child of a GUI with a scalar size of `UDim2.new(0.5, 0, 0.5, 0)`, then the GUI's scalar size will render to be half the scalar size of its parent both horizontally and vertically and will occupy a quarter of the screen in both dimensions.
*
* The pixel portions of the `UDim2` value are the same regardless of the parent GUI's size. The values represent the size of the object in pixels. For example, if Position is set to `{0, 100}, {0, 150}` the element will render with a width of 100 pixels and height of 150 pixels.
*
* If the GUI has a parent, its size of each axis is also influenced by the parent's [SizeConstraint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/SizeConstraint).
*
* Using negative sizes may result in undefined behavior in some cases, such as with [UIConstraint](https://developer.roblox.com/en-us/api-reference/class/UIConstraint). It is preferrable to change [AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) instead of using negative sizes.
*
* An object's actual pixel size can be read from the [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) property.
*/
Size: UDim2;
/**
* This property works in conjunction with the [Size](https://developer.roblox.com/en-us/api-reference/class/GuiObject.Size) property to determine the screen size of a GUI element.
*
* The [SizeConstraint](https://developer.roblox.com/en-us/api-reference/enum/SizeConstraint) enum will determine the axes that influence the scalar size of an object.
*
* This property is useful for creating onscreen controls that are meant to scale with either the width or height of a parent object, but not both. This preserves the aspect ratio of the GUI element in question. For example, setting to RelativeYY with a Size of `{1, 0}, {1, 0}` will make the UI element square, with both the X and Y sizes equal to the parent element's Y size.
*/
SizeConstraint: Enum.SizeConstraint;
/**
* This property is deprecated, and a mix of [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) and [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency).
*
* When indexing, this will return the BackgroundTranparency.
*
* When setting, this will change the BackgroundTransparency **and** TextTransparency of a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element.
*
* Tags: Hidden, NotReplicated
*/
Transparency: number;
/**
* This property determines whether a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) will render shapes, images and/or text on screen. If set to false, the GUI and all of its descedants (children) will not render.
*
* The rendering of individual components of a GUI can be controlled individually through transparency properties such as [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency), [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency) and [ImageLabel.ImageTransparency](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageTransparency).
*
* When this property is true, the GUI will be ignored by [UIGridStyleLayout](https://developer.roblox.com/en-us/api-reference/class/UIGridStyleLayout) objects (such as [UIGridLayout](https://developer.roblox.com/en-us/api-reference/class/UIGridLayout), [UIListLayout](https://developer.roblox.com/en-us/api-reference/class/UIListLayout) and [UITableLayout](https://developer.roblox.com/en-us/api-reference/class/UITableLayout)). In other words, the space that the element would otherwise occupy in the layout is used by other elements instead.
*/
Visible: boolean;
/**
* This property determines the order in which a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) renders to the screen relative to other GUIs.
*
* By default, GUIs render in ascending priority order where lower values are rendered first. As a result, GUIs with lower ZIndex values appear under higher values. You can change the render order by changing the value of `ScreenGui.ZIndexBehavior`.
*
* The range of valid values is -MAX\_INT to MAX\_INT, inclusive (2,147,483,647 or (2^31 - 1)). If you are unsure if you will need to layer an element between two already-existing elements in the future, it can be a good idea to use multiples of 100, i.e. 0, 100, 200. This ensures a large gap of ZIndex values you can use for elements rendered in-between other elements.
*
* See also
* --------
*
* * [GuiObject.LayoutOrder](https://developer.roblox.com/en-us/api-reference/property/GuiObject/LayoutOrder), which controls the sort order of a GUI when used with a [UIGridStyleLayout](https://developer.roblox.com/en-us/api-reference/class/UIGridStyleLayout) instead of render order.
*/
ZIndex: number;
/**
* Smoothly moves a GUI to a new [UDim2](https://developer.roblox.com/en-us/api-reference/datatype/UDim2) position in the specified time using the specified [EasingDirection](https://developer.roblox.com/en-us/api-reference/enum/EasingDirection) and [EasingStyle](https://developer.roblox.com/en-us/api-reference/enum/EasingStyle).
*
* This function will return whether the tween will play. It will not play if another tween is acting on the [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) and the override parameter is false.
*
* See also
* --------
*
* * [GuiObject:TweenSize](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSize), tweens a GUI's size
* * [GuiObject:TweenSizeAndPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSizeAndPosition), tweens a GUI's size and position synchronously
*/
TweenPosition(
this: GuiObject,
endPosition: UDim2,
easingDirection?: CastsToEnum,
easingStyle?: CastsToEnum,
time?: number,
override?: boolean,
callback?: (finishedTween: Enum.TweenStatus) => void,
): boolean;
/**
* Smoothly resizes a GUI to a new [UDim2](https://developer.roblox.com/en-us/api-reference/datatype/UDim2) in the specified time using the specified [EasingDirection](https://developer.roblox.com/en-us/api-reference/enum/EasingDirection) and [EasingStyle](https://developer.roblox.com/en-us/api-reference/enum/EasingStyle).
*
* This function will return whether the tween will play. Normally this will always return true, but it will return false if another tween is active and override is set to false.
*
* See also
* --------
*
* * [GuiObject:TweenPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenPosition), tweens a GUI's position
* * [GuiObject:TweenSizeAndPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSizeAndPosition), tweens a GUI's size and position synchronously
*/
TweenSize(
this: GuiObject,
endSize: UDim2,
easingDirection?: CastsToEnum,
easingStyle?: CastsToEnum,
time?: number,
override?: boolean,
callback?: (finishedTween: Enum.TweenStatus) => void,
): boolean;
/**
* Smoothly resizes and moves a GUI to a new [UDim2](https://developer.roblox.com/en-us/api-reference/datatype/UDim2) size and position in the specified time using the specified [EasingDirection](https://developer.roblox.com/en-us/api-reference/enum/EasingDirection) and [EasingStyle](https://developer.roblox.com/en-us/api-reference/enum/EasingStyle).
*
* This function will return whether the tween will play. Normally this will always return true, but it will return false if another tween is active and override is set to false.
*
* See also
* --------
*
* * [GuiObject:TweenSize](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenSize), tweens a GUI's size
* * [GuiObject:TweenPosition](https://developer.roblox.com/en-us/api-reference/function/GuiObject/TweenPosition), tweens a GUI's position
*/
TweenSizeAndPosition(
this: GuiObject,
endSize: UDim2,
endPosition: UDim2,
easingDirection?: CastsToEnum,
easingStyle?: CastsToEnum,
time?: number,
override?: boolean,
callback?: (finishedTween: Enum.TweenStatus) => void,
): boolean;
/**
* This event fires when a player begins dragging the object.
*
* See also
* --------
*
* * [GuiObject.DragStopped](https://developer.roblox.com/en-us/api-reference/event/GuiObject/DragStopped)
* @deprecated
*/
readonly DragBegin: RBXScriptSignal<(initialPosition: UDim2) => void>;
/**
* This event fires when a player stops dragging the object.
*
* See also
* --------
*
* * [GuiObject.DragBegin](https://developer.roblox.com/en-us/api-reference/event/GuiObject/DragBegin)
* @deprecated
*/
readonly DragStopped: RBXScriptSignal<(x: number, y: number) => void>;
/**
* This event fires when a user begins interacting with the [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
*
* The [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) has a similarly named event that is not restricted to a specific UI element: [UserInputService.InputBegan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputBegan).
*
* This event will always fire regardless of game state.
*
* See also
* --------
*
* * [GuiObject.InputEnded](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputEnded)
* * [GuiObject.InputChanged](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputChanged)
*/
readonly InputBegan: RBXScriptSignal<(input: InputObject) => void>;
/**
* This event fires when a user changes how they're interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
*
* The [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) has a similarly named event that is not restricted to a specific UI element: [UserInputService.InputChanged](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputChanged).
*
* This event will always fire regardless of game state.
*
* See also
* --------
*
* * [GuiObject.InputBegan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputBegan)
* * [GuiObject.InputEnded](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputEnded)
*/
readonly InputChanged: RBXScriptSignal<(input: InputObject) => void>;
/**
* The InputEnded event fires when a user stops interacting via a Human-Computer Interface device (Mouse button down, touch begin, keyboard button down, etc).
*
* The [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) has a similarly named event that is not restricted to a specific UI element: [UserInputService.InputEnded](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputEnded).
*
* This event will always fire regardless of game state.
*
* See also
* --------
*
* * [GuiObject.InputBegan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputBegan)
* * [GuiObject.InputChanged](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputChanged)
*/
readonly InputEnded: RBXScriptSignal<(input: InputObject) => void>;
/**
* The MouseEnter event fires when a user moves their mouse into a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element.
*
* Please do not rely on the `x` and `y` arguments passed by this event as a fool-proof way to to determine where the user's mouse is when it enters a GUI. These coordinates may vary even when the mouse enters the GUI via the same edge - particularly when the mouse enters the element quickly. This is due to the fact the coordinates indicate the position of the mouse when the event fires rather than the exact moment the mouse enters the GUI.
*
* This event fires even when the GUI element renders beneath another element.
*
* If you would like to track when a user's mouse leaves a GUI element, you can use the [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave) event.
*
* See also
* --------
*
* * [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave)
* * [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved)
* * [GuiObject.MouseWheelForward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelForward)
* * [GuiObject.MouseWheelBackward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelBackward)
*/
readonly MouseEnter: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The MouseLeave event fires when a user moves their mouse out of a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element.
*
* Please do not rely on the `x` and `y` arguments passed by this event as a fool-proof way to to determine where the user's mouse is when it leaves a GUI. These coordinates may vary even when the mouse leaves the GUI via the same edge - particularly when the mouse leaves the element quickly. This is due to the fact the coordinates indicate the position of the mouse when the event fires rather than the exact moment the mouse leaves the GUI.
*
* This event fires even when the GUI element renders beneath another element.
*
* See also
* --------
*
* * [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter)
* * [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved)
* * [GuiObject.MouseWheelForward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelForward)
* * [GuiObject.MouseWheelBackward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelBackward)
*/
readonly MouseLeave: RBXScriptSignal<(x: number, y: number) => void>;
/**
* Fires whenever a user moves their mouse while it is inside a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element. It is similar to [Mouse.Move](https://developer.roblox.com/en-us/api-reference/event/Mouse/Move), which fires regardless whether the user's mouse is over a GUI element.
*
* Note, this event fires when the mouse's position is updated, therefore it will fire repeatedly whilst being moved.
*
* The `x` and `y` arguments indicate the updated screen coordinates of the user's mouse in pixels. These can be useful to determine the mouse's location on the GUI, screen, and delta since the mouse's previous position if it is being tracked in a global variable.
*
* The code below demonstrates how to determine the [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) offset of the user's mouse relative to a GUI element:
*
* local CustomScrollingFrame = script.Parent
* local SubFrame = CustomScrollingFrame:FindFirstChild("SubFrame")
*
* local mouse = game.Players.LocalPlayer:GetMouse()
* function getPosition(X, Y)
* local gui\_X = CustomScrollingFrame.AbsolutePosition.X
* local gui\_Y = CustomScrollingFrame.AbsolutePosition.Y
*
*
* local pos = Vector2.new(math.abs(X - gui\_X), math.abs(Y - gui\_Y - 36))
* print(pos)
* end
*
* CustomScrollingFrame.MouseMoved:Connect(getPosition)
*
* Note that this event may not fire exactly when the user's mouse enters or exits a GUI element. Therefore, the `x` and `y` arguments may not match up perfectly to the coordinates of the GUI's edges.
*
* See also
* --------
*
* * [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter)
* * [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave)
* * [GuiObject.MouseWheelForward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelForward)
* * [GuiObject.MouseWheelBackward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelBackward)
*/
readonly MouseMoved: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The WheelBackward event fires when a user scrolls their mouse wheel back when the mouse is over a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element. It is similar to [Mouse.WheelBackward](https://developer.roblox.com/en-us/api-reference/event/Mouse/WheelBackward), which fires regardless whether the user's mouse is over a GUI element.
*
* This event fires merely as an indicator of the wheel's forward movement. This means that the x and y mouse coordinate arguments do not change as a result of this event. These coordinates only change when the mouse moves, which can be tracked by the [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved) event.
*
* See also
* --------
*
* * [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter)
* * [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave)
* * [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved)
* * [GuiObject.MouseWheelForward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelForward)
*/
readonly MouseWheelBackward: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The WheelForward event fires when a user scrolls their mouse wheel forward when the mouse is over a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element. It is similar to [Mouse.WheelForward](https://developer.roblox.com/en-us/api-reference/event/Mouse/WheelForward), which fires regardless whether the user's mouse is over a GUI element.
*
* This event fires merely as an indicator of the wheel's forward movement. This means that the x and y mouse coordinate arguments do not change as a result of this event. These coordinates only change when the mouse moves, which can be tracked by the [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved) event.
*
* See also
* --------
*
* * [GuiObject.MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter)
* * [GuiObject.MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave)
* * [GuiObject.MouseMoved](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseMoved)
* * [GuiObject.MouseWheelBackward](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseWheelBackward)
*/
readonly MouseWheelForward: RBXScriptSignal<(x: number, y: number) => void>;
/**
* This event fires when the Gamepad selector starts focusing on the [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*
* If you want to check from the Gamepad select stops focusing on the GUI element, you can use the [GuiObject.SelectionLost](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionLost) event.
*
* When a GUI gains selection focus, the value of the `GuiService/SelectionObject|SelectionObject` property also changes to the that gains selection. To determine which GUI gained selection, check the value of this property.
*/
readonly SelectionGained: RBXScriptSignal<() => void>;
/**
* This event fires when the Gamepad selector stops focusing on the [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*
* If you want to check from the Gamepad select starts focusing on the GUI element, you can use the [GuiObject.SelectionGained](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionGained) event.
*
* When a GUI loses selection focus, the value of the `GuiService/SelectionObject|SelectionObject` property changes either to nil or to the GUI element that gains selection focus. To determine which GUI gained selection, or if no GUI is selected, check the value of this property.
*/
readonly SelectionLost: RBXScriptSignal<() => void>;
/**
* The TouchLongPress event fires after a brief moment when the player holds their finger on the UI element using a touch-enabled device. It fires with a table of [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires multiple times with multiple [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState)s: Begin after a brief delay, Change if the player moves their finger during the gesture and finally with End. The delay is platform dependent; in Studio it is a little longer than one second.
*
* Since this event only requires one finger, this event can be simulated in Studio using the emulator and a mouse.
*
* Below is an example of TouchLongPress firing on a Frame that is [GuiObject.Active](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Active). Below, the event fires after a brief delay (Begin) and then continually as as the finger is moved (Change). It fires one last time after it is released (End).
*
* 
*
* See also
* --------
*
* * [UserInputService.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TouchLongPress), an event with the same functionality but is not restricted to a specific [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject)
* * [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan)
* * [GuiObject.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPinch)
* * [GuiObject.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchRotate)
* * [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap)
* * [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)
*/
readonly TouchLongPress: RBXScriptSignal<(touchPositions: Array, state: Enum.UserInputState) => void>;
/**
* This event fires when the player moves their finger on the UI element using a touch-enabled device. It fires shortly before [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe) would, and does not fire with [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap). This event is useful for allowing the player to manipulate the position of UI elements on the screen.
*
* This event fires with a table of [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires several times with multiple [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState)s: Begin after a brief delay, Change when the player moves their finger during the gesture and finally once more with End.
*
* This event cannot be simulated in Studio using the emulator and a mouse; you must have a real touch enabled device to fire this event.
*
* Below is an animation of TouchPan firing on the black semitransparent [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) that covers the screen. The event is being used to manipulate the position of the pink inner [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame). The code for this can be found in the code samples.
*
* 
*
* See also
* --------
*
* * [GuiObject.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPinch)
* * [GuiObject.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchRotate)
* * [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap)
* * [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)
* * [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress)
*/
readonly TouchPan: RBXScriptSignal<
(
touchPositions: Array,
totalTranslation: Vector2,
velocity: Vector2,
state: Enum.UserInputState,
) => void
>;
/**
* The TouchPinch event fires when the player uses two fingers to make a pinch or pull gesture on the UI element using a touch-enabled device. A **pinch** happens when two or more fingers move closer together, and a **pull** happens when they move apart. This event fires in conjunction with [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan). This event is useful for allowing the player to manipulate the scale (size) of UI elements on the screen, and is most often used for zooming features.
*
* This event fires with a table of [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires several times with multiple [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState)s: Begin after a brief delay, Change when the player moves a finger during the gesture and finally once more with End. It should be noted that the scale should be used **multiplicatively**.
*
* Since this event requires at least two fingers, it is not possible to be simulated in Studio using the emulator and a mouse; you must have a real touch-enabled device (and also least two fingers, try asking a friend). Below is an animation of TouchPinch firing on the black semitransparent [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) that covers the screen (note the touch positions marked with white circles). The event is being used to manipulate the scale of the [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) that says “Hi!”. The code for this can be found in the code samples.
*
* 
*
* See also
* --------
*
* * [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan)
* * [GuiObject.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchRotate)
* * [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap)
* * [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)
* * [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress)
*/
readonly TouchPinch: RBXScriptSignal<
(touchPositions: Array, scale: number, velocity: number, state: Enum.UserInputState) => void
>;
/**
* The TouchRotate event fires when the player uses two fingers to make a pinch or pull gesture on the UI element using a touch-enabled device. Rotation occurs when the angle of the line between two fingers changes. This event fires in conjunction with [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan). This event is useful for allowing the player to manipulate the rotation of UI elements on the screen.
*
* This event fires with a table of [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) that describe the relative screen positions of the fingers involved in the gesture. In addition, it fires several times with multiple [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState)s: Begin after a brief delay, Change when the player moves a finger during the gesture and finally once more with End.
*
* Since this event requires at least two fingers, it is not possible to be simulated in Studio using the emulator and a mouse; you must have a real touch-enabled device (and also least two fingers, try asking a friend).
*
* See also
* --------
*
* * [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan)
* * [GuiObject.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPinch)
* * [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap)
* * [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)
* * [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress)
*/
readonly TouchRotate: RBXScriptSignal<
(touchPositions: Array, rotation: number, velocity: number, state: Enum.UserInputState) => void
>;
/**
* The TouchSwipe event fires when the player performs a swipe gesture on the UI element using a touch-enabled device. It fires with the direction of the gesture (Up, Down, Left or Right) and the number of touch points involved in the gesture. Swipe gestures are often used to change tabs in mobile UIs.
*
* Since this event only requires one finger, this event can be simulated in Studio using the emulator and a mouse. Below is an example of TouchSwipe being fired on a Frame that is [GuiObject.Active](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Active). Below, the event fires when the Frame moves and changes color slightly. The code for this can be found the code samples.
*
* 
*
* See also
* --------
*
* * [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan)
* * [GuiObject.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPinch)
* * [GuiObject.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchRotate)
* * [GuiObject.TouchTap](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchTap)
* * [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress)
*/
readonly TouchSwipe: RBXScriptSignal<(swipeDirection: Enum.SwipeDirection, numberOfTouches: number) => void>;
/**
* The TouchTap event fires when the player performs a tap gesture on the UI element using a touch-enabled device. A tap is a quick single touch without any movement involved (a longer press would fire [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress), and moving during the touch would fire [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan) and/or [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)). It fires with a table of [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2)s that describe the relative positions of the fingers involved in the gesture.
*
* Since this event only requires one finger, this event can be simulated in Studio using the emulator and a mouse. Below is an example of TouchTap being fired on a Frame that is [GuiObject.Active](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Active). Below, the event fires when the cursor briefly pauses (to simulate a tap) and the Frame toggles its [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency). The code for this can be found the code samples.
*
* 
*
* See also
* --------
*
* * [GuiObject.TouchPan](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPan)
* * [GuiObject.TouchPinch](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchPinch)
* * [GuiObject.TouchRotate](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchRotate)
* * [GuiObject.TouchSwipe](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchSwipe)
* * [GuiObject.TouchLongPress](https://developer.roblox.com/en-us/api-reference/event/GuiObject/TouchLongPress)
*/
readonly TouchTap: RBXScriptSignal<(touchPositions: Array) => void>;
}
/** Renders descendants as a group with color and transparency applied to all of them. */
interface CanvasGroup extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CanvasGroup: unique symbol;
GroupColor3: Color3;
/**
* Transparency that applies to all descendants.
*/
GroupTransparency: number;
}
/** Frame is a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) that renders as a plain rectangle with no other content. They are the simplest concrete example of a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject), as they provide very little additional functionality (`Frame.FrameStyle`). Despite this, Frames are useful as containers for other [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject)s, such as [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel), [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel). The key benefit to using a Frame over a [Folder](https://developer.roblox.com/en-us/api-reference/class/Folder) as a container object is the ability to further manipulate the `GuiObject.Size` and `GuiObject.Position` of any descendant [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject)s. */
interface Frame extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Frame: unique symbol;
/**
* Sets what the frame looks like from a selection of pre-determined styles. See [FrameStyle](https://developer.roblox.com/en-us/api-reference/enum/FrameStyle) for a description of each style.
*/
Style: Enum.FrameStyle;
}
/** GuiLabel is an abstract class that inherits from [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject). It is the base class for [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) and [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton). Objects of this type serve to be interactive, clickable user interface elements. It defines several properties for interaction behavior, namely [GuiButton.AutoButtonColor](https://developer.roblox.com/en-us/api-reference/property/GuiButton/AutoButtonColor) and [GuiButton.Modal](https://developer.roblox.com/en-us/api-reference/property/GuiButton/Modal), as well as a handful of events for mouse buttons ([GuiButton.MouseButton1Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Click), [GuiButton.MouseButton1Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Down), etc).
*
* The most import ant event of a GuiButton is [GuiButton.Activated](https://developer.roblox.com/en-us/api-reference/event/GuiButton/Activated), a **multi-platform event** that fires when the button is activated. When using a mouse, this means clicking the button and releasing with the cursor still over the UI object. For touch, the same applies but with a touch instead of button press. Finally, for gamepads, [GuiButton.Activated](https://developer.roblox.com/en-us/api-reference/event/GuiButton/Activated) fires if a GuiButton is selected when the A-button is pressed and released. In short, this event is very useful for multi-platform user interface programming as it provides a nice general interface for a single user input.
*/
interface GuiButton extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiButton: unique symbol;
/**
* The AutoButtonColor determines whether the button automatically changes color when the user's [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) hovers over or clicks on it.
*
* If true, the button will automatically change color when the mouse hovers over or clicks on it. If false, the button will not change.
*
* If you would like to customize how a button changes when the user's mouse hovers over or clicks on it, consider using an [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) GUI and changing the element's [ImageButton.HoverImage](https://developer.roblox.com/en-us/api-reference/property/ImageButton/HoverImage) and `ImageButton.PressedImage`.
*
* Please note that this property will not have an effect on an [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) if it's [ImageButton.Image](https://developer.roblox.com/en-us/api-reference/property/ImageButton/Image) property is set to an image and is not null. Additionally, the property will not affect an ImageButton element on mouse hover when its [ImageButton.HoverImage](https://developer.roblox.com/en-us/api-reference/property/ImageButton/HoverImage) is not null nor on mouse click if [ImageButton.PressedImage](https://developer.roblox.com/en-us/api-reference/property/ImageButton/PressedImage) is not null.
*/
AutoButtonColor: boolean;
/**
* If true while the GUI element is visible, the mouse will not be locked unless the right mouse button is down.
*/
Modal: boolean;
/**
* A boolean property which indicates whether the object has been selected.
*/
Selected: boolean;
/**
* Sets the style of the GuiButton based on a list of pre-determined styles.
*/
Style: Enum.ButtonStyle;
/**
* Fires when the button is activated.
*/
readonly Activated: RBXScriptSignal<(inputObject: InputObject, clickCount: number) => void>;
/**
* The MouseButton1Click event fires when the user's [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) fully left clicks the GUI button.
*
* By clicking, the mouse has to be in bounds of the button and has to be pressed down and up again before this event fires. If the mouse leaves the bounds of the button and is released, the even will not fire. If you would like to avoid this limitation, you can use [GuiButton.MouseButton1Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Down) and `MouseButton1Up`. These events are similar, but will fire whenever the user pressed their left mouse down or up, respectively.
*
* This event is similar to [GuiButton.MouseButton2Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Click), which behaves identically except that it is connected to the user's right mouse button.
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton1Click: RBXScriptSignal<() => void>;
/**
* The MouseButton2Down event fires when the user presses their left [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) button down on the GUI object.
*
* This event is similar to [GuiButton.MouseButton2Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Down), which behaves identically except that it is connected to the user's right mouse button.
*
* If you are looking for an event requiring the user to press and release their left mouse on a GUI in order for the event to fire, consider using [GuiButton.MouseButton2Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Click).
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton1Down: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The MouseButton1Up event fires when the user releases their left [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) up off of the GUI object.
*
* This event is similar to [GuiButton.MouseButton2Up](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Up), which behaves identically except that it is connected to the user's right mouse button.
*
* If you are looking for an event requiring the user to press and release their left mouse on a GUI in order for the event to fire, consider using [GuiButton.MouseButton1Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Click).
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton1Up: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The MouseButton1Click event fires when the user's [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) fully right clicks the GUI button.
*
* By clicking, the mouse has to be in bounds of the button and has to be pressed down and up again before this event fires. If the mouse leaves the bounds of the button and is released, the even will not fire. If you would like to avoid this limitation, you can use [GuiButton.MouseButton2Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Down) and `MouseButton2Up`. These events are similar, but will fire whenever the user pressed their left mouse down or up, respectively.
*
* This event is similar to [GuiButton.MouseButton1Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Click), which behaves identically except that it is connected to the user's left mouse button.
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton2Click: RBXScriptSignal<() => void>;
/**
* The MouseButton2Down event fires when the user presses their left [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) button down on the GUI object.
*
* This event is similar to [GuiButton.MouseButton1Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Down), which behaves identically except that it is connected to the user's left mouse button.
*
* If you are looking for an event requiring the user to press and release their right mouse on a GUI in order for the event to fire, consider using [GuiButton.MouseButton2Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Click).
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton2Down: RBXScriptSignal<(x: number, y: number) => void>;
/**
* The MouseButton2Up event fires when the user releases their right [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) up off of the GUI object.
*
* This event is similar to [GuiButton.MouseButton1Up](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Up), which behaves identically except that it is connected to the user's left mouse button.
*
* If you are looking for an event requiring the user to press and release their right mouse on a GUI in order for the event to fire, consider using [GuiButton.MouseButton2Click](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton2Click).
*
* Note that this event will only fire for GUI buttons, including [TextButtons](https://developer.roblox.com/en-us/api-reference/class/TextButton) and [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton). It will not fire for other [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject).
*/
readonly MouseButton2Up: RBXScriptSignal<(x: number, y: number) => void>;
}
/** An ImageButton behaves similarly to an [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel) in regards to rendering with the additional behaviors of a [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton). It defines the same image-rendering properties as a [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel) does.
*
* You can disable image rendering by setting [ImageButton.ImageTransparency](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageTransparency) to 1. This will leave you with a plain rectangle that can be used as a button. However, it may be better to use a blank [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton) for this.
*/
interface ImageButton extends GuiButton {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ImageButton: unique symbol;
/**
* A textureId that could be set on the [ImageButton's](https://developer.roblox.com/en-us/api-reference/class/ImageButton) properties. When the button is hovered, it will render HoverImage if specified.
*/
HoverImage: string;
/**
* The Image property is a content-type property that should hold the asset ID of a Decal or Image on the Roblox website. It functions identically to [Decal.Texture](https://developer.roblox.com/en-us/api-reference/property/Decal/Texture) with regards to loading the image from the Roblox website. The rendered image will be colorized using [ImageButton.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageColor3). It is possible to make the image render as tiled, scaled to fit, or 9-sliced, by adjusting the [ImageButton.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ScaleType) property.
*/
Image: string;
/**
* The ImageColor3 property determines how an image is colorized. When set to white, no colorization occurs. This property is very useful for reusing image assets: If the source image is completely white with transparency, you can set the entire color of the image at once with this property.
*/
ImageColor3: Color3;
/**
* Allows the partial display of an image in conjunction with [ImageButton.ImageRectSize](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageRectSize). This property determines the pixel offset (from the top-left) of the image area to be displayed.
*
* This property behaves identically to [ImageLabel.ImageRectSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectSize).
*/
ImageRectOffset: Vector2;
/**
* Allows the partial display of an image in conjunction with [ImageButton.ImageRectOffset](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageRectOffset). This property determines the pixel size of the image area to be displayed. If either dimension is set to 0, the entire image is displayed instead.
*
* This property behaves identically to [ImageLabel.ImageRectOffset](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectOffset).
*/
ImageRectSize: Vector2;
/**
* ImageTransparency determines the alpha of a UI element's rendered image. A value of 0 is completely opaque, and a value of 1 is completely transparent (invisible). This property behaves similarly to [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) or [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency).
*/
ImageTransparency: number;
/**
* The IsLoaded property indicates if the [ImageButton.Image](https://developer.roblox.com/en-us/api-reference/property/ImageButton/Image) property finished loading from the Roblox website. Images declined by moderation will never load.
*
* Tags: NotReplicated
*/
readonly IsLoaded: boolean;
/**
* A texture ID that can be set as an [ImageButton](https://developer.roblox.com/en-us/api-reference/class/ImageButton) property. When the button is pressed, it will render this image.
*/
PressedImage: string;
/**
* Determines how the image looks when it is scaled.
*
* By default, the image smooths out the texture when displayed either larger or smaller than its size in texture memory. In contrast, [Enum.ResamplerMode.Pixelated](https://developer.roblox.com/en-us/api-reference/enum/ResamplerMode.Pixelated) preserves the sharp edges of the image pixels.
*/
ResampleMode: Enum.ResamplerMode;
/**
* The ScaleType property determines in what way an [ImageButton.Image](https://developer.roblox.com/en-us/api-reference/property/ImageButton/Image) is rendered when the UI element's absolute size differs from the source image's size.
*
* By default, this property is [Enum.ScaleType.Stretch](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Stretch), which will simply stretch/compact the image dimensions so it fits the UI element's space exactly. Since transparent pixels are set to black when uploading to the Roblox website, transparent images should apply alpha blending to avoid a blackish outline around scaled images.
*
* For [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice), the [ImageButton.SliceCenter](https://developer.roblox.com/en-us/api-reference/property/ImageButton/SliceCenter) property will be revealed in the Properties window. This is for nine-slice UI: when scaling up, the corners will remain the source image size. The edges of the image will stretch to the width/height of the image. Finally, the center of the image will stretch to fill the center area of the image.
*
* Finally, for [Enum.ScaleType.Tile](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Tile), the [ImageButton.TileSize](https://developer.roblox.com/en-us/api-reference/property/ImageButton/TileSize) property will be revealed in the Properties window. This is for tiled images, where the size of each image tile is determined by the [ImageButton.TileSize](https://developer.roblox.com/en-us/api-reference/property/ImageButton/TileSize) property.
*/
ScaleType: Enum.ScaleType;
/**
* The SliceCenter property sets the slice boundaries of a 9-sliced image when [ImageButton.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ScaleType) is set to [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice). Please note that this property is only visible in the Studio Properties Pane if [ImageButton.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ScaleType) is set to [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice).
* Select this property and click the “…” button to open the 9-Slice Editor, a built-in visual editor for setting the slice boundaries.
*
* To learn more about 9-sliced images, check out this tutorial: [UI 9 Slice Design](https://developer.roblox.com/articles/ui-9-slice-design).
*/
SliceCenter: Rect;
/**
* Scales the 9slice edges by the specified ratio. This means that the edges around the 9slice will grow as if you'd uploaded a new version of the texture upscaled. Defaults to 1.0.
*
* As a multiplier for the borders of a 9slice, it is useful for reusing one rounded corner image for multiple radii
*
* 
*
* See also
* --------
*
* * [ImageButton.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ScaleType), determines how an image will scale if displayed in a UI element whose size differs from the source image
* * `ImageLabel/ScaleCenter`,determines the center of a 9slice image
* * [ImageButton.SliceScale](https://developer.roblox.com/en-us/api-reference/property/ImageButton/SliceScale), the same property in terms of functionality but for [ImageButtons](https://developer.roblox.com/en-us/api-reference/class/ImageButton)
*/
SliceScale: number;
/**
* TileSize sets the tiling size of the ImageButton. The default `UDim2` values are 1,0,1,0. The scale component of the UDim2 will scale the tile based on the size of the ImageButton. The offset is in raw pixels. The tiling starts at the upper left-hand corner of the image. For example a scale of 0.5 will mean the tile will be half the size of the ImageButton (in the corresponding axis).
*
* This property is only active if the ScaleType for the ImageButton is set to Tile instead of Slice or Stretch.
*/
TileSize: UDim2;
}
/** A TextButton behaves similarly to [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) in regards to rendering with the additional behaviors of a [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton). It defines the same text-rendering properties as a [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) does.
*
* You can disable text rendering by setting [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency) to 1. This will leave you with a plain rectangle that can be used as a button.
*/
interface TextButton extends GuiButton {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TextButton: unique symbol;
/**
* This property provides a copy of [TextButton.Text](https://developer.roblox.com/en-us/api-reference/property/TextButton/Text) that contains exactly what is being rendered by the [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton). This is useful for eliminating style tags used for rich text.
*
* Example
* -------
*
* When [TextButton.RichText](https://developer.roblox.com/en-us/api-reference/property/TextButton/RichText) is enabled, the [TextButton.ContentText](https://developer.roblox.com/en-us/api-reference/property/TextButton/ContentText) property shows the text as it appears to the player.
*
* RichText
*
* Text
*
* ContentText
*
* false
*
* Hello,
world!
*
* Hello,
world!
*
* true
*
* Hello,
world!
*
* Hello,
* world!
*
* Tags: NotReplicated
*/
readonly ContentText: string;
/**
* The Font property selects one of several pre-defined fonts with which the UI element will render its text. Some fonts have bold, italic and/or light variants (as there is no font-weight or font-style properties).
*
* With the exception of the “Legacy” font, each font will render text with the line height equal to the [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) property. The “Code” font is the only monospace font. It has the unique property that each character has the exact same width and height ratio of 1:2. The width of each character is approximately half the [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) property.
*
* Tags: Hidden, NotReplicated
*/
Font: Enum.Font;
FontFace: Font;
/**
* This property determines the font size to be used.
*
* Tags: NotReplicated
* @deprecated Use `TextSize` instead
*/
FontSize: Enum.FontSize;
/**
* Controls the height of lines, as a multiple of the font's em square size, by scaling the spacing between lines of text in the [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton). Valid values range from 1.0 to 3.0, defaulting to 1.0.
*/
LineHeight: number;
/**
* This property sets whether a [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton) should be [GuiBase2d.Localize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/Localize) or not.
*
* Tags: Hidden, NotReplicated
*/
readonly LocalizedText: string;
/**
* This property controls the maximum number of graphemes (or units of text) that are shown on the [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton). It is primarily provided as an easy way to create a “typewriter effect” where the characters appear one at a time.
*
* Changing the property does not change the position or size of the visible graphemes - the layout will be calculated as if all graphemes are visible.
*
* Setting the property to -1 disables the limit and shows the entirety of the [TextButton.Text](https://developer.roblox.com/en-us/api-reference/property/TextButton/Text).
*/
MaxVisibleGraphemes: number;
/**
* This property determines whether the [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton) renders the [TextButton.Text](https://developer.roblox.com/en-us/api-reference/property/TextButton/Text) string using rich text formatting. Rich text uses simple markup tags to style sections of the string in bold, italics, specific colors, and more.
*
* To use rich text, simply include formatting tags in the [TextButton.Text](https://developer.roblox.com/en-us/api-reference/property/TextButton/Text) string. Reference on formatting tags can be found in the [Using Rich Text](https://developer.roblox.com/en-us/articles/gui-rich-text) article.
*/
RichText: boolean;
/**
* The Text property determines the content rendered by the UI element. The visual properties of the string rendered to the screen is determined by [TextButton.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextColor3), [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency), [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize), [TextButton.Font](https://developer.roblox.com/en-us/api-reference/property/TextButton/Font), [TextButton.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextScaled), [TextButton.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextWrapped), [TextButton.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextXAlignment) and [TextButton.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextYAlignment).
*
* It is possible to render emoji (for example, 😃) and other symbols. These special symbols aren't affected by the [TextButton.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextColor3) property. These can be pasted into [Script](https://developer.roblox.com/en-us/api-reference/class/Script) and [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) objects, as well as the field within the Properties window.
*
* This property may contain newline characters, however, it is not possible to type newline characters within the Properties window. Similarly, this property may contain a tab character, but it will render as a space instead.
*/
Text: string;
/**
* The read-only property TextBounds reflects the absolute size of rendered text in offsets. In other words, if you were to try to fit text into a rectangle, this property would reflect the minimum dimensions of the rectangle you would need in order to fit the text.
*
* Using [TextService:GetTextSize](https://developer.roblox.com/en-us/api-reference/function/TextService/GetTextSize), you can predict what TextBounds will be on a TextLabel given a string, [TextButton.Font](https://developer.roblox.com/en-us/api-reference/property/TextButton/Font), [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) and frame size.
*
* Tags: NotReplicated
*/
readonly TextBounds: Vector2;
/**
* This property determines the color of text.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
TextColor: BrickColor;
/**
* This property determines the color of all the text rendered by a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextButton) element. This property along with [TextButton.Font](https://developer.roblox.com/en-us/api-reference/property/TextButton/Font), [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) and [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency) will determine the visual properties of text. Text is rendered after the text stroke ([TextButton.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextStrokeColor3)).
*
* It's important that text is easily read by players! Be sure to choose colors with little-to-no saturation, like white, grey, or black. Make sure the color of your text is contrasted by the `TextButton/BackgroundColor3` of the UI element. If the element has a transparent background, try applying a black [TextButton.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextStrokeColor3) to help contrast the text with the 3D world behind it.
*/
TextColor3: Color3;
TextDirection: Enum.TextDirection;
/**
* A boolean representation of whether the TextButton's text fits within the size of it.
*
* Tags: NotReplicated
*/
readonly TextFits: boolean;
/**
* **Note**
*
* Rather than using TextScaled, we recommend you consider using [AutomaticSize](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AutomaticSize), a new method to dynamically size UI that will give you the best visual result possible.
*
* The TextScaled property determines whether text is scaled so that it fills the entire UI element's space. When this is enabled, [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) is ignored and [TextButton.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextWrapped) is automatically enabled. This property is useful for text-rendering UI elements within [BillboardGuis](https://developer.roblox.com/en-us/api-reference/class/BillboardGui).
*
* When this property is used for screen-space UI, it may be desirable to use a [UITextSizeConstraint](https://developer.roblox.com/en-us/api-reference/class/UITextSizeConstraint) to restrict the range of possible text sizes.
*
* TextScaled and AutomaticSize
* ----------------------------
*
* It's recommended that developers avoid usage of TextScaled and adjust UI to take advantage of the AutomaticSize property instead. Here are the core differences between the two properties:
*
* * TextScaled scales the content (text) to accommodate the UI. Without careful consideration, some text may become unreadable if scaled too small.
* * AutomaticSize resizes the UI to accommodate content.
*
* With AutomaticSize, you're able to adjust your UI to accommodate the content (text) while maintaining a consistent font size. For more information on how to use automatic sizing, see the UI Automatic Size article.
*
* We suggest that you don't apply both TextScaled and AutomaticSize on the same UI object. If you apply both properties:
*
* * AutomaticSize determines the maximum amount of available space that a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) can use (in this case, text)
* * TextScaled uses the available space determined by AutomaticSize, to scale the font size to fit the available space, which will expand up to the maximum font size (100), if there are no size constraints
* * The end result will be: text goes to 100 font size and the UI object will expand to fit that text
*
* Using both AutomaticSize and TextScaled at the same time can result in significant scaling differences than when AutomaticSize is off. Here is an example of an automatically sized TextLabel (with no minimum size) that has TextScaled enabled:
*
* 
*
* Note how automatic size changes the TextLabel's size relative to the parent frame's size. Subsequently, as the TextLabel is resized, the TextScaled property scales the text to the maximum amount of space available by the automatically sized TextLabel.
*/
TextScaled: boolean;
/**
* The TextSize property determines the height in offsets of one line of rendered text. The unit is in offsets, not points (which is used in most document editing programs). The “Legacy” font does not hold this property.
*/
TextSize: number;
/**
* The TextStrokeColor3 property sets the color of the stroke, or outline, of rendered text. This property and [TextButton.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextStrokeTransparency) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextButton.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextColor3) and [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency).
*/
TextStrokeColor3: Color3;
/**
* .The TextStrokeTransparency property sets the transparency of the stroke, or outline, of rendered text. This property and [TextButton.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextStrokeColor3) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextButton.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextColor3) and [TextButton.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextTransparency). Since text stroke is simply multiple renderings of the same transparency, this property is essentially multiplicative on itself four times over (e.g. a TextStrokeTransparency of 0.5 appears about the same as TextTransparency of 0.0625, or 0.5^4). Therefore, it's recommended to set TextStrokeTransparency to a value in the range of 0.75 to 1 for more a more subtle effect.
*/
TextStrokeTransparency: number;
/**
* The TextColor3 property determines the transparency of all the text rendered by a UI element. This property along with [TextButton.Font](https://developer.roblox.com/en-us/api-reference/property/TextButton/Font), [TextButton.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextSize) and [TextButton.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextColor3) will determine the visual properties of text. Text is rendered after the text stroke ([TextButton.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextStrokeTransparency)).
*
* Fading text in using a numeric for-loop is a fantastic way to draw a player's attention to text appearing on screen.
*
* \-- Count backwards from 1 to 0, decrementing by 0.1
* for i = 1, 0, -.1 do
* textLabel.TextTransparency = i
* wait(.1)
* end
*/
TextTransparency: number;
/**
* Controls the truncation of the text displayed in this TextButton.
*/
TextTruncate: Enum.TextTruncate;
/**
* This property determines whether or not text should wrap at the edges of the object.
*
* Tags: NotReplicated
* @deprecated Use `TextWrapped` instead
*/
TextWrap: boolean;
/**
* When enabled, this property will render text on multiple lines within a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextButton) element's space so that [TextButton.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextBounds) will never exceed the [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) of the UI element.
*
* This is achieved by breaking long lines of text into multiple lines. Line breaks will prefer whitespace; should a long unbroken word exceed the width of the element, that word will be broken into multiple lines.
*
* If further line breaks would cause the vertical height of the text (the Y component of [TextButton.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextBounds)) to exceed the vertical height of the element (the Y component of [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize)), then that line will not be rendered at all.
*/
TextWrapped: boolean;
/**
* TextXAlignment determines the horizontal alignment (X-axis) of text rendered within a UI element's space. It functions similarly to the CSS text-align property, with left, right and center values (there is no justify option). For Left and Right, text is rendered such that the left/right text bounds just touch the edge of the UI element rectangle. For Center, each line of text is centered on the very center of the UI element rectangle.
*
* This property is used in conjunction with [TextButton.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextYAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextButton.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextBounds) and [TextButton.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextFits).
*/
TextXAlignment: Enum.TextXAlignment;
/**
* TextYAlignment determines the vertical alignment (Y-axis) of text rendered within a UI element's space. For Top and Bottom, text is rendered such that the top/bottom text bounds just touch the edge of the UI element rectangle. For Center, text is rendered such that there is an equal space from the top bounds of the text to the top of the element and the bottom bounds of the text to the bottom of the element.
*
* This property is used in conjunction with [TextButton.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextXAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextButton.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextBounds) and [TextButton.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextButton/TextFits).
*/
TextYAlignment: Enum.TextYAlignment;
}
/** GuiLabel is an abstract class that inherits from [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject). It is the base class for [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel) and [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel). Unlike [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton), objects of this type will not register click events, but instead serve as non-interactive labels. It does not implement any further properties, events or methods. */
interface GuiLabel extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiLabel: unique symbol;
}
/** An ImageLabel renders a rectangle, like a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) does, with an image. The image must be a decal uploaded to the Roblox website. The display of the image can be manipulated through the [ImageLabel.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageColor3) and [ImageLabel.ImageTransparency](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageTransparency) properties. To display only the image and hide the rectangle, set [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) to 1.
*
* The image is scaled to fit the entirety of the rectangle, but remember that images look best when displayed at their native resolution. Before uploading your image asset, you may want to apply alpha bleeding and take a few more steps when building UI for high-DPI devices (like phones).
*
* Advanced ImageLabel usage
* -------------------------
*
* * **Spritesheets** can be used with ImageLabel through the use of [ImageLabel.ImageRectOffset](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectOffset) and [ImageLabel.ImageRectSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectSize). Packing multiple images into one and using this property can make your game's image assets load much quicker, especially if you use many small icons in your GUIs.
* * 9-slice images can be created by setting [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) to `Enum.ScaleType.Slice`, then [ImageLabel.SliceCenter](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/SliceCenter) to the center area of the 9-slice image.
* * Tiled images can be created by setting [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) to `Enum.ScaleType.Tiled`, then [ImageLabel.TileSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/TileSize) to be the size of rendered tiles.
*/
interface ImageLabel extends GuiLabel {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ImageLabel: unique symbol;
/**
* The Image property is a content-type property that should hold the asset ID of a Decal or Image on the Roblox website. It functions identically to [Decal.Texture](https://developer.roblox.com/en-us/api-reference/property/Decal/Texture) with regards to loading the image from the Roblox website. The rendered image will be colorized using [ImageLabel.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageColor3). It is possible to make the image render as tiled, scaled to fit, or 9-sliced, by adjusting the [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) property.
*/
Image: string;
/**
* The ImageColor3 property determines how an image is colorized. When set to white, no colorization occurs. This property is very useful for reusing image assets: If the source image is completely white with transparency, you can set the entire color of the image at once with this property.
*/
ImageColor3: Color3;
/**
* Allows the partial display of an image in conjunction with [ImageLabel.ImageRectSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectSize). This property determines the pixel offset (from the top-left) of the image area to be displayed.
*
* This property behaves identically to [ImageButton.ImageRectSize](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageRectSize).
*/
ImageRectOffset: Vector2;
/**
* Allows the partial display of an image in conjunction with [ImageLabel.ImageRectOffset](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageRectOffset). This property determines the pixel size of the image area to be displayed. If either dimension is set to 0, the entire image is displayed instead.
*
* This property behaves identically to [ImageButton.ImageRectOffset](https://developer.roblox.com/en-us/api-reference/property/ImageButton/ImageRectOffset).
*/
ImageRectSize: Vector2;
/**
* ImageTransparency determines the alpha of a UI element's rendered image. A value of 0 is completely opaque, and a value of 1 is completely transparent (invisible). This property behaves similarly to [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) or [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency).
*/
ImageTransparency: number;
/**
* The IsLoaded property indicates if the [ImageLabel.Image](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/Image) property finished loading from the Roblox website. Images declined by moderation will never load.
*
* Tags: NotReplicated
*/
readonly IsLoaded: boolean;
/**
* Determines how the image looks when it is scaled.
*
* By default, the image smooths out texture when displayed on the screen larger or smaller than its size in texture memory. When set to [Enum.ResamplerMode.Pixelated](https://developer.roblox.com/en-us/api-reference/enum/ResamplerMode.Pixelated), the image preserves the sharp edges of pixels.
*/
ResampleMode: Enum.ResamplerMode;
/**
* The ScaleType property determines in what way an [ImageLabel.Image](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/Image) is rendered when the UI element's absolute size differs from the source image's size.
*
* By default, this property is [Enum.ScaleType.Stretch](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Stretch), which will simply stretch/compact the image dimensions so it fits the UI element's space exactly. Since transparent pixels are set to black when uploading to the Roblox website, transparent images should apply alpha blending to avoid a blackish outline around scaled images.
*
* For [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice), the [ImageLabel.SliceCenter](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/SliceCenter) property will be revealed in the Properties window. This is for nine-slice UI: when scaling up, the corners will remain the source image size. The edges of the image will stretch to the width/height of the image. Finally, the center of the image will stretch to fill the center area of the image.
*
* Finally, for [Enum.ScaleType.Tile](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Tile), the [ImageLabel.TileSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/TileSize) property will be revealed in the Properties window. This is for tiled images, where the size of each image tile is determined by the [ImageLabel.TileSize](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/TileSize) property.
*/
ScaleType: Enum.ScaleType;
/**
* The SliceCenter property sets the slice boundaries of a 9-sliced image when [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) is set to [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice). Please note that this property is only visible in the Studio Properties Pane if [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) is set to [Enum.ScaleType.Slice](https://developer.roblox.com/en-us/api-reference/class/Enum/ScaleType/Slice).
* Select this property and click the “…” button to open the 9-Slice Editor, a built-in visual editor for setting the slice boundaries.
*
* To learn more about 9-sliced images, check out this tutorial: [UI 9 Slice Design](https://developer.roblox.com/articles/ui-9-slice-design).
*/
SliceCenter: Rect;
/**
* Scales the 9slice edges by the specified ratio. This means that the edges around the 9slice will grow as if you'd uploaded a new version of the texture upscaled. Defaults to 1.0.
*
* As a multiplier for the borders of a 9slice, it is useful for reusing one rounded corner image for multiple radii.
*
* 
*
* See also
* --------
*
* * [ImageLabel.ScaleType](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ScaleType) - Determines how an image will scale if displayed in a UI element whose size differs from the source image.
* * [ImageLabel.SliceCenter](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/SliceCenter) - Determines the center of a 9slice image.
* * [ImageLabel.SliceScale](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/SliceScale) - The same property in terms of functionality but for [ImageLabels](https://developer.roblox.com/en-us/api-reference/class/ImageLabel).
*/
SliceScale: number;
/**
* TileSize sets the tiling size of the ImageLabel. The default `UDim2` values are 1,0,1,0. The scale component of the UDim2 will scale the tile based on the size of the ImageLabel. The offset is in raw pixels. The tiling starts at the upper left-hand corner of the image. For example a scale of 0.5 will mean the tile will be half the size of the ImageLabel (in the corresponding axis).
*
* This property is only active if the ScaleType for the ImageLabel is set to Tile instead of Slice or Stretch.
*/
TileSize: UDim2;
}
/** A TextLabel renders a rectangle, like a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame), with styled text. The rectangle can be used to define text boundaries, text scaling ([TextLabel.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextScaled)) and wrapping ([TextLabel.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextWrapped), [TextLabel.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextXAlignment), [TextLabel.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextYAlignment)).
*
* This class contains properties that control the display of the text, such as [TextLabel.Font](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Font) and [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3). All text rendered by a single text label will have the same visual properties; multiple TextLabel objects must be used in order to render multiple styles of text. To display only text and hide the rectangle, set [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) to 1.
*
* [TextService:GetTextSize](https://developer.roblox.com/en-us/api-reference/function/TextService/GetTextSize) can be used to get the size (bounds) of text that would be rendered in a TextLabel given a font size, font, and frame size.
*
* A [UITextSizeConstraint](https://developer.roblox.com/en-us/api-reference/class/UITextSizeConstraint) object can be used to constrain the size of text with [TextLabel.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextScaled) enabled. It is recommended that the size of text is no lower than 9, otherwise it may not be visible to most users. See [Accessibility Best Practices](https://developer.roblox.com/en-us/articles/accessibility-best-practices) for more information.
*/
interface TextLabel extends GuiLabel {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TextLabel: unique symbol;
/**
* This property provides a copy of [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text) that contains exactly what is being rendered by the [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel). This is useful for eliminating style tags used for rich text.
*
* Example
* -------
*
* When [TextLabel.RichText](https://developer.roblox.com/en-us/api-reference/property/TextLabel/RichText) is enabled, the [TextLabel.ContentText](https://developer.roblox.com/en-us/api-reference/property/TextLabel/ContentText) property shows the text as it appears to the player.
*
* RichText
*
* Text
*
* ContentText
*
* false
*
* Hello,
world!
*
* Hello,
world!
*
* true
*
* Hello,
world!
*
* Hello,
* world!
*
* Tags: NotReplicated
*/
readonly ContentText: string;
/**
* The Font property selects one of several pre-defined fonts with which the UI element will render its text. Some fonts have bold, italic and/or light variants (as there is no font-weight or font-style properties).
*
* With the exception of the “Legacy” font, each font will render text with the line height equal to the [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) property. The “Code” font is the only monospace font. It has the unique property that each character has the exact same width and height ratio of 1:2. The width of each character is approximately half the [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) property.
*
* Tags: Hidden, NotReplicated
*/
Font: Enum.Font;
FontFace: Font;
/**
* This property determines the height in offsets of one line of text.
*
* Tags: NotReplicated
* @deprecated Use `TextSize` instead
*/
FontSize: Enum.FontSize;
/**
* Controls the height of lines, as a multiple of the font's em square size, by scaling the spacing between lines of text in the [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel). Valid values range from 1.0 to 3.0, defaulting to 1.0.
*/
LineHeight: number;
/**
* This property sets whether a [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) should be [GuiBase2d.Localize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/Localize) or not.
*
* Tags: Hidden, NotReplicated
*/
readonly LocalizedText: string;
/**
* This property controls the maximum number of graphemes (or units of text) that are shown on the [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel). It is primarily provided as an easy way to create a “typewriter effect” where the characters appear one at a time.
*
* Changing the property does not change the position or size of the visible graphemes - the layout will be calculated as if all graphemes are visible.
*
* Setting the property to -1 disables the limit and shows the entirety of the [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text).
*/
MaxVisibleGraphemes: number;
/**
* This property determines whether the [TextLabel](https://developer.roblox.com/en-us/api-reference/class/TextLabel) renders the [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text) string using rich text formatting. Rich text uses simple markup tags to style sections of the string in bold, italics, specific colors, and more.
*
* To use rich text, simply include formatting tags in the [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text) string. Reference on formatting tags can be found in the [Using Rich Text](https://developer.roblox.com/en-us/articles/gui-rich-text) article.
*/
RichText: boolean;
/**
* The Text property determines the content rendered by the UI element. The visual properties of the string rendered to the screen is determined by [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3), [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency), [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize), [TextLabel.Font](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Font), [TextLabel.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextScaled), [TextLabel.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextWrapped), [TextLabel.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextXAlignment) and [TextLabel.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextYAlignment).
*
* It is possible to render emoji (for example, 😃) and other symbols. These special symbols aren't affected by the [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3) property. These can be pasted into [Script](https://developer.roblox.com/en-us/api-reference/class/Script) and [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) objects, as well as the field within the Properties window.
*
* This property may contain newline characters, however, it is not possible to type newline characters within the Properties window. Similarly, this property may contain a tab character, but it will render as a space instead.
*/
Text: string;
/**
* The read-only property TextBounds reflects the absolute size of rendered text in offsets. In other words, if you were to try to fit text into a rectangle, this property would reflect the minimum dimensions of the rectangle you would need in order to fit the text.
*
* Using [TextService:GetTextSize](https://developer.roblox.com/en-us/api-reference/function/TextService/GetTextSize), you can predict what TextBounds will be on a TextLabel given a string, [TextLabel.Font](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Font), [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) and frame size.
*
* Tags: NotReplicated
*/
readonly TextBounds: Vector2;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
TextColor: BrickColor;
/**
* This property determines the color of all the text rendered by a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextLabel) element. This property along with [TextLabel.Font](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Font), [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) and [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency) will determine the visual properties of text. Text is rendered after the text stroke ([TextLabel.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeColor3)).
*
* It's important that text is easily read by players! Be sure to choose colors with little-to-no saturation, like white, grey, or black. Make sure the color of your text is contrasted by the `TextLabel/BackgroundColor3` of the GUI element. If the element has a transparent background, try applying a black [TextLabel.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeColor3) to help contrast the text with the 3D world behind it.
*/
TextColor3: Color3;
TextDirection: Enum.TextDirection;
/**
* The TextFits is a read-only property that is false if [TextLabel.Text](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Text) content does not fit within the [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) when rendered. If [TextLabel.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextWrapped) is true, a false value indicates that some text is truncated and not rendering. Otherwise, it indicates if the line of text is rendering outside the UI element's rectangle. If [TextLabel.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextScaled) is enabled, this property will be disabled when text must be scaled down in order to fit.
*
* Tags: NotReplicated
*/
readonly TextFits: boolean;
/**
* **Note**
*
* Rather than using TextScaled, we recommend you consider using [AutomaticSize](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AutomaticSize), a new method to dynamically size UI that will give you the best visual result possible.
*
* The TextScaled property determines whether text is scaled so that it fills the entire UI element's space. When this is enabled, [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) is ignored and [TextLabel.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextWrapped) is automatically enabled. This property is useful for text-rendering UI elements within [BillboardGuis](https://developer.roblox.com/en-us/api-reference/class/BillboardGui).
*
* When this property is used for screen-space UI, it may be desirable to use a [UITextSizeConstraint](https://developer.roblox.com/en-us/api-reference/class/UITextSizeConstraint) to restrict the range of possible text sizes.
*
* TextScaled and AutomaticSize
* ----------------------------
*
* It's recommended that developers avoid usage of TextScaled and adjust UI to take advantage of the AutomaticSize property instead. Here are the core differences between the two properties:
*
* * TextScaled scales the content (text) to accommodate the UI. Without careful consideration, some text may become unreadable if scaled too small.
* * AutomaticSize resizes the UI to accommodate content.
*
* With AutomaticSize, you're able to adjust your UI to accommodate the content (text) while maintaining a consistent font size. For more information on how to use automatic sizing, see the UI Automatic Size article.
*
* We suggest that you don't apply both TextScaled and AutomaticSize on the same UI object. If you apply both properties:
*
* * AutomaticSize determines the maximum amount of available space that a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) can use (in this case, text)
* * TextScaled uses the available space determined by AutomaticSize, to scale the font size to fit the available space, which will expand up to the maximum font size (100), if there are no size constraints
* * The end result will be: text goes to 100 font size and the UI object will expand to fit that text
*
* Using both AutomaticSize and TextScaled at the same time can result in significant scaling differences than when AutomaticSize is off. Here is an example of an automatically sized TextLabel (with no minimum size) that has TextScaled enabled:
*
* 
*
* Note how automatic size changes the TextLabel's size relative to the parent frame's size. Subsequently, as the TextLabel is resized, the TextScaled property scales the text to the maximum amount of space available by the automatically sized TextLabel.
*/
TextScaled: boolean;
/**
* The TextSize property determines the height in offsets of one line of rendered text. The unit is in offsets, not points (which is used in most document editing programs). It's worth noting that the “Legacy” font's line height behaves differently, and won't match this property exactly.
*
* This property and [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3), [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency), [TextLabel.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeColor3) and [TextLabel.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeTransparency) each influence the way text is rendered.
*
* This property supersedes [TextLabel.FontSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/FontSize) since it is a number and not an enum. Internally, Roblox uses several sets of pre-rendered character images for each size of each font. It chooses the closest size to TextSize, then scales that set of character images to render text. Before the introduction of this property, you could only pick from the pre-rendered sizes, which were listed by the [FontSize](https://developer.roblox.com/en-us/api-reference/enum/FontSize) enum.
*/
TextSize: number;
/**
* The TextStrokeColor3 property sets the color of the stroke, or outline, of rendered text. This property and [TextLabel.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeTransparency) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3) and [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency).
*/
TextStrokeColor3: Color3;
/**
* .The TextStrokeTransparency property sets the transparency of the stroke, or outline, of rendered text. This property and [TextLabel.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeColor3) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3) and [TextLabel.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextTransparency). Since text stroke is simply multiple renderings of the same transparency, this property is essentially multiplicative on itself four times over (e.g. a TextStrokeTransparency of 0.5 appears about the same as TextTransparency of 0.0625, or 0.5^4). Therefore, it's recommended to set TextStrokeTransparency to a value in the range of 0.75 to 1 for more a more subtle effect.
*/
TextStrokeTransparency: number;
/**
* The TextColor3 property determines the transparency of all the text rendered by a UI element. This property along with [TextLabel.Font](https://developer.roblox.com/en-us/api-reference/property/TextLabel/Font), [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) and [TextLabel.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextColor3) will determine the visual properties of text. Text is rendered after the text stroke ([TextLabel.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextStrokeTransparency)).
*
* Fading text in using a numeric for-loop is a fantastic way to draw a player's attention to text appearing on screen.
*
* \-- Count backwards from 1 to 0, decrementing by 0.1
* for i = 1, 0, -.1 do
* textLabel.TextTransparency = i
* wait(.1)
* end
*/
TextTransparency: number;
/**
* Controls the truncation of the text displayed in this TextLabel.
*/
TextTruncate: Enum.TextTruncate;
/**
* This property determines if text wraps to multiple lines within the [GUI](https://developer.roblox.com/en-us/api-reference/class/TextLabel) element space, truncating excess text.
*
* Tags: NotReplicated
* @deprecated Use `TextWrapped` instead
*/
TextWrap: boolean;
/**
* When enabled, this property will render text on multiple lines within a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextLabel) element's space so that [TextLabel.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextBounds) will never exceed the [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) of the UI element.
*
* This is achieved by breaking long lines of text into multiple lines. Line breaks will prefer whitespace; should a long unbroken word exceed the width of the element, that word will be broken into multiple lines.
*
* If further line breaks would cause the vertical height of the text (the Y component of [TextLabel.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextBounds)) to exceed the vertical height of the element (the Y component of [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize)), then that line will not be rendered at all.
*/
TextWrapped: boolean;
/**
* TextXAlignment determines the horizontal alignment (X-axis) of text rendered within a UI element's space. It functions similarly to the CSS text-align property, with left, right and center values (there is no justify option). For Left and Right, text is rendered such that the left/right text bounds just touch the edge of the UI element rectangle. For Center, each line of text is centered on the very center of the UI element rectangle.
*
* This property is used in conjunction with [TextLabel.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextYAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextLabel.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextBounds) and [TextLabel.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextFits).
*/
TextXAlignment: Enum.TextXAlignment;
/**
* TextYAlignment determines the vertical alignment (Y-axis) of text rendered within a UI element's space. For Top and Bottom, text is rendered such that the top/bottom text bounds just touch the edge of the UI element rectangle. For Center, text is rendered such that there is an equal space from the top bounds of the text to the top of the element and the bottom bounds of the text to the bottom of the element.
*
* This property is used in conjunction with [TextLabel.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextXAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextLabel.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextBounds) and [TextLabel.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextFits).
*/
TextYAlignment: Enum.TextYAlignment;
}
/** The ScrollingFrame is a special [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) that handles all scrolling for you, with a range of different ways to customize how the scrolling works. An in-depth tutorial for the ScrollingFrame can be found [here](https://developer.roblox.com/articles/Creating-a-Scrolling-Frame-GUI). */
interface ScrollingFrame extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ScrollingFrame: unique symbol;
/**
* Tags: NotReplicated
*/
readonly AbsoluteCanvasSize: Vector2;
/**
* The size in pixels of the frame, without the scrollbars.
*
* Tags: NotReplicated
*/
readonly AbsoluteWindowSize: Vector2;
/**
* This property is used to automatically size parent UI objects based on the size of its descendants. Developers can use this property to dynamically add text and other content to a UI object at edit or run time, and the size will adjust to fit that content.
*
* When AutomaticCanvasSize is set to an [Enum.AutomaticSize](https://developer.roblox.com/en-us/api-reference/enum/AutomaticSize) value to anything other than None, [ScrollingFrame.CanvasSize](https://developer.roblox.com/en-us/api-reference/property/ScrollingFrame/CanvasSize) may resize depending on its child content.
*
* For more information on how to use this property and how it works, please see the following article: [How to use AutomaticSize](../../../articles/ui-automaticsize).
*/
AutomaticCanvasSize: Enum.AutomaticSize;
/**
* The Down image on the vertical scrollbar. Size of this is always ScrollBarThickness by ScrollBarThickness. This is also used as the image on the horizontal scroll bar.
*/
BottomImage: string;
/**
* The location within the canvas, in pixels, that should be drawn at the top left of the scroll frame
*/
CanvasPosition: Vector2;
/**
* Determines the size of the area that is scrollable. The UDim2 is calculated using the parent gui's size, similar to the regular Size property on gui objects.
*/
CanvasSize: UDim2;
/**
* This property determines when elastic scrolling is allowed. It can be used to dictate if and when the [ScrollingFrame](https://developer.roblox.com/en-us/api-reference/class/ScrollingFrame) canvas is elastic. Defaults to WhenScrollable.
*
* What's the Differences Between Elastic and Non-Elastic
* ------------------------------------------------------
*
* ### Elastic
*
* The image below demonstrates Enum.Elasticity.Always an Enum.Elasticity.WhenScrollable when the canvas is scrollable:
* 
*
* ### Non-Elastic
*
* The image below demonstrates Enum.Elasticity.Never:
* 
*
* Enums
* -----
*
* It can be set to several [ElasticBehavior](https://developer.roblox.com/en-us/api-reference/enum/ElasticBehavior) enum values, which determine how elastic scrolling behaves:
*
* Name
*
* Description
*
* Always
*
* Regardless of scrolling, you can always move the canvas a bit outside the bounds
*
* Never
*
* You can never move the canvas outside the rect bounds
*
* WhenScrollable
*
* (default) Elastic scrolling is allowed when canvas size is larger than the rect size
*
* See also
* --------
*
* * [ScrollingFrame.ScrollingDirection](https://developer.roblox.com/en-us/api-reference/property/ScrollingFrame/ScrollingDirection), the direction scrolling is allowed in this scrolling frame
*/
ElasticBehavior: Enum.ElasticBehavior;
/**
* Indicates the inset behavior of the horizontal scrolling bar.
*/
HorizontalScrollBarInset: Enum.ScrollBarInset;
/**
* The middle image on the vertical scrollbar. The size of this can vary in the y direction, but is always set as [ScrollingFrame.ScrollBarThickness](https://developer.roblox.com/en-us/api-reference/property/ScrollingFrame/ScrollBarThickness) in the x direction. This is also used as the middle image on the horizontal scroll bar.
*/
MidImage: string;
/**
* Determines how a scrolling bar image is colorized. When set to white, no colorization occurs. This property is very useful for reusing image assets: If the source image is completely white with transparency, you can set the entire color of the image at once with this property.
*/
ScrollBarImageColor3: Color3;
/**
* Determines the alpha of a scroll bar's rendered image. A value of 0 is completely opaque, and a value of 1 is completely transparent (invisible). This property behaves similarly to [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) or [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency).
*/
ScrollBarImageTransparency: number;
/**
* How thick the scroll bar appears. This applies to both the horizontal and vertical scroll bars. If set to 0, no scroll bars are rendered.
*/
ScrollBarThickness: number;
/**
* This property determines the direction scrolling is allowed. If scrolling is disallowed in a direction, the scrollbar will not appear. Defaults to XY.
*
* What are the Different Scrolling Directions
* -------------------------------------------
*
* ### XY (Default)
*
* The image below demonstrates Enum.ScrollingDirection.XY:
* 
*
* ### X
*
* The image below demonstrates Enum.ScrollingDirection.X:
* 
*
* ### Y
*
* The image below demonstrates Enum.ScrollingDirection.Y:
* 
*
* Enums
* -----
*
* It can be set to several [ScrollingDirection](https://developer.roblox.com/en-us/api-reference/enum/ScrollingDirection) enum values, which determine how elastic scrolling behaves:
*
* Name
*
* Description
*
* XY
*
* (default) Canvas can be scrolled along both X and Y axes
*
* X
*
* Canvas can only be scrolled along the X axis
*
* Y
*
* Canvas can only be scrolled along the Y axis
*
* See also
* --------
*
* * [ScrollingFrame.ElasticBehavior](https://developer.roblox.com/en-us/api-reference/property/ScrollingFrame/ElasticBehavior), how elastic scrolling behaves for touch input
*/
ScrollingDirection: Enum.ScrollingDirection;
/**
* Determines whether or not scrolling is allowed on the frame. If false, no scroll bars will be rendered.
*/
ScrollingEnabled: boolean;
/**
* The Up image on the vertical scrollbar. The size of this is always ScrollBarThickness by ScrollBarThickness. This is also used as the left image on the horizontal scroll bar.
*/
TopImage: string;
/**
* Indicates the inset behavior of the vertical scrolling bar.
*/
VerticalScrollBarInset: Enum.ScrollBarInset;
/**
* Indicates the side that the vertical scrollbar will be located at.
*/
VerticalScrollBarPosition: Enum.VerticalScrollBarPosition;
}
/** 
*
* A **TextBox** allows the player to provide text input. It behaves similarly to a [TextButton](https://developer.roblox.com/en-us/api-reference/class/TextButton), except that a single TextBox can be put in focus by clicking, tapping or gamepad selection. While in focus, the player can use a keyboard to change the [Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) property.
*
* * If there is no text, the [PlaceholderText](https://developer.roblox.com/en-us/api-reference/property/TextBox/PlaceholderText) will be visible. This is useful prompting players of the kind or format of data they should input.
* * By default, the [ClearTextOnFocus](https://developer.roblox.com/en-us/api-reference/property/TextBox/ClearTextOnFocus) property is enabled and ensures there is no existing text when a TextBox is focused. This may not be desirable for text that should be editable by the player.
* * The [MultiLine](https://developer.roblox.com/en-us/api-reference/property/TextBox/MultiLine) property allows players to enter multiple lines of text with newline characters (`\n`).
*
* The [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService) honors TextBox keybinds and will automatically prevent key press events from being passed to actions bound with [ContextActionService:BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction). [UserInputService.InputBegan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputBegan) and related events will still fire while a TextBox is in focus.
*
* Focus State
* -----------
*
* It is possible to detect and change the focus state of a TextBox:
*
* * You can use [CaptureFocus](https://developer.roblox.com/en-us/api-reference/function/TextBox/CaptureFocus) when a dialogue appears so that the player doesn't have to click on a TextBox when it becomes available; you can use [ContextActionService:BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) to bind a certain key to focus a TextBox using this function. When a TextBox comes into focus, the [Focused](https://developer.roblox.com/en-us/api-reference/event/TextBox/Focused) event fires.
* * You can detect if a certain TextBox is in focus by using [IsFocused](https://developer.roblox.com/en-us/api-reference/function/TextBox/IsFocused). Alternatively, [UserInputService:GetFocusedTextBox](https://developer.roblox.com/en-us/api-reference/function/UserInputService/GetFocusedTextBox) can be used to check if any TextBox is in focus.
* * When the player is done inputting text, the [FocusLost](https://developer.roblox.com/en-us/api-reference/event/TextBox/FocusLost) event fires, indicating if the user pressed Enter to submit text along with the [InputObject](https://developer.roblox.com/en-us/api-reference/class/InputObject) that caused the loss of focus. When using on screen keyboards on mobile and console, [ReturnPressedFromOnScreenKeyboard](https://developer.roblox.com/en-us/api-reference/event/TextBox/ReturnPressedFromOnScreenKeyboard) may also fire.
* * If some more important matter comes up during gameplay, you can [ReleaseFocus](https://developer.roblox.com/en-us/api-reference/function/TextBox/ReleaseFocus) of the TextBox so that a player's keyboard input returns to your game.
*
* Text Editing
* ------------
*
* 
*
* A TextBox supports text selection through its [CursorPosition](https://developer.roblox.com/en-us/api-reference/property/TextBox/CursorPosition) and [SelectionStart](https://developer.roblox.com/en-us/api-reference/property/TextBox/SelectionStart) properties. Using [GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal), you can detect when a selection changes. Additionally, it is possible for players to copy and paste text within a TextBox, enabling basic clipboard support.
*
* **Text Filtering Notice**
* Games that facilitate player-to-player communication using text, such as custom chat or nametags, must properly filter such text using [TextService:FilterStringAsync](https://developer.roblox.com/en-us/api-reference/function/TextService/FilterStringAsync) or [Chat:FilterStringAsync](https://developer.roblox.com/en-us/api-reference/function/Chat/FilterStringAsync). If this is not properly done, your game may receive moderation action.
*/
interface TextBox extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TextBox: unique symbol;
/**
* Determines whether clicking on the TextBox will clear its [TextBox.Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) property
*/
ClearTextOnFocus: boolean;
/**
* Tags: NotReplicated
*/
readonly ContentText: string;
/**
* **CursorPosition** determines the offset of the text cursor in bytes, or -1 if the TextBox is not currently being edited. A value of 1 represents the beginning, the position before the first byte in the [Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) property. When used in conjunction with the [SelectionStart](https://developer.roblox.com/en-us/api-reference/property/TextBox/SelectionStart) property, it is possible to both get and set selected text within a TextBox.
*
* 
*
* It should be noted that the units of this property is **bytes** and that many unicode characters such as emoji are **longer than 1 byte**. For instance, if a player types into the TextBox “Hello👋” – “Hello” immediately followed by the waving hand sign – the cursor position would be 10, not 7, since the emoji uses 4 bytes.
*/
CursorPosition: number;
/**
* The Font property selects one of several pre-defined [fonts](https://developer.roblox.com/en-us/api-reference/enum/Font) with which the UI element will render its text. Some fonts have bold, italic and/or light variants (as there is no font-weight or font-style properties).
*
* With the exception of the “Legacy” font, each font will render text with the line height equal to the [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) property. The “Code” font is the only monospace font. It has the unique property that each character has the exact same width and height ratio of 1:2. The width of each character is approximately half the [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) property.
*
* Tags: Hidden, NotReplicated
*/
Font: Enum.Font;
FontFace: Font;
/**
* This property determines the font size of a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextBox) object.
*
* Tags: NotReplicated
* @deprecated Use `TextSize` instead
*/
FontSize: Enum.FontSize;
/**
* Controls the height of lines, as a multiple of the font's em square size, by scaling the spacing between lines of text in the [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox). Valid values range from 1.0 to 3.0, defaulting to 1.0.
*/
LineHeight: number;
/**
* This property controls the maximum number of graphemes (or units of text) that are shown on the [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox), regardless of whether it's showing the [TextBox.PlaceholderText](https://developer.roblox.com/en-us/api-reference/property/TextBox/PlaceholderText) or [TextBox.Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text).
*
* Changing the property does not change the position or size of the visible graphemes - the layout will be calculated as if all graphemes are visible.
*
* Setting the property to -1 disables the limit and shows the entirety of the [TextBox.Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text).
*/
MaxVisibleGraphemes: number;
/**
* When set to true, text inside a TextBox is able to move onto multiple lines. This also enables players to use the enter key to move onto a new line.
*/
MultiLine: boolean;
/**
* Sets the text color that gets used when no text has been entered into the TextBox yet.
*/
PlaceholderColor3: Color3;
/**
* Sets the text that gets displayed when no text has been entered into the TextBox yet.
*/
PlaceholderText: string;
/**
* This property determines whether the [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox) renders the [TextBox.Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) string using rich text formatting. Rich text uses simple markup tags to style sections of the string in bold, italics, specific colors, and more.
*
* To use rich text, simply include formatting tags in the [TextBox.Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) string. Reference on formatting tags can be found in the [Using Rich Text](https://developer.roblox.com/en-us/articles/gui-rich-text) article.
*
* Note that when the [TextBox](https://developer.roblox.com/en-us/api-reference/class/TextBox) has this property enabled and the box gains focus, the user will be able to edit and interact with the complete XML string, including all of the formatting tags. When focus is lost, the text will automatically parse and render the tags as rich text.
*/
RichText: boolean;
/**
* Determines the starting position of a text selection, or -1 if the TextBox has no range of selected text. If the value is -1 or equivalent to [CursorPosition](https://developer.roblox.com/en-us/api-reference/property/TextBox/CursorPosition), there is no range of text selected. This property uses the same positioning logic as CursorPosition. SelectionStart will be greater than CursorPosition if the cursor is at the beginning of a selection, and less than CursorPosition if the cursor is at the end.
*/
SelectionStart: number;
/**
* If set to true, input native to the platform is used instead of Roblox's built-in keyboard.
*/
ShowNativeInput: boolean;
/**
* The Text property determines the content rendered by the UI element. The visual properties of the string rendered to the screen is determined by [TextBox.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextColor3), [TextBox.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextTransparency), [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize), [TextBox.Font](https://developer.roblox.com/en-us/api-reference/property/TextBox/Font), [TextBox.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextScaled), [TextBox.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextWrapped), [TextBox.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextXAlignment) and [TextBox.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextYAlignment).
*
* It is possible to render emoji (for example, 😃) and other symbols. These special symbols aren't affected by the [TextBox.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextColor3) property. These can be pasted into [Script](https://developer.roblox.com/en-us/api-reference/class/Script) and [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) objects, as well as the field within the Properties window.
*
* This property may contain newline characters, however, it is not possible to type newline characters within the Properties window. Similarly, this property may contain a tab character, but it will render as a space instead.
*/
Text: string;
/**
* The read-only property TextBounds reflects the absolute size of rendered text in offsets. In other words, if you were to try to fit text into a rectangle, this property would reflect the minimum dimensions of the rectangle you would need in order to fit the text.
*
* Using [TextService:GetTextSize](https://developer.roblox.com/en-us/api-reference/function/TextService/GetTextSize), you can predict what TextBounds will be on a TextLabel given a string, [TextBox.Font](https://developer.roblox.com/en-us/api-reference/property/TextBox/Font), [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) and frame size.
*
* Tags: NotReplicated
*/
readonly TextBounds: Vector2;
/**
* Tags: Hidden, NotReplicated
* @deprecated
*/
TextColor: BrickColor;
/**
* This property determines the color of all the text rendered by a [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) element. This property along with [TextBox.Font](https://developer.roblox.com/en-us/api-reference/property/TextBox/Font), [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) and [TextBox.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextTransparency) will determine the visual properties of text. Text is rendered after the text stroke ([TextBox.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextStrokeColor3)).
*
* It's important that text is easily read by players! Be sure to choose colors with little-to-no saturation, like white, grey, or black. Make sure the color of your text is contrasted by the `TextBox/BackgroundColor3` of the UI element. If the element has a transparent background, try applying a black [TextBox.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextStrokeColor3) to help contrast the text with the 3D world behind it.
*/
TextColor3: Color3;
TextDirection: Enum.TextDirection;
/**
* **TextEditable** determines whether the user can change the [Text](https://developer.roblox.com/en-us/api-reference/property/TextBox/Text) through input. It is recommended to disable [ClearTextOnFocus](https://developer.roblox.com/en-us/api-reference/property/TextBox/ClearTextOnFocus) when this property is disabled, otherwise the Text could be cleared on-focus. This property is useful to make read-only TextBoxes from which content can be copied in-game.
*/
TextEditable: boolean;
/**
* Whether the text fits within the constraints of the TextBox.
*
* Tags: NotReplicated
*/
readonly TextFits: boolean;
/**
* **Note**
*
* Rather than using TextScaled, we recommend you consider using [AutomaticSize](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AutomaticSize), a new method to dynamically size UI that will give you the best visual result possible.
*
* The TextScaled property determines whether text is scaled so that it fills the entire UI element's space. When this is enabled, [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) is ignored and [TextBox.TextWrapped](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextWrapped) is automatically enabled. This property is useful for text-rendering UI elements within [BillboardGuis](https://developer.roblox.com/en-us/api-reference/class/BillboardGui).
*
* When this property is used for screen-space UI, it may be desirable to use a [UITextSizeConstraint](https://developer.roblox.com/en-us/api-reference/class/UITextSizeConstraint) to restrict the range of possible text sizes.
*
* TextScaled and AutomaticSize
* ----------------------------
*
* It's recommended that developers avoid usage of TextScaled and adjust UI to take advantage of the AutomaticSize property instead. Here are the core differences between the two properties:
*
* * TextScaled scales the content (text) to accommodate the UI. Without careful consideration, some text may become unreadable if scaled too small.
* * AutomaticSize resizes the UI to accommodate content.
*
* With AutomaticSize, you're able to adjust your UI to accommodate the content (text) while maintaining a consistent font size. For more information on how to use automatic sizing, see the UI Automatic Size article.
*
* We suggest that you don't apply both TextScaled and AutomaticSize on the same UI object. If you apply both properties:
*
* * AutomaticSize determines the maximum amount of available space that a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) can use (in this case, text)
* * TextScaled uses the available space determined by AutomaticSize, to scale the font size to fit the available space, which will expand up to the maximum font size (100), if there are no size constraints
* * The end result will be: text goes to 100 font size and the UI object will expand to fit that text
*
* Using both AutomaticSize and TextScaled at the same time can result in significant scaling differences than when AutomaticSize is off. Here is an example of an automatically sized TextLabel (with no minimum size) that has TextScaled enabled:
*
* 
*
* Note how automatic size changes the TextLabel's size relative to the parent frame's size. Subsequently, as the TextLabel is resized, the TextScaled property scales the text to the maximum amount of space available by the automatically sized TextLabel.
*/
TextScaled: boolean;
/**
* The TextSize property determines the height in offsets of one line of rendered text. The unit is in offsets, not points (which is used in most document editing programs). The “Legacy” font does not hold this property.
*/
TextSize: number;
/**
* The TextStrokeColor3 property sets the color of the stroke, or outline, of rendered text. This property and [TextBox.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextStrokeTransparency) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextBox.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextColor3) and [TextBox.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextTransparency).
*/
TextStrokeColor3: Color3;
/**
* .The TextStrokeTransparency property sets the transparency of the stroke, or outline, of rendered text. This property and [TextBox.TextStrokeColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextStrokeColor3) determine the visual properties of the text stroke.
*
* Text stroke is rendered before normal text and is simply 4 renderings of the same text in +/- 1 pixel offsets in each direction. Text stroke rendering works independently and identically to [TextBox.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextColor3) and [TextBox.TextTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextTransparency). Since text stroke is simply multiple renderings of the same transparency, this property is essentially multiplicative on itself four times over (e.g. a TextStrokeTransparency of 0.5 appears about the same as TextTransparency of 0.0625, or 0.5^4). Therefore, it's recommended to set TextStrokeTransparency to a value in the range of 0.75 to 1 for more a more subtle effect.
*/
TextStrokeTransparency: number;
/**
* The TextColor3 property determines the transparency of all the text rendered by a UI element. This property along with [TextBox.Font](https://developer.roblox.com/en-us/api-reference/property/TextBox/Font), [TextBox.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextSize) and [TextBox.TextColor3](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextColor3) will determine the visual properties of text. Text is rendered after the text stroke ([TextBox.TextStrokeTransparency](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextStrokeTransparency)).
*
* Fading text in using a numeric for-loop is a fantastic way to draw a player's attention to text appearing on screen.
*
* \-- Count backwards from 1 to 0, decrementing by 0.1
* for i = 1, 0, -.1 do
* textLabel.TextTransparency = i
* wait(.1)
* end
*/
TextTransparency: number;
/**
* Controls the truncation of the text displayed in this TextBox.
*/
TextTruncate: Enum.TextTruncate;
/**
* Tags: NotReplicated
* @deprecated Use `TextWrapped` instead
*/
TextWrap: boolean;
/**
* When enabled, this property will render text on multiple lines within a [GUI](https://developer.roblox.com/en-us/api-reference/class/TextBox) element's space so that [TextBox.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextBounds) will never exceed the [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize) of the GUI element.
*
* This is achieved by breaking long lines of text into multiple lines. Line breaks will prefer whitespace; should a long unbroken word exceed the width of the element, that word will be broken into multiple lines.
*
* If further line breaks would cause the vertical height of the text (the Y component of [TextBox.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextBounds)) to exceed the vertical height of the element (the Y component of [GuiBase2d.AbsoluteSize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AbsoluteSize)), then that line will not be rendered at all.
*/
TextWrapped: boolean;
/**
* TextXAlignment determines the horizontal alignment (X-axis) of text rendered within a UI element's space. It functions similarly to the CSS text-align property, with left, right and center values (there is no justify option). For Left and Right, text is rendered such that the left/right text bounds just touch the edge of the UI element rectangle. For Center, each line of text is centered on the very center of the UI element rectangle.
*
* This property is used in conjunction with [TextBox.TextYAlignment](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextYAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextBox.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextBounds) and [TextBox.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextFits).
*/
TextXAlignment: Enum.TextXAlignment;
/**
* TextYAlignment determines the vertical alignment (Y-axis) of text rendered within a UI element's space. For Top and Bottom, text is rendered such that the top/bottom text bounds just touch the edge of the UI element rectangle. For Center, text is rendered such that there is an equal space from the top bounds of the text to the top of the element and the bottom bounds of the text to the bottom of the element.
*
* This property is used in conjunction with [TextBox.TextXAlignment](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextXAlignment) to fully determine text alignment on both axes. This property won't affect the read-only properties [TextBox.TextBounds](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextBounds) and [TextBox.TextFits](https://developer.roblox.com/en-us/api-reference/property/TextBox/TextFits).
*/
TextYAlignment: Enum.TextYAlignment;
/**
* Forces the client to focus on the TextBox.
*/
CaptureFocus(this: TextBox): void;
/**
* Returns true if the textbox is focused, or false if it is not.
*/
IsFocused(this: TextBox): boolean;
/**
* Forces the client to unfocus the TextBox.
*
* The _submitted_ parameter allows you to over-ride the _enterPressed_ parameter in the [FocusLost](https://developer.roblox.com/api-reference/event/TextBox/FocusLost "FocusLost") event.
*
* Notes
* -----
*
* * This item should be used with a \`LocalScript\` in order to work as expected in online mode.
*
* Example
* -------
*
* The code shown below will force the client to unfocus the 'TextBox' 5 seconds after it's selected:
*
* local TextBox = script.Parent
* TextBox.Focused:Connect(function()
* wait(5)
* TextBox:ReleaseFocus()
* end)
*
* Please be aware that the above example assumes that it's in a LocalScript, as a child of a TextBox.
*/
ReleaseFocus(this: TextBox, submitted?: boolean): void;
/**
* The FocusLost event fires when the client lets their focus off the TextBox - typically when a client clicks/taps on a TextBox to begin text entry. This also fires if a TextBox forces focus on the user.
*
* It can be used alongside `TextBox.Focus` to track when a TextBox gains and loses focus.
*
* See also the [UserInputService.TextBoxFocused](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TextBoxFocused) and [UserInputService.TextBoxFocusReleased](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TextBoxFocusReleased) for similar functions that rely on the UserInputService service.
*
* This event will only fire when used in a `/LocalScript`.
*/
readonly FocusLost: RBXScriptSignal<(enterPressed: boolean, inputThatCausedFocusLoss: InputObject) => void>;
/**
* The Focused event fires when the `/TextBox` gains focus - typically when a client clicks/taps on a TextBox to begin text entry. This also fires if a TextBox forces focus on the user.
*
* It can be used alongside `TextBox.FocusLost` to track when a TextBox gains and loses focus.
*
* See also the [UserInputService.TextBoxFocused](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TextBoxFocused) and [UserInputService.TextBoxFocusReleased](https://developer.roblox.com/en-us/api-reference/event/UserInputService/TextBoxFocusReleased) for similar functions that rely on the UserInputService service.
*
* This event will only fire when used in a `/LocalScript`.
*/
readonly Focused: RBXScriptSignal<() => void>;
readonly ReturnPressedFromOnScreenKeyboard: RBXScriptSignal<() => void>;
}
/** A VideoFrame renders a rectangle, like a [Frame](https://developer.roblox.com/en-us/api-reference/class/Frame) does, with a moving video image. The video must be from a file uploaded to the Roblox website.
*
* The video is scaled to fit the entirety of the rectangle, but looks best when displayed at its native resolution.
*
* 2D and 3D Sound
* ---------------
*
* A VideoFrame placed underneath [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) will emit its sound from that part's [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position).
*
* A VideoFrame exhibits the Doppler effect, meaning its frequency and pitch varies with the relative motion of whatever part it is attached to.
*
* The volume of the VideoFrame will be determined by the distance between the client's sound listener (by default the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) position) and the position of the VideoFrame's part .
*
* A VideoFrame is considered **“global”** if it is not placed underneath SurfaceGui on a BasePart. In this case, the sound will play at the same volume throughout the entire place.
*/
interface VideoFrame extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_VideoFrame: unique symbol;
/**
* This property will be true when the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) has loaded from Roblox servers and is ready to play.
*
* Tags: NotReplicated
*/
readonly IsLoaded: boolean;
/**
* This property sets whether or not the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) repeats once it has finished when it is playing.
*/
Looped: boolean;
/**
* This property indicates whether the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) is currently playing. It can be set to start or pause playback as an alternative to the [VideoFrame:Play](https://developer.roblox.com/en-us/api-reference/function/VideoFrame/Play) and VideoFrame/Pause\` functions.
*
* Tags: NotReplicated
*/
Playing: boolean;
/**
* This property gets the original source resolution of the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) file.
*
* Tags: NotReplicated
*/
readonly Resolution: Vector2;
/**
* This property indicates the length of the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) in seconds. If the video is not loaded, this value will be 0.
*
* Tags: NotReplicated
*/
readonly TimeLength: number;
/**
* This property indicates the progress in seconds of the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video). It can be changed to move the playback position of the video both before and during playback.
*
* Tags: NotReplicated
*/
TimePosition: number;
/**
* The content ID of the video file a [VideoFrame](https://developer.roblox.com/en-us/api-reference/class/VideoFrame) object is associated with.
*/
Video: string;
/**
* This property determines how loud the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) plays back. It can be set to a number between 0 and 100.
*/
Volume: number;
/**
* Sets [VideoFrame.Playing](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Playing) to false, pausing playback if the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) is playing.
*
* As [VideoFrame.TimePosition](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/TimePosition) is not reset, when the video is resumed it will continue from its previous position.
*/
Pause(this: VideoFrame): void;
/**
* Sets [VideoFrame.Playing](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Playing) to true, This plays the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video), continuing from the current [VideoFrame.TimePosition](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/TimePosition).
*/
Play(this: VideoFrame): void;
/**
* An event that fires whenever the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) loops. Returns the content ID of the video.
*/
readonly DidLoop: RBXScriptSignal<(video: string) => void>;
/**
* This event fires when the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) has completed playback and stopped.
*/
readonly Ended: RBXScriptSignal<(video: string) => void>;
/**
* This event fires when the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) is loaded.
*/
readonly Loaded: RBXScriptSignal<(video: string) => void>;
/**
* This event fires whenever the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) is paused using [VideoFrame:Pause](https://developer.roblox.com/en-us/api-reference/function/VideoFrame/Pause) or by setting [VideoFrame.Playing](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Playing) to false.
*/
readonly Paused: RBXScriptSignal<(video: string) => void>;
/**
* This event fires whenever the [VideoFrame.Video](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Video) is played using the [VideoFrame:Play](https://developer.roblox.com/en-us/api-reference/function/VideoFrame/Play) function or by setting [VideoFrame.Playing](https://developer.roblox.com/en-us/api-reference/property/VideoFrame/Playing) to true.
*/
readonly Played: RBXScriptSignal<(video: string) => void>;
}
/** A **ViewportFrame** is a type of [GUI](https://developer.roblox.com/en-us/api-reference/class/GuiObject) that can render 3D objects inside its bounds. This is a great way to display 3D objects/models in a 2D GUI space like a [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui). At the moment, no shadow or post effects are available. Neon and Glass [materials](https://developer.roblox.com/en-us/api-reference/enum/Material) will be rendered on lowest quality.
*
* For a step-by-step walkthrough, see the [ViewportFrame GUI](https://developer.roblox.com/en-us/articles/viewportframe-gui) article.
*/
interface ViewportFrame extends GuiObject {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ViewportFrame: unique symbol;
/**
* This property determines the lighting hue applied to the area within the [ViewportFrame](https://developer.roblox.com/en-us/api-reference/class/ViewportFrame). This property defaults to 200, 200, 200 (ghost grey).
*/
Ambient: Color3;
/**
* This property is a [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) instance that is used to render children objects. Defaults to _nil_.
*
* The [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object will not replicate so the [ViewportFrame.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/ViewportFrame/CurrentCamera) won't replicate either. If you save a Camera in the server, it will not appear in the client. When you set this property, [Camera.CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) and [Camera.FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView) will be saved and replicate with [ViewportFrame](https://developer.roblox.com/en-us/api-reference/class/ViewportFrame) internally so the client can render ViewportFrame without a Camera object. If you want to change the client's Camera, you have to create a new Camera using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) at runtime.
*
* ### See also
*
* * [ViewportFrame-GUI](https://developer.roblox.com/en-us/articles/viewportframe-gui), an article exploring how the ViewportFrame GUI can render 3D objects inside its bounds
*
* Tags: NotReplicated
*/
CurrentCamera: Camera | undefined;
/**
* This property determines how a rendered image will be colorized. It allows you to change the image color without directly modifying the rendered object.The default colorization value is \`DataType/Color3|Color3.new(1,1,1) (white). When set to white no colorization occurs.
*
* It functions similarly to [ImageLabel.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/ImageColor3) and [Decal.Color3](https://developer.roblox.com/en-us/api-reference/property/Decal/Color3)except that it is applied to the rendered image.
*
* The image below demonstrates the same ViewportFrame with two different colorizations. The first image has the default (white) colorization and the second image has a `Color3.new(255, 255, 102)` (yellow) colorization.
* 
* 
*
* ### See also
*
* * [ViewportFrame-GUI](https://developer.roblox.com/en-us/articles/viewportframe-gui), an article exploring how the ViewportFrame GUI can render 3D objects inside its bounds
* * [ViewportFrame.ImageTransparency](https://developer.roblox.com/en-us/api-reference/property/ViewportFrame/ImageTransparency), determines the transparency of the rendered image
* * [ViewportFrame.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/ViewportFrame/CurrentCamera), the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) that is used to render children objects
*/
ImageColor3: Color3;
/**
* This property determines the transparency of the rendered image. It allows you to change the image transparency without directly modifying the rendered object. A value of 0 is completely opaque, and a value of 1 is completely transparent (invisible). The default transparency is 0.
*
* This property behaves similarly to [GuiObject.BackgroundTransparency](https://developer.roblox.com/en-us/api-reference/property/GuiObject/BackgroundTransparency) or [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) except that it is applied to the rendered image.
*
* The image below demonstrates the same ViewportFrame with two different transparency. The first image has a transparency of 0 and the second image has a transparency of 0.5.
*
* 
* 
*
* ### See also
*
* * [ViewportFrame-GUI](https://developer.roblox.com/en-us/articles/viewportframe-gui), an article exploring how the ViewportFrame GUI can render 3D objects inside its bounds
* * [ViewportFrame.ImageColor3](https://developer.roblox.com/en-us/api-reference/property/ViewportFrame/ImageColor3), determines how a rendered image will be colorized
* * [ViewportFrame.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/ViewportFrame/CurrentCamera), the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) that is used to render children objects
*/
ImageTransparency: number;
/**
* The color of the emitted light. This property defaults to 140, 140, 140 (silver flip/flop).
*/
LightColor: Color3;
/**
* A [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) representing the direction of the light source from the position 0, 0, 0. This property defaults to -1, -1, -1.
*/
LightDirection: Vector3;
}
/** LayerCollector is the base class of 2D UI containers which render [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) descendants, such as [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui).
*
* ##### Caching static UI for performance improvements
*
* A Gui's appearance is cached until one of the following events occurs:
*
* * A descendant is added to the Gui.
* * A descendant is removed from the Gui.
* * A property of a descendant of the Gui changes.
* * A property of the Gui changes.
*
* If any of these events occur, the Gui's appearance will be recomputed the next frame it gets rendered.
*/
interface LayerCollector extends GuiBase2d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LayerCollector: unique symbol;
/**
* Toggles the visibility of the LayerCollector. When false, the UI contents
* will not render, process user input, or update in response to changes.
*/
Enabled: boolean;
/**
* When set to false, this LayerCollector will only be cloned into each
* [player's](https://developer.roblox.com/en-us/api-reference/class/Player) `/PlayerGui` once, and the LayerCollector will not be
* deleted when the player respawns.
*
* When set to true, the LayerCollector will be cloned into each
* [player's](https://developer.roblox.com/en-us/api-reference/class/Player) `/PlayerGui` when they respawn, and it will delete
* itself when the player respawns again.
*/
ResetOnSpawn: boolean;
/**
* Controls how [GuiObject.ZIndex](https://developer.roblox.com/en-us/api-reference/property/GuiObject/ZIndex) behaves on all descendants of the
* LayerCollector.
*
* `Enum/ZIndexBehavior/Global` sorts all descendants according to the
* ZIndex, then breaks ties using the hierarchy order. As a result,
* descendants of a [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) need to have a ZIndex value that's at least
* as high as the parent, or they will render underneath their parent.
*
* With `Enum/ZIndexBehavior/Sibling`, children always render above their
* parents, and the ZIndex is used to decide the order in which children of a
* single UI object will render over each other.
*/
ZIndexBehavior: Enum.ZIndexBehavior;
}
/** BillboardGuis are containers for [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject) that appear in the 3D
* space. BillboardGuis always face the camera, and can either change size with
* distance or remain the same size on the screen based on the
* [BillboardGui.Size](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Size) property.
*
* Their position is relative to the [BillboardGui.Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee). If no Adornee is
* set, then the parent of the BillboardGui will be used as the adornee. For
* [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart), the [Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) property will be used.
* For [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment), the [WorldPosition](https://developer.roblox.com/en-us/api-reference/property/Attachment/WorldPosition)
* property will be used.
*
* The [Size](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Size) property of a BillboardGui works slightly
* differently than [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size). The Offset portion works the
* same, but the Scale portion is used as a size in studs in 3D space.
*
* A size of `UDim2.fromScale(4, 5)` is 4x5 studs, and scales the UI larger and
* smaller depending on distance from the camera. A size of
* `UDim2.fromOffset(200, 100)` is always 200x100 on the screen, and does not
* change size with distance. Scale and Offset values can also be combined
* together, like with [GuiObject.Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size).
*
* When creating size-scaled BillboardGuis, it's important to make sure all the
* UI objects within are using Scale sizing and all text has
* [TextLabel.TextScaled](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextScaled) enabled, to ensure correct scaling.
*
* The AbsolutePosition property of a BillboardGui and all of its descendants is
* relative to the top left corner of its canvas, and so is always `0, 0` for the
* BillboardGui instance.
*
* ##### Caching static UI for performance improvements
*
* A Gui's appearance is cached until one of the following events occurs:
*
* * A descendant is added to the Gui.
* * A descendant is removed from the Gui.
* * A property of a descendant of the Gui changes.
* * A property of the Gui changes.
*
* If any of these events occur, the Gui's appearance will be recomputed the next frame it gets rendered.
*/
interface BillboardGui extends LayerCollector {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BillboardGui: unique symbol;
/**
* Controls whether the descendants will receive input events. If the UI
* contains a [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton) then that button will become clickable only if
* Active is set to true on both the BillboardGui and the button.
*
* BillboardGuis will only receive user input if they are parented to the
* PlayerGui. The [BillboardGui.Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee) property can be used to target a
* Part in the workspace while the UI itself is in the [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui).
*/
Active: boolean;
/**
* Sets the target part or attachment that the BillboardGui is positioned
* relative to. If no Adornee is set, then the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is
* used instead.
*/
Adornee: PVInstance | Attachment | undefined;
/**
* Determines whether the BillboardGui will render over top of 3D content, or
* be occluded by it.
*
* When set to false, the BillboardGui will render like other 3D content, and
* will be occluded by other 3D objects.
*
* When set to true, it always renders on top of 3D content, and the
* appearance changes significantly:
*
* * Colors match how they appear inside a [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui).
* * Text may appear sharper on high DPI devices.
* * [BillboardGui.LightInfluence](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/LightInfluence) is treated as though it was 0.
* * [BillboardGui.Brightness](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Brightness) has no effect.
*/
AlwaysOnTop: boolean;
/**
* **Brightness** determines the factor by which the GUI's emitted light is scaled. By default, this property is 1 and can be set to any number on the range \[0, 1000\].
*
* By modifying this property, the apparent brightness of a GUI can be better matched to its environment. For instance, a video billboard like those found in Times Square can be made brighter to be clearly visible on a bright day.
*
* This property won't produce any effect in the following scenarios wherein the GUI does not emit light.:
*
* * When [AlwaysOnTop](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/AlwaysOnTop) is true, the color of each pixel is the color shown on-screen.
* * When [LightInfluence](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/LightInfluence) is 1, all light from the GUI is reflected from the environment instead of being emit.
*/
Brightness: number;
/**
* When set to true, portions of GuiObjects that fall outside of the
* BillboardGui's canvas borders will not be drawn.
*
* Even when this property is false, objects that are completely outside of
* the canvas of the BillboardGui will not render.
*/
ClipsDescendants: boolean;
/**
* The current distance in studs that the [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) is from the player's camera. A changed event does not fire for this property unless the gui's [BillboardGui.DistanceStep](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/DistanceStep) is more than 0.
*
* Tags: NotReplicated
*/
readonly CurrentDistance: number;
/**
* Determines the distance in studs that a [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) will stop scaling larger in size at relative to the player's current camera. If the distance of the gui is below this value, it will not be scaled any larger than it would be at this distance. The value of this property defaults to 0 studs.
*/
DistanceLowerLimit: number;
/**
* Determines the size [BillboardGui.CurrentDistance](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/CurrentDistance) increments and decrements in studs as the player's camera moves closer and further from the [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui). The property defaults to 0 and rounds up starting from [BillboardGui.DistanceLowerLimit](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/DistanceLowerLimit).
*
* For example, if this property is set to 0.5 and the player's camera is moving away from the gui starting from 0 then CurrentDistance will increase 0 -> 0.5 -> 1 -> 1.5 -> … and so forth.
*/
DistanceStep: number;
/**
* Determines the distance in studs that a [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) will stop scaling smaller in size at relative to the player's current camera. If the distance of the gui is above this value, it will not be scaled any smaller than it would be at this distance.
*
* This property is ignored if the value is less than 0. The default value is -1, meaning the property is ignored by default.
*/
DistanceUpperLimit: number;
/**
* **ExtentsOffset** determines how the BillboardGui is offset from its [Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee), relative to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) orientation and units are half the dimensions of the model's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera)\-aligned bounding box.
*
* See also
* --------
*
* * [ExtentsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffsetWorldSpace), which works similarly except the offset orientation is relative to the global axes
* * [StudsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffset), which works similarly except the units are studs
*/
ExtentsOffset: Vector3;
/**
* **ExtentsOffsetWorldSpace** determines how the BillboardGui is offset from its [Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee), relative to the global axes and units are half the dimensions of the model's axis-aligned bounding box.
*
* See also
* --------
*
* * [ExtentsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffset), which works similarly except the offset orientation is relative to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera)
* * [StudsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffsetWorldSpace), which works similarly except the units are studs
*/
ExtentsOffsetWorldSpace: Vector3;
/**
* Controls how much the BillboardGui is influenced by the lighting in the environment.
*
* When set to 0, the UI behaves similarly to an LCD screen, acting as its own
* light source and appearing the same regardless of the surrounding
* lighting.
*
* When set to 1, the UI behaves similarly to a piece of paper, only reflecting
* the light from another source.
*/
LightInfluence: number;
/**
* The MaxDistance property of a [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) sets how far away in studs that billboard can be from the camera and still be drawn. If the camera and billboard are moved further apart than the maximum distance, then the billboard will not be visible regardless of any other properties of the billboard or any GUI objects it contains. The default value of this property is infinity
*
* If this value is set to less than or equal to 0 then the maximum distance will be treated as infinite and the billboard will always be drawable.
*
* Example
* -------
*
* \-- Wait for default camera/control scripts to load
* wait(5)
*
* -- Declare and initialize objects
* local camera = game.Workspace.CurrentCamera
* local part = Instance.new("Part")
* local billboard = Instance.new("BillboardGui")
* local label = Instance.new("TextLabel")
*
* -- Set up camera type
* camera.CameraType = Enum.CameraType.Scriptable
*
* -- Set part's position and lock in place
* part.CFrame = CFrame.new(0, 10, 0)
* part.Anchored = true
*
* -- Set up billboard
* billboard.MaxDistance = 10
* billboard.Adornee = part
* billboard.AlwaysOnTop = true
* billboard.Size = UDim2.new(0, 50, 0, 50)
*
* -- Set up label
* label.Size = UDim2.new(1, 0, 1, 0)
*
* -- Set partents of objects
* label.Parent = billboard
* billboard.Parent = part
* part.Parent = game.Workspace
*
* -- Move camera next to part. Wait a bit and then move camera
* local cameraPosition0 = part.Position + Vector3.new(0, 0, 10)
* local cameraPosition1 = part.Position + Vector3.new(0, 0, 20)
* camera.CFrame = CFrame.new(cameraPosition0, part.Position)
* -- Contents of billboard will be visible here
* wait(2)
* camera.CFrame = CFrame.new(cameraPosition1, part.Position)
* -- Contents of billboard will no longer be visible (outside MaxDistance)
*/
MaxDistance: number;
/**
* Used by scripts to hide the BillboardGui from a specific player.
*
* To hide the UI from more than one player, place the BillboardGui into
* [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) and use a script to set the `BillboardGui/Enabled` property
* according to whether the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) should be able to see it.
* The [BillboardGui.Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee) property can be used to attach the BillboardGui
* to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace), instead of parenting it.
*/
PlayerToHideFrom: Player | undefined;
/**
* Controls the size that the BillboardGui will have on screen.
*
* The Scale component of the Size is interpreted as a size in studs, and the
* UI will automatically scale with distance if Scale values are used.
*
* The Scale and Offset portions of the size are added together, and can be
* used at the same time.
*/
Size: UDim2;
/**
* A 2D offset in size-relative units that acts like an anchor point. This
* can be used similarly to the [GuiObject.AnchorPoint](https://developer.roblox.com/en-us/api-reference/property/GuiObject/AnchorPoint) property, but the
* values are different.
*
* Common Values
* -------------
*
* SizeOffset
*
* Explanation
*
* 0.0, 0.0
*
* The default. The UI will be anchored at its center.
*
* 0.5, 0.5
*
* The UI will anchor at the bottom left.
*
* 0.5, -0.5
*
* The UI will anchor at the top left.
*
* \-0.5, 0.5
*
* The UI will anchor at the top right.
*
* \-0.5, -0.5
*
* The UI will anchor at the bottom right.
*
* See also
* --------
*
* * [StudsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffset),
* [StudsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffsetWorldSpace),
* [ExtentsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffset),
* [ExtentsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffsetWorldSpace), which are
* all other offset properties that work in 3D space instead
*/
SizeOffset: Vector2;
/**
* **StudsOffset** determines how the BillboardGui is offset from its [Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee), relative to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) orientation with units in studs.
*
* See also
* --------
*
* * [StudsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffsetWorldSpace), which works similarly except the offset orientation is relative to the global axes
* * [ExtentsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffset), which works similarly except the units are half the dimensions of the model's Camera-aligned bounding box
*/
StudsOffset: Vector3;
/**
* **StudsOffsetWorldSpace** determines how the BillboardGui is offset from its [Adornee](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/Adornee), relative to the global axes with units in studs.
*
* See also
* --------
*
* * [StudsOffset](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/StudsOffset), which works similarly except the offset orientation is relative to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera)
* * [ExtentsOffsetWorldSpace](https://developer.roblox.com/en-us/api-reference/property/BillboardGui/ExtentsOffsetWorldSpace), which works similarly except the units are half the dimensions of the model's axis-aligned bounding box
*/
StudsOffsetWorldSpace: Vector3;
}
/** The main storage object for 2D [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) displayed on the player's screen. ScreenGuis will only be shown if parented to a player's [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui).
* To make sure a ScreenGui is displayed to your player, it should be parented into the [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui), as that service will clone it's contents into each player's [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) when they join the game.
*
* ##### Caching static UI for performance improvements
*
* A Gui's appearance is cached until one of the following events occurs:* A descendant is added to the Gui.
* * A descendant is removed from the Gui.
* * A property of a descendant of the Gui changes.
* * A property of the Gui changes.
*
* If any of these events occur, the Gui's appearance will be recomputed the next frame it gets rendered.
*/
interface ScreenGui extends LayerCollector {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ScreenGui: unique symbol;
ClipToDeviceSafeArea: boolean;
/**
* This property controls the order that multiple ScreenGuis are drawn.
*
* ScreenGuis with a higher DisplayOrder will be drawn on top of ScreenGuis with a lower DisplayOrder. DisplayOrder can have any value greater than 0 and defaults to 0.
*/
DisplayOrder: number;
/**
* IgnoreGuiInset is a boolean property of ScreenGuis that, when set to true, will force the [GUI Inset](https://developer.roblox.com/en-us/api-reference/function/GuiService/GetGuiInset) imposed by Roblox's CoreGuis to be ignored by this ScreenGui and its descendants. This means that an element with a UDim2 size of `{1,0},{1,0}` will fill up the entire screen, without a 36 pixel gap reserved for Roblox's top bar.
*/
IgnoreGuiInset: boolean;
SafeAreaCompatibility: Enum.SafeAreaCompatibility;
/**
* Tags: NotBrowsable
*/
ScreenInsets: Enum.ScreenInsets;
}
interface SurfaceGuiBase extends LayerCollector {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SurfaceGuiBase: unique symbol;
Active: boolean;
Adornee: BasePart | undefined;
Face: Enum.NormalId;
}
interface AdGui extends SurfaceGuiBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AdGui: unique symbol;
AdShape: Enum.AdShape;
EnableVideoAds: boolean;
FallbackImage: string;
/**
* Tags: NotReplicated
*/
readonly Status: Enum.AdUnitStatus;
OnAdEvent: (eventInfo: object) => boolean;
}
/** **Note:** SurfaceGuis must be descendants of PlayerGui in order to know the player who is interacting with it.Allows for the rendering of GUI elements onto a part's surface in the 3D world, whilst allowing for basic user interaction to occur.
*
* ##### Caching static UI for performance improvements
*
* A Gui's appearance is cached until one of the following events occurs:* A descendant is added to the Gui.
* * A descendant is removed from the Gui.
* * A property of a descendant of the Gui changes.
* * A property of the Gui changes.
*
* If any of these events occur, the Gui's appearance will be recomputed the next frame it gets rendered.
*/
interface SurfaceGui extends SurfaceGuiBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SurfaceGui: unique symbol;
/**
* Determines whether the SurfaceGui will render over top of 3D content, or
* be occluded by it.
*
* When set to false, the SurfaceGui will render like other 3D content, and
* will be occluded by other 3D objects.
*
* When set to true, it always renders on top of 3D content, and the
* appearance changes significantly:
*
* * Colors match how they appear inside a [ScreenGui](https://developer.roblox.com/en-us/api-reference/class/ScreenGui).
* * Text may appear sharper on high DPI devices.
* * [SurfaceGui.LightInfluence](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/LightInfluence) is treated as though it was 0.
* * [SurfaceGui.Brightness](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/Brightness) has no effect.
*/
AlwaysOnTop: boolean;
/**
* **Brightness** determines the factor by which the GUI's emitted light is scaled. By default, this property is 1 and can be set to any number on the range \[0, 1000\].
*
* By modifying this property, the apparent brightness of a GUI can be better matched to its environment. For instance, a video billboard like those found in Times Square can be made brighter to be clearly visible on a bright day.
*
* This property won't produce any effect in the following scenarios wherein the GUI does not emit light.:
*
* * When [AlwaysOnTop](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/AlwaysOnTop) is true, the color of each pixel is the color shown on-screen.
* * When [LightInfluence](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/LightInfluence) is 1, all light from the GUI is reflected from the environment instead of being emit.
*/
Brightness: number;
/**
* The size of a 'virtual screen', in 'virtual pixels', which makes SurfaceGuis pixel-to-pixel compatible with ScreenGuis.
*/
CanvasSize: Vector2;
/**
* When set to true, portions of GuiObjects that fall outside of the
* SurfaceGui's canvas borders will not be drawn.
*
* Even when this property is false, objects that are completely outside of
* the canvas of the SurfaceGui will not render.
*/
ClipsDescendants: boolean;
/**
* Controls how much the SurfaceGui is influenced by the lighting in the game world.
*/
LightInfluence: number;
MaxDistance: number;
/**
* **PixelsPerStud** determines the density of pixels used for each world-space stud to render the contents of the SurfaceGui.
*
* Higher values will cause the various [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) within to appear smaller if they are kept the same size. Conversely, lower values will cause objects to appear larger. However, if the GuiObjects are scaled proportionally (either by using a [UIScale](https://developer.roblox.com/en-us/api-reference/class/UIScale) or modifying [Size](https://developer.roblox.com/en-us/api-reference/property/GuiObject/Size) or [TextLabel.TextSize](https://developer.roblox.com/en-us/api-reference/property/TextLabel/TextSize) etc.), this property allows for higher definition to be used. It's important to select a value based on how far away you expect a player to view the SurfaceGui. Be mindful that a large pixel density could negatively affect performance if the face of the adorned part is large enough.
*
* 
*/
PixelsPerStud: number;
/**
* When set to `Enum/SurfaceGuiSizingMode/FixedSize`, SurfaceGui renders with a fixed size set using [SurfaceGui.CanvasSize](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/CanvasSize).
*
* When set to `Enum/SurfaceGuiSizingMode/PixelsPerStud`, SurfaceGui renders with a variable size based on [SurfaceGui.PixelsPerStud](https://developer.roblox.com/en-us/api-reference/property/SurfaceGui/PixelsPerStud) and the SurfaceGui's size in studs.
*/
SizingMode: Enum.SurfaceGuiSizingMode;
/**
* Sets the distance left clicking starts acting on the surface gui instead of the held tool. If a character is within this distance of the surface gui, then the tool will not activate on click.
*/
ToolPunchThroughDistance: number;
/**
* Offsets the SurfaceGui relative to the normal of the surface it is attached to.
*/
ZOffset: number;
}
/** An abstract class for 3D GUI elements that are rendered in the world. */
interface GuiBase3d extends GuiBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiBase3d: unique symbol;
/**
* Sets the color of a GUI object.
*/
Color3: Color3;
/**
* Sets the transparency of a GUI object, where 1 is invisible and 0 is completely visible.
*/
Transparency: number;
/**
* Determines whether the object and its descendants will be displayed.
*/
Visible: boolean;
}
/** A FloorWire attempts to make a wire from two of its properties: [FloorWire.From](https://developer.roblox.com/en-us/api-reference/property/FloorWire/From) and [FloorWire.To](https://developer.roblox.com/en-us/api-reference/property/FloorWire/To), which both need to be set to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). It sometimes goes through bricks but the majority of the time it works fine. It starts at From's center and goes to To's center. Which side of each one it goes into depends on the BaseParts's positions. It chooses the fastest route. */
interface FloorWire extends GuiBase3d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FloorWire: unique symbol;
/**
* A decimal number between 0 and 1, through which you can control how far all of the decals are along the wire.
*/
CycleOffset: number;
/**
* The object that the FloorWire travels from.
*/
From: BasePart | undefined;
/**
* The number of studs between each FloorWire segment.
*/
StudsBetweenTextures: number;
/**
* Sets the texture to be displayed on the FloorWire.
*/
Texture: string;
/**
* Sets the size of the texture used with the FloorWire.
*/
TextureSize: Vector2;
/**
* The object that the FloorWire travels to.
*/
To: BasePart | undefined;
/**
* The speed that the textures flow along the wire.
*/
Velocity: number;
/**
* The radius of the wire.
*/
WireRadius: number;
}
interface InstanceAdornment extends GuiBase3d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InstanceAdornment: unique symbol;
/**
* Since adornments are usually parented to some GUI, this property determines which [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) they are adorning.
* They render in 3D positioned relative to the “adornee”, not to their parent.
*/
Adornee: Instance | undefined;
}
/** **SelectionBox** is an object which renders a 3D box around its [Adornee](https://developer.roblox.com/en-us/api-reference/property/PVAdornment/Adornee) when it is a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) or anywhere where GUI objects are rendered. The box's geometry consists of rectangular prisms forming an outline/wireframe in addition to a surface for each of its faces. By default, only the outline is visible.
*
*  There are several properties available to configure the appearance of the cube. The outline can modified through the [Color3](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color3)†, [Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency)† and [LineThickness](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/LineThickness) properties. The faces can be modified through the [SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/SurfaceColor3) and [SurfaceTransparency](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/SurfaceTransparency) properties. Finally, rendering of the box can be toggled with the [Visible](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Visible)† property.
*
* † These properties come from this object's superclass, [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d).
*
* The SelectionBox object does not capture any form of input; it is solely a visual effect. To capture simple pointer input on the adornee, consider using a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector).
*
* See also
* --------
*
* * [Selection Boxes](https://developer.roblox.com/en-us/articles/selection-boxes), to learn more about using this object
*/
interface SelectionBox extends InstanceAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SelectionBox: unique symbol;
/**
* **LineThickness** determines the thickness of the box's outlines. It is measured in studs, the same unit for [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size). If set to 0, the outline will not be visible at all.
*
* 
*
* Pictured above are three default [Part](https://developer.roblox.com/en-us/api-reference/class/Part)s with default SelectionBoxes applied to them. Their thicknesses from left-to-right are 0.075, 0.15 (default) and 0.3.
*
* See also
* --------
*
* * [GuiBase3d.Color](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the outline's color
* * [GuiBase3d.Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the outline's transparency
*/
LineThickness: number;
/**
* A `BrickColor` version of [SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/SurfaceColor3)…
*
* Tags: Hidden, NotReplicated
* @deprecated Use `SurfaceColor3` instead
*/
SurfaceColor: BrickColor;
/**
* **SurfaceColor3** determines the color of the SelectionBox's surfaces.
*
* See also
* --------
*
* * [SurfaceTransparency](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/SurfaceTransparency), which controls the transparency of the surfaces. You may need to adjust this property in order to see changes to SurfaceColor.
* * [GuiBase3d.Color](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the color of the outline rather than the surface faces
*/
SurfaceColor3: Color3;
/**
* **SurfaceTransparency** determines the transparency of the SelectionBox's surfaces, similar to the way [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) works. By default, this property is 1, which causes the surfaces to not be visible.
*
* See also
* --------
*
* * [SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionBox/SurfaceColor3), which controls the color of the surface.
* * [GuiBase3d.Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the transparency of the outline rather than the surface faces
*/
SurfaceTransparency: number;
}
/** The PVAdornment class is an abstract class of which the inheritors can be adorned to objects of the PVInstance class. */
interface PVAdornment extends GuiBase3d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PVAdornment: unique symbol;
/**
* The [PVInstance](https://developer.roblox.com/api-reference/class/PVInstance "PVInstance") the PVAdornment is attached to. An adornment will stay positioned and rotated relative to its adornee, even if the adornee moves.
*/
Adornee: PVInstance | undefined;
}
/** **Note:** For handles to be interactive, they must be parented to a player's [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) or the [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui).**HandleAdornment** is an abstract class inherited by 3D handle adornments. */
interface HandleAdornment extends PVAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HandleAdornment: unique symbol;
AdornCullingMode: Enum.AdornCullingMode;
/**
* Forces this object to render on top of all 3d objects in the Workspace. Even if the adornment is behind a part based on its [HandleAdornment.CFrame](https://developer.roblox.com/en-us/api-reference/property/HandleAdornment/CFrame), if **AlwaysOnTop** is true then the adornment will still draw on top.
*
* The one exception to this behavior is if the \`HandleAdornment/ZIndex\` of the adornment is set to -1. If this is the case, the adornment will always draw behind 3d geometry.
*/
AlwaysOnTop: boolean;
/**
* The position and rotation relative to its [PVAdornment.Adornee](https://developer.roblox.com/en-us/api-reference/property/PVAdornment/Adornee). This CFrame is in the local space of the adornee, so forward (0,0,-1) will be forward relative to the adornee. The offset and rotation of this CFrame is applied after any translations due to [HandleAdornment.SizeRelativeOffset](https://developer.roblox.com/en-us/api-reference/property/HandleAdornment/SizeRelativeOffset).
*/
CFrame: CFrame;
/**
* The positional offset of the adornment based on the adornee's [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size). By default, an adornment draws in the center of its adornee. By using this property, the position of the adornment can be shifted relative to the center of the adornee. The units of **SizeRelativeOffset** are a scale based on the size of the adornee itself. This scale is such that a value of 1 will move the adornment to the corresponding edge of the adornee.
*
* This property is intended to allow adornments to easily be moved to the edges of a parts.
*
* For example, if the **SizeRelativeOffset** is set to (0,1,0), the adornment will be drawn with its center at the exact top of the adornee. If set to (1,1,1), the adornment will be drawn in the upper corner of the adornee.
*/
SizeRelativeOffset: Vector3;
/**
* The **ZIndex** property determines the draw order of the [HandleAdornment](https://developer.roblox.com/en-us/api-reference/class/HandleAdornment). This **ZIndex** only refers to how the adornment will draw relative to other adornments or 3d objects in the workspace. This does not relate to the `GuiObjects/ZIndex (page does not exist)` of GuiObjects.
*
* The valid values for ZIndex are from -1 to 10. If two HandleAdornments are drawn over one another, the one with the higher ZIndex will be drawn. This order of drawing will be respected even if the adormnent with higher ZIndex is behind the other adornment in terms of its position in 3d space.
*
* If set to -1, ZIndex will force the adornment to draw behind other adornments and objects in the Workspace, even if the \`HandleAdornment/AlwaysOnTop\` property for the adornment is true.
*/
ZIndex: number;
/**
* Fires when a user presses down on their left mouse button while hovering over the adornment.
*/
readonly MouseButton1Down: RBXScriptSignal<() => void>;
/**
* Fires when a user releases their left mouse button while hovering over the adornment.
*/
readonly MouseButton1Up: RBXScriptSignal<() => void>;
/**
* Fires when a user moves their mouse over the adornment.
*/
readonly MouseEnter: RBXScriptSignal<() => void>;
/**
* Fires when a user moves their mouse out of the adornment.
*/
readonly MouseLeave: RBXScriptSignal<() => void>;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **BoxHandleAdornment** is a rectangular prism that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface BoxHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BoxHandleAdornment: unique symbol;
/**
* The size of the adornment.
*/
Size: Vector3;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* A **ConeHandleAdornment** is a cone that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface ConeHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ConeHandleAdornment: unique symbol;
/**
* The height of the cone adornment.
*/
Height: number;
/**
* The radius of the cone adornment.
*/
Radius: number;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **CylinderHandleAdornment** is a cylinder that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface CylinderHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CylinderHandleAdornment: unique symbol;
/**
* If `Angle` is <360, a cylindrical sector (aka a pie-slice) of that angle is rendered instead of a full cylinder.
* The `Angle` property can be combined with `InnerRadius` to render a sector of a hollow cylinder.
*/
Angle: number;
/**
* The height of the cylinder adornment.
*/
Height: number;
/**
* If `InnerRadius` is >0, a hollow cylinder with that inner radius is rendered instead of a full cylinder.
* The `InnerRadius` property can be combined with `Angle` to render a sector of a hollow cylinder.
*/
InnerRadius: number;
/**
* The radius of the cylinder adornment.
*/
Radius: number;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **ImageHandleAdornment** is an image that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface ImageHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ImageHandleAdornment: unique symbol;
/**
* The image to draw for the adornment.
*/
Image: string;
/**
* The size in studs of the image.
*/
Size: Vector2;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **LineHandleAdornment** is a line that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This line starts at the center of the adornment's [HandleAdornment.CFrame](https://developer.roblox.com/en-us/api-reference/property/HandleAdornment/CFrame) (offset by the adornment's [HandleAdornment.SizeRelativeOffset](https://developer.roblox.com/en-us/api-reference/property/HandleAdornment/SizeRelativeOffset)) and will be oriented along its CFrame. This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface LineHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LineHandleAdornment: unique symbol;
/**
* The length of the line.
*/
Length: number;
/**
* The thickness of the line in pixels.
*/
Thickness: number;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **SphereHandleAdornment** is a sphere that can be adorned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). This adornment can listen to input events and is commonly used to make dragger tools.
*/
interface SphereHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SphereHandleAdornment: unique symbol;
/**
* The radius of the sphere adornment.
*/
Radius: number;
}
interface WireframeHandleAdornment extends HandleAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WireframeHandleAdornment: unique symbol;
Scale: Vector3;
AddLine(this: WireframeHandleAdornment, from: Vector3, to: Vector3): void;
AddLines(this: WireframeHandleAdornment, points: Array): void;
AddPath(this: WireframeHandleAdornment, points: Array, loop: boolean): void;
Clear(this: WireframeHandleAdornment): void;
}
/** A special type of Adornment that is still a work in progress.
* This object can only be created by [CoreScript](https://developer.roblox.com/en-us/api-reference/class/CoreScript) at the moment.
*/
interface ParabolaAdornment extends PVAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ParabolaAdornment: unique symbol;
}
/** **SelectionSphere** is an object which renders a 3D sphere around its [Adornee](https://developer.roblox.com/en-us/api-reference/property/PVAdornment/Adornee) when it is a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) or anywhere where GUI objects are rendered. The sphere's geometry consists of a ring/outline in addition to a surface. By default, only the outline is visible.
*
*  There are a few properties available to configure the appearance of the sphere. The outline can modified through the [Color3](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color3)† and [Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency)† properties. The surface can be modified through the [SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionSphere/SurfaceColor3) and [SurfaceTransparency](https://developer.roblox.com/en-us/api-reference/property/SelectionSphere/SurfaceTransparency) properties. Finally, rendering of the sphere can be toggled with the [Visible](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Visible)† property.
*
* † These properties come from this object's superclass, [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d).
*
* The SelectionSphere object does not capture any form of input; it is solely a visual effect. To capture simple pointer input on the adornee, consider using a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector).
*/
interface SelectionSphere extends PVAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SelectionSphere: unique symbol;
/**
* A `BrickColor` version of [SelectionSphere.SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionSphere/SurfaceColor3).
*
* Tags: Hidden, NotReplicated
* @deprecated Use `SurfaceColor3` instead
*/
SurfaceColor: BrickColor;
/**
* **SurfaceColor3** determines the color of the SelectionSphere's surface.
*
* See also
* --------
*
* * [SurfaceTransparency](https://developer.roblox.com/en-us/api-reference/property/SelectionSphere/SurfaceTransparency), which controls the transparency of the surface. You may need to adjust this property in order to see changes to SurfaceColor3.
* * [GuiBase3d.Color](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the color of the outline rather than the surface faces
*/
SurfaceColor3: Color3;
/**
* **SurfaceTransparency** determines the transparency of the SelectionSphere's surface, similar to the way [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) works. By default, this property is 1, which causes the surface to not be visible.
*
* See also
* --------
*
* * [SurfaceColor3](https://developer.roblox.com/en-us/api-reference/property/SelectionSphere/SurfaceColor3), which controls the color of the surface.
* * [GuiBase3d.Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency), a property of the superclass [GuiBase3d](https://developer.roblox.com/en-us/api-reference/class/GuiBase3d) which controls the transparency of the outline rather than the surface
*/
SurfaceTransparency: number;
}
/** An abstract class for GUI elements that are adorned to (displayed as attached to) objects deriving from [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). */
interface PartAdornment extends GuiBase3d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PartAdornment: unique symbol;
/**
* Sets the object to adorn to.
*/
Adornee: BasePart | undefined;
}
/** An abstract class for Handle objects, such as `/ArcHandles` and `/Handles`. */
interface HandlesBase extends PartAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HandlesBase: unique symbol;
}
/** For handles to be interactive, they must be parented to a player's [PlayerGui](PlayerGui) or the [CoreGui](CoreGui).
*
* The **ArcHandles** object places 3D ArcHandles around any object that its [PartAdornment.Adornee](https://developer.roblox.com/en-us/api-reference/property/PartAdornment/Adornee) is set to. The Adornee property must be set to a 3D object for the handles to appear. The [Color](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color3) can be changed.
*
* 
*/
interface ArcHandles extends HandlesBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ArcHandles: unique symbol;
/**
* Sets the current Axes ArcHandles will show.
*/
Axes: Axes;
/**
* Fired when the left mouse button goes down on one of the GUI handles.
*/
readonly MouseButton1Down: RBXScriptSignal<(axis: Enum.Axis) => void>;
/**
* Fired when the left mouse button is released on one of the GUI handles.
*/
readonly MouseButton1Up: RBXScriptSignal<(axis: Enum.Axis) => void>;
/**
* Fired when the mouse moves while the MouseButton1Down event has fired, but the left mouse button has not been released yet.
*/
readonly MouseDrag: RBXScriptSignal<(axis: Enum.Axis, relativeAngle: number, deltaRadius: number) => void>;
/**
* Fired when a mouse “enters” the GUI handle.
*/
readonly MouseEnter: RBXScriptSignal<(axis: Enum.Axis) => void>;
/**
* Fired when the mouse leaves the GUI handle.
*/
readonly MouseLeave: RBXScriptSignal<(axis: Enum.Axis) => void>;
}
/** For handles to be interactive, they must be parented to a player's PlayerGui or the CoreGui.
*
* The **Handles** object places 3D handles around any object that its Adornee is set to. The Adornee property must be set to a 3D object for the handles to appear. The color can be changed, and the shape of the handles can be set to either arrows or spheres.
*/
interface Handles extends HandlesBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Handles: unique symbol;
/**
* Sets which sides the GUI handles will appear.
*/
Faces: Faces;
/**
* Sets the GUI style of the handles. Currently there are only two types; Resize and Movement.
*/
Style: Enum.HandlesStyle;
/**
* Fired when the left mouse button goes down on one of the GUI handles.
*/
readonly MouseButton1Down: RBXScriptSignal<(face: Enum.NormalId) => void>;
/**
* Fired when the left mouse button is released on one of the GUI handles.
*/
readonly MouseButton1Up: RBXScriptSignal<(face: Enum.NormalId) => void>;
/**
* Fired when the mouse moves while the MouseButton1Down event has fired, but the left mouse button has not been released yet.
*/
readonly MouseDrag: RBXScriptSignal<(face: Enum.NormalId, distance: number) => void>;
/**
* Fired when a mouse “enters” the GUI handle.
*/
readonly MouseEnter: RBXScriptSignal<(face: Enum.NormalId) => void>;
/**
* Fired when the mouse leaves the GUI handle.
*/
readonly MouseLeave: RBXScriptSignal<(face: Enum.NormalId) => void>;
}
/** A **SurfaceSelection** highlights a particular face, the [TargetSurface](https://developer.roblox.com/en-us/api-reference/property/SurfaceSelection/TargetSurface), of its [Adornee](https://developer.roblox.com/en-us/api-reference/property/PartAdornment/Adornee). The highlight's color is configurable using the [Color3](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Color3) property.
*
* 
*
* The SurfaceSelection object is typically used by [Plugin](https://developer.roblox.com/en-us/api-reference/class/Plugin) when the user is selecting the face of a Part. However, it is not limited to plugin use.
*/
interface SurfaceSelection extends PartAdornment {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SurfaceSelection: unique symbol;
/**
* Sets which side the SurfaceSelection will appear on, on the adorned [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*/
TargetSurface: Enum.NormalId;
}
/** The SelectionLasso class is an abstract class of which the inheritors are able to be attached to an object of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) class or the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) class. They can also be attached to a point in the tridimensional space indicated by a Vector3 value. */
interface SelectionLasso extends GuiBase3d {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SelectionLasso: unique symbol;
/**
* The Humanoid that the Lasso belongs to, and will come from.
*/
Humanoid: Humanoid | undefined;
}
/** An instance used to display a “lasso” between a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) Torso and a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). It should be noted that the [GuiBase3d.Transparency](https://developer.roblox.com/en-us/api-reference/property/GuiBase3d/Transparency) property doesn't currently work. */
interface SelectionPartLasso extends SelectionLasso {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SelectionPartLasso: unique symbol;
/**
* Sets the target of the lasso object.
*/
Part: BasePart | undefined;
}
/** A 3D GUI object which displays a lasso between the defined Humanoid and a given Vector3 point. */
interface SelectionPointLasso extends SelectionLasso {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SelectionPointLasso: unique symbol;
/**
* Sets the Vector3 target of the lasso object.
*/
Point: Vector3;
}
interface Path2D extends GuiBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Path2D: unique symbol;
}
/** The GuiService is a service which currently allows developers to control what [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) is currently being selected by the gamepad navigator. It also allows clients to check if Roblox's main menu is currently open.
*
* This service has a lot of hidden members, which are mainly used internally by Roblox's [CoreScripts](https://developer.roblox.com/en-us/api-reference/class/CoreScript).
*/
interface GuiService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_GuiService: unique symbol;
/**
* If the select button on a gamepad will automatically set a GUI as the selected object when the Select button is pressed. Turning this off will mean that Gui navigation will still work if GuiNavigationEnabled is enabled but you will have to set SelectedObject manually to start Gui navigation.
*/
AutoSelectGuiEnabled: boolean;
/**
* Toggles whether or not objects in the [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui) can be navigated using a Gamepad.
*
* Tags: Hidden, NotReplicated
*/
CoreGuiNavigationEnabled: boolean;
/**
* Used to enable and disable the default controller GUI navigation.
*/
GuiNavigationEnabled: boolean;
/**
* This property tells whether or not a modal dialog is visible, such as the game menu or a purchase prompt.
*
* Tags: NotReplicated
* @deprecated
*/
readonly IsModalDialog: boolean;
/**
* The IsWindows property defines if the user is playing on a computer running Windows.
*
* Tags: NotReplicated
* @deprecated
*/
readonly IsWindows: boolean;
/**
* Returns true if any menu of [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui) is open.
*
* Tags: NotReplicated
*/
readonly MenuIsOpen: boolean;
/**
* Tags: Hidden, NotReplicated
*/
readonly PreferredTransparency: number;
/**
* Tags: Hidden, NotReplicated
*/
readonly ReducedMotionEnabled: boolean;
/**
* Sets the [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) currently being focused on by the GUI Navigator (used for Gamepads). This may reset to nil if the object is off-screen.
*
* This property is changed by the [GuiObject.SelectionGained](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionGained) and [GuiObject.SelectionLost](https://developer.roblox.com/en-us/api-reference/event/GuiObject/SelectionLost) events.
*
* If you would like to determine when this property changes without tracking the SelectionGained and SelectionLost events for all GUI elements, you can use the [Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) event.
*/
SelectedObject: GuiObject | undefined;
/**
* Tags: NotReplicated
*/
readonly TopbarInset: Rect;
/**
* Determines whether touch controls are enabled. Defaults to true.
*/
TouchControlsEnabled: boolean;
/**
* Creates a gui selection group where gamepad gui navigation will only consider selectable gui objects that are within the group (children of selectionParent).
*
* A use case is you have a menu pop open, but there are other selectable objects on the screen (maybe from previous menus), but you want to the user to only be able to select gui objects in the new menu.
*/
AddSelectionParent(this: GuiService, selectionName: string, selectionParent: GuiObject): void;
/**
* Functions similarly to [GuiService:AddSelectionParent](https://developer.roblox.com/en-us/api-reference/function/GuiService/AddSelectionParent), but you can give it a tuple of [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject) that you want to be contained in the group.
*/
AddSelectionTuple(this: GuiService, selectionName: string, selections: Array): void;
/**
* This function closes the Inspect Menu, if open, when run from a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* See also
* --------
*
* * [Avatar Inspect Menu](https://developer.roblox.com/articles/avatar-inspect-menu), an article providing a more detailed explanation of the Inspect and Buy feature and how it works
* * [GuiService:InspectPlayerFromHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromHumanoidDescription), allows a developer to bring up the Inspect menu showing the assets listed in this [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) object. This is especially useful when what is being worn on a player's avatar on the Roblox platform is not necessarily the same as their in-game appearance
* * [GuiService:InspectPlayerFromUserId](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromUserId), allows the Inspect Menu to appear showing the user that has the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId). This is especially useful when you want to inspect players who aren't in the current game
*/
CloseInspectMenu(this: GuiService): void;
/**
* Returns a boolean indicating whether or not the player Emotes menu is open.
*
* Developers can open or close the Emotes menu by calling the [GuiService:SetEmotesMenuOpen](https://developer.roblox.com/en-us/api-reference/function/GuiService/SetEmotesMenuOpen) function.
*/
GetEmotesMenuOpen(this: GuiService): boolean;
/**
* This function returns whether or not the [gameplay paused](https://developer.roblox.com/en-us/api-reference/property/Player/GameplayPaused) notification has been disabled by the developer.
*
* Developers can enable or disable the notification by calling the [GuiService:SetGameplayPausedNotificationEnabled](https://developer.roblox.com/en-us/api-reference/function/GuiService/SetGameplayPausedNotificationEnabled) function.
*
* See Also
* --------
*
* * [Workspace.StreamingPauseMode](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingPauseMode), controls which streaming physics pause mode is active
*/
GetGameplayPausedNotificationEnabled(this: GuiService): boolean;
/**
* Returns two [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) values representing the inset of user GUIs in pixels, from the top left corner of the screen and the bottom right corner of the screen respectively.
*
* The inset values supplied by this function only take effect on [ScreenGuis](https://developer.roblox.com/en-us/api-reference/class/ScreenGui) that have their [IgnoreGuiInset](https://developer.roblox.com/en-us/api-reference/property/ScreenGui/IgnoreGuiInset) property set to false.
*/
GetGuiInset(this: GuiService): LuaTuple<[Vector2, Vector2]>;
/**
* This function returns whether the Inspect and Buy menu functionality is currently enabled. The feature is enabled by default and can be set using the [GuiService:SetInspectMenuEnabled](https://developer.roblox.com/en-us/api-reference/function/GuiService/SetInspectMenuEnabled) function.
*
* See also
* --------
*
* * [Avatar Inspect Menu](https://developer.roblox.com/articles/avatar-inspect-menu), an article providing a more detailed explanation of the Inspect and Buy feature and how it works
* * [GuiService:InspectPlayerFromHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromHumanoidDescription), allows a developer to bring up the Inspect menu showing the assets listed in this [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) object. This is especially useful when what is being worn on a player's avatar on the Roblox platform is not necessarily the same as their in-game appearance
* * [GuiService:InspectPlayerFromUserId](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromUserId), allows the Inspect Menu to appear showing the user that has the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId). This is especially useful when you want to inspect players who aren't in the current game
*/
GetInspectMenuEnabled(this: GuiService): boolean;
/**
* This function allows a developer to bring up the Inspect menu showing the assets listed in this [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) object.
*
* This allows further customization with what is shown in the Inspect Menu when players inspect other players in your game. If your game modifies what the players are wearing, you can instead give the Inspect Menu a HumanoidDescription object that represents what a player is wearing and those items will be shown. You should pass a name as well to represent the name of the player that will be inspected.
*
* See also
* --------
*
* * [Avatar Inspect Menu](https://developer.roblox.com/articles/avatar-inspect-menu), an article providing a more detailed explanation of the Inspect and Buy feature and how it works
* * [GuiService:SetInspectMenuEnabled](https://developer.roblox.com/en-us/api-reference/function/GuiService/SetInspectMenuEnabled), allows developers to enable or disable default Inspect and Buy functionality
* * [GuiService:InspectPlayerFromUserId](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromUserId), allows the Inspect Menu to appear showing the user that has the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId). This is especially useful when you want to inspect players who aren't in the current game
*/
InspectPlayerFromHumanoidDescription(
this: GuiService,
humanoidDescription: HumanoidDescription,
name: string,
): void;
/**
* This function allows the Inspect Menu to appear showing the user that has the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId). This is especially useful when you want to inspect players who aren't in the current game.
*
* This shows the same information as the “Currently Wearing” tab on the specified user's profile.
*
* See also
* --------
*
* * [Avatar Inspect Menu](https://developer.roblox.com/articles/avatar-inspect-menu), an article providing a more detailed explanation of the Inspect and Buy feature and how it works
* * `GuiService:SetInspectMenuEnabled`, allows developers to enable or disable default Inspect and Buy functionality. This is especially useful when what is being worn on a player's avatar on the Roblox platform is not necessarily the same as their in-game appearance
* * [GuiService:InspectPlayerFromHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromHumanoidDescription), allows a developer to bring up the Inspect menu showing the assets listed in this [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) object
*/
InspectPlayerFromUserId(this: GuiService, userId: number): void;
/**
* Returns true if the client is using the ten foot interface, which is a special version of Roblox's UI, exclusive to consoles.
*
* This is the only guaranteed way to verify if the user is on a console or not.
*/
IsTenFootInterface(this: GuiService): boolean;
/**
* Removes a group that was created with [GuiService:AddSelectionParent](https://developer.roblox.com/en-us/api-reference/function/GuiService/AddSelectionParent) or [GuiService:AddSelectionTuple](https://developer.roblox.com/en-us/api-reference/function/GuiService/AddSelectionTuple).
*/
RemoveSelectionGroup(this: GuiService, selectionName: string): void;
Select(this: GuiService, selectionParent: Instance): void;
/**
* Opens or closes the player Emotes menu.
*/
SetEmotesMenuOpen(this: GuiService, isOpen: boolean): void;
/**
* This method allows developers to disable the built-in notification when a players gameplay is paused. They can then add in their own UI if they wish to customize it.
*
* Developers can query whether the notification is enabled by calling the [GuiService:GetGameplayPausedNotificationEnabled](https://developer.roblox.com/en-us/api-reference/function/GuiService/GetGameplayPausedNotificationEnabled) function.
*
* See Also
* --------
*
* * [Workspace.StreamingPauseMode](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingPauseMode), controls which streaming physics pause mode is active
*/
SetGameplayPausedNotificationEnabled(this: GuiService, enabled: boolean): void;
/**
* This function allows developers to enable or disable default Inspect and Buy functionality. This is useful when you want to disable the feature in your game, entirely or during certain parts of your game (such as a cutscene). The feature is enabled by default.
*
* The code sample below demonstrates how to disable the Inspect Menu for your game:
*
* local GuiService = game:GetService("GuiService")
* GuiService:SetInspectMenuEnabled(false)
*
* See also
* --------
*
* * [Avatar Inspect Menu](https://developer.roblox.com/articles/avatar-inspect-menu), an article providing a more detailed explanation of the Inspect and Buy feature and how it works
* * [GuiService:InspectPlayerFromHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromHumanoidDescription), allows a developer to bring up the Inspect menu showing the assets listed in this [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription) object. This is especially useful when what is being worn on a player's avatar on the Roblox platform is not necessarily the same as their in-game appearance
* * [GuiService:InspectPlayerFromUserId](https://developer.roblox.com/en-us/api-reference/function/GuiService/InspectPlayerFromUserId), allows the Inspect Menu to appear showing the user that has the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId). This is especially useful when you want to inspect players who aren't in the current game
*/
SetInspectMenuEnabled(this: GuiService, enabled: boolean): void;
/**
* Fires when the user **closes** the Roblox coregui escape menu.
*/
readonly MenuClosed: RBXScriptSignal<() => void>;
/**
* Fires when the user **opens** the Roblox coregui escape menu.
*/
readonly MenuOpened: RBXScriptSignal<() => void>;
}
/** The _Xbox One_ controller and some other USB gamepad controllers have motors built in to provide haptic feedback. Adding rumbles and vibrations can greatly enhance a game's experience and provide subtle feedback that is hard to convey through visuals or audio. */
interface HapticService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HapticService: unique symbol;
/**
* Returns the current vibration value set to the specified [UserInputType](https://developer.roblox.com/api-reference/property/InputObject/UserInputType "UserInputType") and [VibrationMotor](https://developer.roblox.com/api-reference/enum/VibrationMotor "VibrationMotor").
*
* This will not return anything if [SetMotor](https://developer.roblox.com/api-reference/function/HapticService/SetMotor "SetMotor") has not been called prior.
*/
GetMotor(this: HapticService, inputType: CastsToEnum, vibrationMotor: CastsToEnum): unknown;
/**
* Returns true if the specified motor is available to be used with the specified [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType).
*/
IsMotorSupported(this: HapticService, inputType: CastsToEnum, vibrationMotor: CastsToEnum): boolean;
/**
* Returns true if the specified [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType) supports haptic feedback.
*/
IsVibrationSupported(this: HapticService, inputType: CastsToEnum): boolean;
/**
* Sets the vibration intensity of the specified [UserInputType](https://developer.roblox.com/api-reference/property/InputObject/UserInputType "UserInputType") and [VibrationMotor](https://developer.roblox.com/api-reference/enum/VibrationMotor "VibrationMotor").
*/
SetMotor(
this: HapticService,
inputType: CastsToEnum,
motor: CastsToEnum,
vibration: number,
): void;
}
interface HeightmapImporterService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HeightmapImporterService: unique symbol;
}
interface HiddenSurfaceRemovalAsset extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HiddenSurfaceRemovalAsset: unique symbol;
}
interface Highlight extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Highlight: unique symbol;
Adornee: Instance | undefined;
DepthMode: Enum.HighlightDepthMode;
Enabled: boolean;
FillColor: Color3;
FillTransparency: number;
OutlineColor: Color3;
OutlineTransparency: number;
}
/** **HttpService** allows HTTP requests to be sent from game servers using [RequestAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/RequestAsync), [GetAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/GetAsync) and [PostAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/PostAsync). This service allows games to be integrated with off-Roblox web services such as analytics, data storage, remote server configuration, error reporting, advanced calculations or real-time communication.
*
* Enabling HTTP Requests
* ----------------------
*
* Request-sending functions aren't enabled by default: attempting to use them while disabled will result in the error “Http requests are not enabled. Enable via game settings”. To send requests, set [HttpEnabled](https://developer.roblox.com/en-us/api-reference/property/HttpService/HttpEnabled) to true through the Game Settings interface (under the Security section) or the Command Bar (for unpublished games). This property cannot be interacted with at runtime.
*
* \-- For unpublished games, use this in the Command Bar:
* game:GetService("HttpService").HttpEnabled = true
*
* Other Functions
* ---------------
*
* HttpService also houses the [JSONEncode](https://developer.roblox.com/en-us/api-reference/function/HttpService/JSONEncode) and [JSONDecode](https://developer.roblox.com/en-us/api-reference/function/HttpService/JSONDecode) functions, which are useful for communicating with services that use the [JSON](https://json.org) format. In addition, the [GenerateGUID](https://developer.roblox.com/en-us/api-reference/function/HttpService/GenerateGUID) function provides random 128-bit labels, which can be treated as probabilistically unique in a variety of scenarios.
*
* Use in Plugins
* --------------
*
* HttpService can also be used by Roblox Studio plugins. They may do this to check for updates, send usage data, download content or other business logic. The first time a plugin attempts to do this, the user may be prompted to give the plugin permission to communicate with the particular web address. A user may accept, deny and revoke such permissions at any time through the Plugin Management window.
*
* Plugins may also communicate with other software running on the same computer through the `localhost` and `127.0.0.1` hosts. By running programs compatible with such plugins, you can extend the functionality of your plugin beyond the normal capabilities of Roblox Studio, such as interacting with your computer's file system. Beware that such software must be distributed separately from the plugin itself, and can pose security hazards if you aren't careful.
*
* Considerations
* --------------
*
* * There are port restrictions. You cannot use port 1194 or any port below 1024, except 80 and 443. If you try to use a blocked port, you will receive either a `403 Forbidden` or `ERR_ACCESS_DENIED` error.
* * For each Roblox game server, there is a limit of 500 HTTP requests per minute. Exceeding this may cause request-sending functions to stall entirely for about 30 seconds.
* * Requests cannot be made to any Roblox website, such as [www.roblox.com](http://www.roblox.com).
* * Web requests can fail for many reasons, so it is important to “code defensively” (use `pcall`) and have a plan for when requests fail.
* * Although the `http://` protocol is supported, you should use `https://` wherever possible.
* * Requests sent should provide a secure form of authentication, such as a pre-shared secret key, so that bad actors cannot pose as one of your Roblox game servers.
* * Be aware of the general capacity and rate-limiting policies of the web servers to which requests are being sent.
*/
interface HttpService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HttpService: unique symbol;
/**
* The GenerateGUID function randomly creates a [universally unique identifier (UUID)](https://en.wikipedia.org/wiki/Universally_unique_identifier) string.
*
* The sixteen octets of a UUID are represented as 32 hexadecimal (base 16) digits, displayed in 5 groups separated by hyphens in the form `8-4-4-4-12` for a total of 36 characters. For example: `123e4567-e89b-12d3-a456-426655440000`.
*
* The _wrapInCurlyBraces_ argument determines whether the returned string is wrapped in curly braces _{}_. For instance:
*
* * **true** - _{94b717b2-d54f-4340-a504-bd809ef5bf5c}_
* * **false** - _db454790-7563-44ed-ab4b-397ff5df737b_
*/
GenerateGUID(this: HttpService, wrapInCurlyBraces?: boolean): string;
GetSecret(this: HttpService, key: string): Secret;
/**
* The JSONDecode function transforms a [JSON object or array](http://robloxdev.com/articles/JSON-Storage-Format) into a Lua [table](http://robloxdev.com/articles/Table) with the following characteristics:
*
* * Keys of the table are strings or numbers but not both. If a JSON object contains both, string keys are ignored.
* * An empty JSON object generates an empty Lua table `{}`.
* * If the _input_ string is not a valid JSON object, this function will throw an error.
*
* To encode a Lua table into a JSON object, you can use [HttpService's](https://developer.roblox.com/en-us/api-reference/class/HttpService) [HttpService:JSONEncode](https://developer.roblox.com/en-us/api-reference/function/HttpService/JSONEncode) function.
*
* Many web endpoints use JSON, as it is commonly used on the Internet. Visit [JSON.org](http://www.json.org/) to become more familiar with the format.
*
* This method can be used regardless of whether HTTP Requests are [enabled](https://developer.roblox.com/en-us/api-reference/property/HttpService/HttpEnabled).
*
* Tags: CustomLuaState
*/
JSONDecode(this: HttpService, input: string): unknown;
/**
* The JSONEncode function transforms a Lua [table](http://robloxdev.com/articles/Table) into a [JSON object or array](http://robloxdev.com/articles/JSON-Storage-Format) based on the following guidelines:
*
* * Keys of the table must be either strings or numbers. If a table contains both, an array takes priority (string keys are ignored).
* * An empty Lua table `{}` generates an empty JSON array.
* * The value `nil` is never generated.
* * Cyclic table references cause an error.
*
* This function allows values such as _inf_ and _nan_, which are not valid JSON. This may cause problems if you want to use the outputted JSON elsewhere.
*
* To reverse the encoding process, and decode a JSON object, you can use [HttpService's](https://developer.roblox.com/en-us/api-reference/class/HttpService) [HttpService:JSONDecode](https://developer.roblox.com/en-us/api-reference/function/HttpService/JSONDecode) function.
*
* Many web endpoints use JSON, as it is commonly used on the Internet. Visit [JSON.org](http://robloxdev.com/articles/JSON-Storage-Format) to become more familiar with the format.
*
* This method can be used regardless of whether HTTP Requests are [enabled](https://developer.roblox.com/en-us/api-reference/property/HttpService/HttpEnabled).
*
* Tags: CustomLuaState
*/
JSONEncode(this: HttpService, input: unknown): string;
/**
* The UrlEncode function [percent-encodes](https://en.wikipedia.org/wiki/Percent-encoding) a given string so that reserved characters properly encoded with '%' and two hexadecimal characters.
*
* This is useful when formatting URLs for use with [HttpService:GetAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/GetAsync)/[HttpService:PostAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/PostAsync), or POST data of the media type `application/x-www-form-urlencoded` ([Enum.HttpContentType.ApplicationUrlEncoded](https://developer.roblox.com/en-us/api-reference/enum/HttpContentType)).
*
* For instance, when you encode the URL:
*
* http://robloxdev.com/api-reference/function/HttpService/UrlEncode
*
* the function returns the string:
*
* http%3A%2F%2Frobloxdev%2Ecom%2Fapi%2Dreference%2Ffunction%2FHttpService%2FUrlEncode
*/
UrlEncode(this: HttpService, input: string): string;
/**
* The GetAsync function sends an HTTP GET request. It functions similarly to [RequestAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/RequestAsync) except that it accepts HTTP request parameters as method parameters instead of a single dictionary and returns only the body of the HTTP response. Generally, this method is useful only as a shorthand and [RequestAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/RequestAsync) should to be used in most cases. For a detailed guide on sending and retrieving data via HTTP requests, see the [Sending HTTP Requests](https://developer.roblox.com/articles/Sending-HTTP-requests) article.
*
* When true, the `nocache` parameter prevents this function from caching results from previous calls with the same `url`.
*
* Tags: Yields
*/
GetAsync(this: HttpService, url: string, nocache?: boolean, headers?: HttpHeaders): string;
/**
* The PostAsync function sends an HTTP POST request. It functions similarly to [RequestAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/RequestAsync) except that it accepts HTTP request parameters as method parameters instead of a single dictionary and returns only the body of the HTTP response. Generally, this method is useful only as a shorthand and [RequestAsync](https://developer.roblox.com/en-us/api-reference/function/HttpService/RequestAsync) should to be used in most cases. For a detailed guide on sending and retrieving data via HTTP requests, see the [Sending HTTP Requests](https://developer.roblox.com/articles/Sending-HTTP-requests) article.
*
* When true, the `compress` parameter controls whether large request bodies will be compressed using gzip.
*
* Tags: Yields
*/
PostAsync(
this: HttpService,
url: string,
data: string,
content_type?: CastsToEnum,
compress?: boolean,
headers?: HttpHeaders,
): string;
/**
* The **RequestAsync()** function sends an HTTP request using a dictionary to specify the request data, such as the target URL, method, headers and request body data. It returns a dictionary that describes the response data received.
*
* Request Dictionary Fields
* -------------------------
*
* Name
*
* Type
*
* Required
*
* Description
*
* **Url**
*
* String
*
* yes
*
* The target URL for this request. Must use `http` or `https` protocols.
*
* **Method**
*
* String
*
* no
*
* The HTTP method being used by this request, most often GET or POST.
*
* **Headers**
*
* Dictionary
*
* no
*
* A dictionary of headers to be used with this request. Most HTTP headers are accepted here, but not all.
*
* **Body**
*
* String
*
* no
*
* The request body. Can be any string, including binary data. Must be excluded when using the GET or HEAD HTTP methods. It might be necessary to specify the `Content-Type` header when sending JSON or other formats.
*
* ### HTTP Headers
*
* In the request dictionary, you can specify custom HTTP headers to use in the request. However, some headers cannot be specified. For example, `Content-Length` is determined from the request body. `User-Agent` and `Roblox-Id` are locked by Roblox. Other headers like `Accept` or `Cache-Control` use default values but can be overridden. More commonly, some REST APIs may require API keys or other service authentication to be specified in request headers.
*
* This method does not detect the format of body content. Many web servers require the `Content-Type` header be set appropriately when sending certain formats. Other methods of [HttpService](https://developer.roblox.com/en-us/api-reference/class/HttpService) use the [HttpContentType](https://developer.roblox.com/en-us/api-reference/enum/HttpContentType) enum; for this method set the `Content-Type` header appropriately: `text/plain`, `text/xml`, `application/xml`, `application/json` or `application/x-www-form-urlencoded` are replacement `Content-Type` header values for the respective enum values.
*
* Response Dictionary Fields
* --------------------------
*
* The function returns a dictionary containing the following fields:
*
* Name
*
* Type
*
* Description
*
* **Success**
*
* Boolean
*
* The success status of the request. This is true if and only if the **StatusCode** lies within the range \[200, 299\].
*
* **StatusCode**
*
* Integer
*
* The HTTP response code identifying the status of the response.
*
* **StatusMessage**
*
* String
*
* The status message that was sent back.
*
* **Headers**
*
* Dictionary
*
* A dictionary of headers that were set in this response.
*
* **Body**
*
* The request body (content) received in the response.
*
* Error Cases
* -----------
*
* This method raises an error if the response times out or if the target server rejects the request. If a web service goes down for some reason, it can cause scripts that use this method to stop functioning altogether. It is often a good idea to wrap calls to this method in `pcall` and gracefully handle failure cases if the required information isn't available.
*
* Limitations
* -----------
*
* The current limitation for sending and receiving HTTP requests is 500 requests per minute. Requests over this threshold will fail. Additionally, Roblox domains are blacklisted. This means that HTTP requests cannot be sent to any Roblox owned site, such as [www.roblox.com](https://www.roblox.com).
*
* Tags: Yields
*/
RequestAsync(this: HttpService, requestOptions: RequestAsyncRequest): RequestAsyncResponse;
}
/** The Humanoid is a special object that gives models the functionality of a character. It grants the model with the ability to physically walk around and interact with various components of a Roblox level.
*
* Humanoids are always parented inside of a [Model](https://developer.roblox.com/en-us/api-reference/class/Model), and the model is expected to be an assembly of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) and [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D); the root part of the assembly is expected to be named _HumanoidRootPart_. It also expects a part named _Head_ to be connected to the character's torso part, either directly or indirectly.
*
* By default, there are two official types of character rigs supplied by Roblox, each with their own set of rules:
*
*
* ### R6
*
* * A basic character rig that uses 6 parts for limbs.
*
* * The _Head_ part must be attached to a part named _Torso_, or the Humanoid will die immediately.
* * BodyPart appearances are applied using [CharacterMesh](https://developer.roblox.com/en-us/api-reference/class/CharacterMesh) objects.
* * Certain properties, such as [Humanoid.LeftLeg](https://developer.roblox.com/en-us/api-reference/property/Humanoid/LeftLeg) and [Humanoid.RightLeg](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RightLeg), only work with R6.
*
* ### R15
*
* * More complex than R6, but also far more flexible and robust.
* * Uses 15 parts for limbs.
* * The _Head_ part must be attached to a part named _UpperTorso_ or the Humanoid will die immediately.
* * BodyPart appearances have to be assembled directly.
* * Can be dynamically rescaled by using special [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) objects parented inside of the Humanoid.
* * The Humanoid will automatically create [Vector3Value](https://developer.roblox.com/en-us/api-reference/class/Vector3Value) objects named _OriginalSize_ inside of each limb.
* * If a NumberValue is parented inside of the Humanoid and is named one of the following, it will be used to control the scaling functionality:
* * BodyDepthScale
* * BodyHeightScale
* * BodyWidthScale
* * HeadScale
*/
interface Humanoid extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Humanoid: unique symbol;
/**
* AutoJumpEnabled sets whether or not the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will attempt to automatically jump over an obstacle it is walking towards.
*
* Currently, this property only works when the following conditions are true:
*
* * The Humanoid's character model is the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) of a [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
* * The Player in question is using touch controls.
*
* When a player's character spawns, the property's value matches the player's [Player.AutoJumpEnabled](https://developer.roblox.com/en-us/api-reference/property/Player/AutoJumpEnabled) property - which in turn matches the [StarterPlayer.AutoJumpEnabled](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/AutoJumpEnabled) property.
*/
AutoJumpEnabled: boolean;
/**
* The AutoRotate property describes whether or not the Humanoid will automatically rotate to face in the direction they are moving. When set to true, the character model will gradually turn to face their movement direction as the Humanoid walks around. When set to false, the character model will remain fixated in its current rotation, unless a rotating force is applied to the _HumanoidRootPart_.
*
* If the character model happens to be the character of a player, then the behavior of the Humanoid's rotation is influenced by the UserGameSetting's RotateType property.
*
* When the AutoRotate property is set to true, the RotateType property has the following effects on the Humanoid's rotation:
*
* RotationType
*
* Behavior
*
* Context
*
* CameraRelative
*
* Character will rotate to face in the direction of the camera.
*
* Player has their camera zoomed into first-person, or they are in shift-lock mode.
*
* CameraRelative
*
* Character will rotate to face in the direction of the camera.
*
* Player has their camera zoomed into first-person, or they are in shift-lock mode.
*/
AutoRotate: boolean;
AutomaticScalingEnabled: boolean;
/**
* Determines whether a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) joints break when in the Dead state. Defaults to true.
*
* If it is set to false, BreakJoints will not be called on death or after death. If it is set to true, the existing break-joints-every-frame behavior will be used.
*/
BreakJointsOnDeath: boolean;
/**
* The CameraOffset property specifies an offset to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera)'s subject position when its [Camera.CameraSubject](https://developer.roblox.com/en-us/api-reference/property/Camera/CameraSubject) is set to this [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* The offset is applied in object-space, relative to the orientation of the Humanoid's _HumanoidRootPart_. For example, an offset [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) value of _(0, 10, 0)_ offsets the player's camera to 10 studs above the player's humanoid.
*/
CameraOffset: Vector3;
/**
* This property selects the [HumanoidCollisionType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidCollisionType) for R15 and Rthro non-player characters.
*
* The collision geometry for the InnerBox type is calculated at run-time and will not be applied in Studio when the simulation is not running.
*
* For player [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character) the CollisionType property will be decided by the Avatar Collision Option in Game Settings.
*
* 
*
* This property is writable by [Plugins](https://developer.roblox.com/en-us/api-reference/class/Plugin) and can be read by all scripts.
*
* ### Enums
*
* Name
*
* Value
*
* Description
*
* ### OuterBox
*
* 0
*
* Dynamically sized collision boxes based on mesh sizes
*
* ### Innerbox
*
* 1
*
* Fixed size collision boxes, similar to the classic avatar collision
* @deprecated
*/
CollisionType: Enum.HumanoidCollisionType;
/**
* The DisplayDistanceType property controls how the humanoid display's visibility behaves, based on the distance between the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) and the player's view.
*
* When a Humanoid's parent `BaseModel` has a part named _Head_, a visual display of the [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s name and health is drawn 1.5 studs above the character's head. This visual display is known as the **Humanoid Display**.
*
* This property is set using the [HumanoidDisplayDistanceType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidDisplayDistanceType) enum. There are three available values for this property, each with their own set of rules:
*
* None
* ----
*
* When the DisplayDistanceType is set to **None**, the humanoid display will not be shown under any circumstances.
*
* Viewer
* ------
*
* When the DisplayDistanceType is set to **Viewer**, the humanoid display's visibility is locally controlled by the NameDisplayDistance and HealthDisplayDistance of each Player in the game. For instance, if a player has their display distance properties set to 50, and everyone else has their display distance properties set to 100, then that player will not be able to see the name and health of the humanoid at a distance greater than 50 studs, while everyone else can still see the name and health of the humanoid up to a distance of 100 studs.
*
* 
*
* In this example all of the NPC characters have their DisplayDistanceType set to Viewer. This means the distance the information will be displayed will be taken from the humanoid that is viewing them. In this case, the player character (who is in the foreground) has its HealthDisplayDistance set to 10 and NameDisplayDistance set to 20. The health bar is only visible on the closest NPC because it is within 10 studs, and the names of only the two closer NPCs are visible because they are within 20 studs.
*
* When the DisplayDistanceType is set to **Viewer** and there is no local [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), a default value of 100 will be used.
*
* * * *
*
* Subject
* -------
*
* When the DisplayDistanceType is set to **Subject** the Humanoid's name and healthbar will be displayed based on the viewed humanoid's settings. This is useful when there are specific characters who you want to behave differently from other ones.
*
* 
*
* In this example all of the NPC characters have their DisplayDistanceType set to Subject. This means the view distance of their information will depend on their individual HealthDisplayDistance and NameDisplayDistance properties.
*
* * The NPC on the left has its HealthDisplayDistance and NameDisplayDistance set to 10. Since the NPC is 15 studs away, neither of the displays are visible.
*
* * The NPC in the middle has its HealthDisplayDistance set to 10 and NameDisplayDistance set to 20. Since the NPC is 15 studs away, only the name is visible.
*
* * The NPC on the right has its HealthDisplayDistance and NameDisplayDistance set to 20. Both name and health are visible, as the NPC is only 15 studs away.
*/
DisplayDistanceType: Enum.HumanoidDisplayDistanceType;
/**
* `DisplayName` is a property that determines the Humanoid's name display when visible. By default, a new Humanoid will have the value of an empty string. If `DisplayName` is an empty string, the humanoid's name display will default to the humanoid's parent's name property.
*
* **Player Character Loading**
* When players load their character, either automatically or through the use of [LoadCharacter()](https://developer.roblox.com/api-reference/function/Player/LoadCharacter), the Humanoid that is created by the engine will have its `DisplayName` property set to the player's `DisplayName`
* property.
*
* **StarterCharacter and StarterHumanoid**
* When a Humanoid named `StarterHumanoid` is parented to [StarterPlayer](https://developer.roblox.com/api-reference/class/StarterPlayer), or when a Humanoid is present in a Model named `StarterCharacter`, the DisplayName property will be respected when Characters are loaded by Players in the game. The engine will only override the `DisplayName` property of the Humanoid with the `DisplayName` property of the player if the `StarterHumanoid`'s `DisplayName` property is an empty string.
*/
DisplayName: string;
EvaluateStateMachine: boolean;
/**
* This is a read-only property that describes the [Material](https://developer.roblox.com/en-us/api-reference/enum/Material) the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently standing on.
* It works with both regular [Parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) voxels.
*
* The code sample below demonstrates how to listen to when this property changes using [Instance:GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal). When the material the humanoid is standing on changes, it will print a message indicating the new material being stood on.
*
* local Humanoid = route.to.humanoid
*
* Humanoid:GetPropertyChangedSignal("FloorMaterial"):Connect(function()
* print("New value for FloorMaterial: " .. tostring(Humanoid.FloorMaterial))
* end)
*
* Caveats
* -------
*
* * When the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is not standing on a floor, the value of this property will be set to _Air_.
* * This occurs because Enum properties cannot have an empty value.
* * This can cause some confusion if a part has its material is set to Air, though in practice, parts are not supposed to use that material in the first place.
* * The [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) character model must be able to collide with the floor, or else it will not be detected.
* * You cannot test if the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is swimming with this property. You should instead use the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Humanoid:GetState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) function.
*
* Tags: NotReplicated
*/
readonly FloorMaterial: Enum.Material;
/**
* **Health** is a property that represents the current health of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The value is restricted to the range \[0, [Humanoid.MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth)\]. If the Humanoid is dead, Health is continually set to 0.
*
* 
*
* Dealing Damage
* --------------
*
* The [TakeDamage](https://developer.roblox.com/en-us/api-reference/function/Humanoid/TakeDamage) function should be used to subtract from Health. If a Humanoid has a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) as a sibling, the function will **not** lower Health.
*
* Regeneration
* ------------
*
* If there is no [Script](https://developer.roblox.com/en-us/api-reference/class/Script) named “Health” within [StarterCharacterScripts](https://developer.roblox.com/en-us/api-reference/class/StarterCharacterScripts), a passive health regeneration script is automatically inserted. This causes players' characters to spawn with the same health regeneration script, which adds 1% of [MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth) to Health each second, while the Humanoid is not dead. To disable this health regeneration behavior, add an empty Script named “Health” to [StarterCharacterScripts](https://developer.roblox.com/en-us/api-reference/class/StarterCharacterScripts).
*
* Health Bar Display
* ------------------
*
* 
*
* When Health is less than [MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth), a health bar is displayed under the Humanoid's name in-game. The display behavior of the health bar is dependent on the [HealthDisplayDistance](https://developer.roblox.com/en-us/api-reference/property/Humanoid/HealthDisplayDistance) and [HealthDisplayType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/HealthDisplayType).
*
* 
*
* A [Player](https://developer.roblox.com/en-us/api-reference/class/Player) will not see their own name and health bar above their [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character). Instead, it is displayed in the top right corner of the screen on the top bar. The health bar is visible when Health is less than [MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth).
*
* Death
* -----
*
* When the value of the character's health reaches 0, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will automatically transitions to the _Dead_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType). In this state, Health is locked to 0; however, there is no error or warning for setting the Health of a dead Humanoid to a positive nonzero value.
*
* 
*
* Tags: NotReplicated
*/
Health: number;
/**
* HealthDisplayDistance is a number used in conjunction with the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)'s [Humanoid.DisplayDistanceType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/DisplayDistanceType) property to control how far a humanoid's health bar can be seen from in studs.
*
* The DisplayDistanceType property is to one of three values using the [HumanoidDisplayDistanceType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidDisplayDistanceType) enum.
*
* * * *
*
* DisplayDistanceType set to “None”##
* -----------------------------------
*
* When a humanoid's DisplayDistanceType is set to **None**, its health bar will never be visible to anyone under any circumstances.
*
* * * *
*
* DisplayDistanceType set to “Viewer”##
* -------------------------------------
*
* When a humanoid's DisplayDistanceType is set to **Viewer**, the visibility of its health bar is dependent upon the HealthDisplayDistance of the player viewing it.
*
* If the distance between the character models of the viewer and the humanoid is outside the range of the viewer's HealthDisplayDistance, then the health bar will not be shown to the viewer.
*
* * * *
*
* DisplayDistanceType set to “Subject”##
* --------------------------------------
*
* When a humanoid's DisplayDistanceType is set to **Subject**, the visibility of its health bar is dependent upon the value of the humanoid's own HealthDisplayDistance.
*
* If the distance between the character models of the viewing player and the humanoid is outside the range of the humanoid's HealthDisplayDistance, then the health bar will not be shown to the viewing player.
*
* * * *
*/
HealthDisplayDistance: number;
/**
* 
* HealthDisplayType controls when a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) health bar is allowed to be displayed.
*
* By default, this property is set to **DisplayWhenDamaged**, which makes the health bar only display when a humanoid's [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) is less than its [Humanoid.MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth). It can also be set to **AlwaysOn**, which makes the health bar always display, or **AlwaysOff**, which prevents it from ever displaying.
*
* This property functions independently of the humanoid's [Humanoid.HealthDisplayDistance](https://developer.roblox.com/en-us/api-reference/property/Humanoid/HealthDisplayDistance) property, which is responsible for making the health bar fade out at certain distances. If the HealthDisplayType is set to AlwaysOn, it will still fade out depending the how the [Humanoid.HealthDisplayDistance](https://developer.roblox.com/en-us/api-reference/property/Humanoid/HealthDisplayDistance) is configured.
*/
HealthDisplayType: Enum.HumanoidHealthDisplayType;
/**
* HipHeight determines the distance (in studs) off the ground the [Humanoid.RootPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart) should be when the Humanoid is standing. The [RigType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RigType) influences the way this property behaves:
*
* HipHeight for R15 Humanoids
* ---------------------------
*
* With R15 rigs, a suitable HipHeight is preset to ensure the height of the [Humanoid.RootPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart) is correct. The height of the legs is not used. The overall height of the Humanoid can be described in the following formula:
*
* Height = (0.5 \* RootPart.Size.Y) + HipHeight
*
* HipHeight for R6 Humanoids
* --------------------------
*
* For R6 rigs, the [RootPart's](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart) height is determined by the height of the character's legs and [Humanoid.RootPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart). HipHeight instead describes a relative offset. The overall height of the Humanoid can be described in the following formula:
*
* Height = LeftLeg.Size.Y + (0.5 \* RootPart.Size.Y) + HipHeight
*/
HipHeight: number;
/**
* Whether the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is jumping. If set to true, it will cause the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to jump. The humanoid jumps with an upwards force equal to the value of its [Humanoid.JumpPower](https://developer.roblox.com/en-us/api-reference/property/Humanoid/JumpPower) property.
*
* 
*
* [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) are able to jump roughly 7.5 studs high by default, depending on both the [Workspace's](https://developer.roblox.com/en-us/api-reference/class/Workspace) [Workspace.Gravity](https://developer.roblox.com/en-us/api-reference/property/Workspace/Gravity), and the [Humanoid.JumpPower](https://developer.roblox.com/en-us/api-reference/property/Humanoid/JumpPower) of the humanoid itself.
*
* Tags: NotReplicated
*/
Jump: boolean;
/**
* Provides control over the height a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) jumps in studs. The starting value of this property is determined by the value of [StarterPlayer.CharacterJumpHeight](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterJumpHeight), which defaults to 7.2.
*
* This property is only visible in the Properties window if [Humanoid.UseJumpPower](https://developer.roblox.com/en-us/api-reference/property/Humanoid/UseJumpPower) is set to **false**, as it would not be relevant otherwise.
*
* This property can be used to adjust the height that a humanoid can jump, allowing developers to remove jumping, allow dynamically adjustable jump height based on character stats or raise the jump height (as if on the moon or such).
*/
JumpHeight: number;
/**
* Determines how much upwards force is applied to the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when jumping. The starting value of this property is determined by the value of [StarterPlayer.CharacterJumpPower](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterJumpPower), which defaults to 50 and is constrained between 1 and 1000.
*
* This property is only visible in the Properties window if \`Humanoid/UseJumpPower\`\` is set to **true**, as it would not be relevant otherwise.
*
* Notes
* -----
*
* * Jumps are also influenced by the [Workspace.Gravity](https://developer.roblox.com/en-us/api-reference/property/Workspace/Gravity) property which determines the acceleration due to gravity.
* * Although setting this property to 0 will prevent the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) from jumping, developers are advised to disable the “Jumping” state using the [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled) function.
*/
JumpPower: number;
/**
* A reference to the humanoid's _Left Leg_ part. The value of this property will always be nil if the humanoid's RigType is set to R15.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
LeftLeg: BasePart | undefined;
/**
* The maximum value of a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health). The value of this property is used with the value of the [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) property to size the default health bar display.
*
* When a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) reaches its maximum value, its health bar may not be displayed anymore, depending on its [Humanoid.HealthDisplayType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/HealthDisplayType) property, as seen below:
*
* 
*/
MaxHealth: number;
/**
* This property determines the maximum slope angle that a humanoid can climb. If the angle of a slope is greater than a humanoid's MaxSlopeAngle, they will slide down the slope.
*
* When a character spawns, this property is set according to the value of [StarterPlayer.CharacterMaxSlopeAngle](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterMaxSlopeAngle).
*
* The value of this property is constrained to values between 0° and 89°. It defaults to 89°, so humanoids can climb pretty much any slope they want by default.
*/
MaxSlopeAngle: number;
/**
* MoveDirection is a read-only property that describes the direction a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is walking in, as a unit vector along the X/Z axis. The direction is described in world space.
*
* Because the property is read-only, it cannot be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* The animation below visualizes the property:
* 
*
* Tags: NotReplicated
*/
readonly MoveDirection: Vector3;
/**
* The NameDisplayDistance property is a number used in conjunction with the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)'s [Humanoid.DisplayDistanceType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/DisplayDistanceType) property to control how far a humanoid's name can be seen from.
*
* The DisplayDistanceType property is to one of three values using the [HumanoidDisplayDistanceType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidDisplayDistanceType) enum.
*
* * * *
*
* DisplayDistanceType set to “None”##
* -----------------------------------
*
* When a humanoid's DisplayDistanceType is set to **None**, its name will never be visible to anyone under any circumstances.
*
* * * *
*
* DisplayDistanceType set to “Viewer”##
* -------------------------------------
*
* When a humanoid's DisplayDistanceType is set to **Viewer**, the visibility of its name is dependent upon the NameDisplayDistance of the player viewing it.
*
* If the distance between the character models of the viewer and the humanoid is outside the range of the viewer's NameDisplayDistance, then the humanoid's name will not be shown to the viewer.
*
* * * *
*
* DisplayDistanceType set to “Subject”##
* --------------------------------------
*
* When a humanoid's DisplayDistanceType is set to **Subject**, the visibility of its name is dependent upon the value of the humanoid's own NameDisplayDistance.
*
* If the distance between the character models of the viewing player and the humanoid is outside the range of the humanoid's NameDisplayDistance, then the humanoid's name will not be shown to the viewing player.
*
* * * *
*/
NameDisplayDistance: number;
/**
* Controls whether a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) name can be seen behind walls or other objects.
*
* This property is a [NameOcclusion](https://developer.roblox.com/en-us/api-reference/enum/NameOcclusion) value and can be configured to occlude all names, enemies names only or disable occlusion entirely.
*
* How does NameOcclusion work?
* ----------------------------
*
* This property applies based on the viewing [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). If the viewing [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) NameOcclusion property is set to OccludeAll, all [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) name tags will be occluded for that [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
*
* NameOcclusion when there is no local Humanoid
* ---------------------------------------------
*
* In cases where the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) has no [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) associated with it. This property will instead apply for the subject [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). This means in such cases, a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Humanoid.NameOcclusion](https://developer.roblox.com/en-us/api-reference/property/Humanoid/NameOcclusion) property determines the occlusion of that [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) name for the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer).
*/
NameOcclusion: Enum.NameOcclusion;
/**
* PlatformStand describes whether the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently in the _PlatformStanding_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType). When true, the Humanoid is in a state where it is free-falling and cannot move. This state behaves similar to sitting, except that jumping does not free the humanoid from the state.
*
* The now-deprecated [SkateboardPlatform](https://developer.roblox.com/en-us/api-reference/class/SkateboardPlatform) puts the Humanoid into this state, much like how a [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) causes a sitting state.
*/
PlatformStand: boolean;
/**
* Allows developers to disable the behavior where a player [character](https://developer.roblox.com/en-us/api-reference/class/Character) dies if the Neck [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) is removed or disconnected even momentarily. This property defaults to true.
*/
RequiresNeck: boolean;
/**
* 
*
* RigType describes whether a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is utilizing the legacy R6 character rig, or the new R15 character rig.
*
* The R6 rig uses 6 visible [Parts](https://developer.roblox.com/en-us/api-reference/class/Part), while the R15 rig uses 15 visible [Parts](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* R15 rigs have more joints than R6 rigs, making them much more versatile when being animated.
*
* Notes
* -----
*
* * If this property is set incorrectly, then the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will not function correctly. For example, if a R15 [Character's](https://developer.roblox.com/en-us/api-reference/property/Player/Character) [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) RigType is set to R6 then the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will die as there is no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) called _Torso_ connected to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) called _Head_
*/
RigType: Enum.HumanoidRigType;
/**
* A reference to the humanoid's _Right Leg_ part. The value of this property will always be nil if the humanoid's RigType is set to R15.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
RightLeg: BasePart | undefined;
/**
* 
*
* A reference to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) HumanoidRootPart, which is the root driving part of the Humanoid, that controls a humanoid's movement through the game world. This part is normally invisible.
*
* Notes
* -----
*
* * In the case of [Player](https://developer.roblox.com/en-us/api-reference/class/Player) [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character) the RootPart is also the [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) of the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) [Model](https://developer.roblox.com/en-us/api-reference/class/Model)
* * The RootPart is the [RootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart) of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Model's](https://developer.roblox.com/en-us/api-reference/class/Model) assembly. As such, if a developer wishes to move the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) they should do so via the RootPart
*
* Tags: NotReplicated
*/
readonly RootPart: BasePart | undefined;
/**
* 
*
* SeatPart is a reference to the seat that a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently sitting in, if any. The value of this property can be either a [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat), or a [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat). It will be _nil_ if the Humanoid is not currently sitting in a seat.
*
* Notes
* -----
*
* * For a bool describing if the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently sitting or not, see [Humanoid.Sit](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Sit)
*
* Tags: NotReplicated
*/
readonly SeatPart: BasePart | undefined;
/**
* 
*
* The Sit property is a boolean that indicates whether the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently sitting. [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) can be forced into a sitting state by setting this property's value to true. If the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) isn't attached to a seat while in its sitting state, it will trip over with no collision in its legs. A [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) can escape from the sitting state by jumping.
*
* Notes
* -----
*
* * The [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) or [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat) the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is sitting on can be obtained using the [Humanoid.SeatPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/SeatPart) property
* * It is possible to detect when a Humanoid sits by connecting to the [Humanoid.Seated](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Seated) event.
*/
Sit: boolean;
/**
* **Do not use**
* This property only works with Experimental Mode enabled, which has been entirely discontinued.
*
* This property describes a 3D position in space where the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) controlling this [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) last clicked with a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) equipped.
*
* This property is primarily used by classic tools to determine what a humanoid is targeting when they activate a tool. If you give an NPC a classic rocket launcher, set their **TargetPoint**, and then call the tool's [Tool:Activate](https://developer.roblox.com/en-us/api-reference/function/Tool/Activate) function, you can make the NPC fire a rocket at the target point.
*/
TargetPoint: Vector3;
/**
* A reference to a humanoid's root driving part.
* Contrary to the name of this property, it will only point to the Torso part if a humanoid doesn't have a HumanoidRootPart.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
Torso: BasePart | undefined;
/**
* This property determines whether the [CharacterJumpHeight](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterJumpHeight) (false) or [StarterPlayer.CharacterJumpPower](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterJumpPower) (true) property is used.
*
* When a character spawns, this property is set according to the value of [StarterPlayer.CharacterUseJumpPower](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterUseJumpPower) which defaults to true.
*/
UseJumpPower: boolean;
/**
* WalkSpeed is a property that describes how quickly this [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is able to walk, in studs per second. This property defaults to the value of [StarterPlayer.CharacterWalkSpeed](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CharacterWalkSpeed), which defaults to 16, meaning a Roblox [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) can move 16 studs in any direction each second by default.
*
* Notes
* -----
*
* * When controlled on a mobile device or a gamepad, a humanoid can walk slower than their WalkSpeed if the controlling joystick is moved closer to its center
* * Roblox's default animation script scales a humanoid's movement animations based on how fast it is moving relative to the default speed of 16 studs/sec
* * The speed the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently walking at can be obtained using the [Humanoid.Running](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Running) event
* * Movement speed is reduced to _87.5%_ WalkSpeed when swimming and _70%_ WalkSpeed when climbing
*/
WalkSpeed: number;
/**
* 
*
* WalkToPart is a reference to a part that the Humanoid is trying to reach. This property is normally set when a part is passed as the 2nd argument of the Humanoid's [Humanoid:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Humanoid/MoveTo) function.
*
* When WalkToPart is set and a humanoid is actively trying to reach the part, it will keep updating its Vector3 goal to be the position of the part, plus the [Humanoid.WalkToPoint](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPoint) translated in object space relative to the rotation of the part.
*
* This can be described in Lua as:
*
* goal = humanoid.WalkToPart.CFrame:pointToObjectSpace(humanoid.WalkToPoint)
*
* Caveats
* -------
*
* * Setting the value of WalkToPart isn't sufficient enough to make a humanoid start following a part.
* * The Humanoid is prompted to start attempting to reach a goal when the value of WalkToPoint is changed.
* * This may be changed in the future.
* * The _reach goal_ state of a humanoid will timeout after 8 seconds if it doesn't reach its goal.
* * This is done so that NPCs won't get stuck waiting for [Humanoid.MoveToFinished](https://developer.roblox.com/en-us/api-reference/event/Humanoid/MoveToFinished) to fire.
* * If you don't want this to happen, you should repeatedly call MoveTo so that the timeout will keep resetting.
*/
WalkToPart: BasePart | undefined;
/**
* 
*
* WalkToPoint describes the 3D position in space that a humanoid is trying to reach, after having been prompted to do so by the
* Humanoid's [Humanoid:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Humanoid/MoveTo) function.
*
* If a humanoid's [Humanoid.WalkToPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPart) is set, the goal is set by transforming WalkToPoint relative to the parts position and rotation. If WalkToPart is not set, then the humanoid will try to reach the 3D position specified by WalkToPoint directly.
*
* Caveats
* -------
*
* * The value of WalkToPoint must be changed to a different value in order for the humanoid to start walking towards it.
* * If you want to make a humanoid walk to `0,0,0`, you should use the Humanoid's MoveTo function.
* * This may be changed in the future.
* * The _reach goal_ state of a humanoid will timeout after 8 seconds if it doesn't reach its goal.
* * This is done so that NPCs won't get stuck waiting for [Humanoid.MoveToFinished](https://developer.roblox.com/en-us/api-reference/event/Humanoid/MoveToFinished) to fire.
* * If you don't want this to happen, you should repeatedly call MoveTo so that the timeout will keep resetting.
*/
WalkToPoint: Vector3;
/**
* The AddAccessory function attaches the specified [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent.
*
* How are Accessories attached to Humanoids?
* ------------------------------------------
*
* When this function is called, the [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) is parented to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent and then attached.
*
* An [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) is attached to the character by searching for an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) in the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent that shares the same name as an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) in the accessory's _Handle_ [Part](https://developer.roblox.com/en-us/api-reference/class/Part). If one is found, the _Handle_ part will be connected to the parent of the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) using a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld). This weld will be configured so the [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) occupy the same space.
*
* If the required [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) can not be found, then the [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) will remain parented to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent but it will be unattached.
*/
AddAccessory(this: Humanoid, accessory: Accessory): void;
/**
* Adds a BoolValue to the Humanoid's _Status_ object, whose name is equal to the string passed as the _status_ argument. If the status already exists, a new BoolValue will not be created.
* @deprecated
*/
AddCustomStatus(this: Humanoid, status: string): boolean;
/**
* Adds a BoolValue to the Humanoid's _Status_ object, whose name is equal to the name of the _Status_ enum passed as the _status_ argument. If the status already exists, a new BoolValue will not be created.
* @deprecated
*/
AddStatus(this: Humanoid, status?: CastsToEnum): boolean;
/**
* BuildRigFromAttachments assembles a tree of [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) joints for a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). Motor6D joints are required for the playback of [Animations](https://developer.roblox.com/en-us/api-reference/class/Animation)
*
* Starting from the humanoid's [Humanoid.RootPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart), the function collects all [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s parented in the current part, whose name ends with “RigAttachment”. It then searches for a matching attachment in the character that shares the same name as the attachment. Using those two attachments, a Motor6D joint is generated based on the parts associated with the two attachments, and the [Attachment.CFrame](https://developer.roblox.com/en-us/api-reference/property/Attachment/CFrame)s of the attachments.
*
* See the provided code sample below to see how this function works.
*/
BuildRigFromAttachments(this: Humanoid): void;
/**
* This function causes the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to enter the given [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* The humanoid state describes the activity the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently doing.
*
* You should check the page for [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) for more information on what particular states do as some have unintuitive names. For example, running describes a state where the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) legs are on the ground, including when stationary
*
* Due to the default behavior of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) some states will automatically be changed when set to. For example:
*
* * Setting the state to _'Swimming_' when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is not in the water will lead to it being automatically set to _'GettingUp'_
* * As it is unused, setting the state to _'PlatformStanding'_ will lead to it being automatically set to _'Running'_
*
* See also
* --------
*
* * To enable or disable a particular state use [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled)
* * To get the current state use [Humanoid:GetState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState)
*/
ChangeState(this: Humanoid, state?: CastsToEnum): void;
/**
* This function makes the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) equip the given [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool).
*
* The below example would cause a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) to equip a tool in [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) named _'Tool'_.
*
* local Players = game:GetService("Players")
*
* local player = Players:FindFirstChildOfClass(“Player”)
* if player and player.Character then
* local humanoid = player.Character:FindFirstChildOfClass("Humanoid")
* if humanoid then
* local tool = workspace:FindFirstChild("Tool")
* if tool then
* humanoid:EquipTool(tool)
* end
* end
* end
*
* When this function is called, the humanoid will automatically unequip any [Tools](https://developer.roblox.com/en-us/api-reference/class/Tool) that it currently has equipped
*
* Although they will be equipped, [Tools](https://developer.roblox.com/en-us/api-reference/class/Tool) for which [Tool.RequiresHandle](https://developer.roblox.com/en-us/api-reference/property/Tool/RequiresHandle) is _true_ will not function if they have no handle, regardless if this function is used to equip them or not
*
* See also
* --------
*
* * To unequip tools, use [Humanoid:UnequipTools](https://developer.roblox.com/en-us/api-reference/function/Humanoid/UnequipTools)
*/
EquipTool(this: Humanoid, tool: Tool): void;
/**
* This function returns an array of [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) that the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent is currently wearing. All [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) objects parented to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent will be included, regardless of if they are attached or not. If the humanoid is not wearing any accessories, the array will be empty.
*
* If the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) has no [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) an empty array will be returned
*
* See also
* --------
*
* * Use [Humanoid:AddAccessory](https://developer.roblox.com/en-us/api-reference/function/Humanoid/AddAccessory) to attach an [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) to a [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent
*/
GetAccessories(this: Humanoid): Array;
/**
* This blocking function returns back a copy of the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) cached [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription), which describes its current look.
*
* This can be used to quickly determine a player's look and to assign their look to other players using the [Humanoid:ApplyDescription](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) function.
*
* See also
* --------
*
* * [Players:GetHumanoidDescriptionFromUserId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromUserId), gives back a HumanoidDescription which describes the Avatar for the passed in user
* * [Players:GetHumanoidDescriptionFromOutfitId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromOutfitId), gives back a HumanoidDescription whose parameters are initialized to match that of the passed in server-side outfit asset
* * [Player:LoadCharacterWithHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacterWithHumanoidDescription), spawns a player with the look from the HumanoidDescription Instance passed in
*/
GetAppliedDescription(this: Humanoid): HumanoidDescription;
/**
* This function returns what [BodyPartR15](https://developer.roblox.com/en-us/api-reference/enum/BodyPartR15) a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) is, or `Enum.BodyPartR15.Unknown` if the part is not an R15 body part. This function allows developers to retrieve player body parts independent of what the actual body part names are, instead returning an Enum.
*
* It can be used in conjunction with [Humanoid:ReplaceBodyPartR15](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ReplaceBodyPartR15). For example, if a [player's](https://developer.roblox.com/en-us/api-reference/class/Player) body part touches something, this function will return get a part instance. Developers can then look up what part of the body that was, like head or arm. Then depending on what that part was, developers can either perform some gameplay action or replace that part with some other part - perhaps showing damage.
*
* This function can be useful for games where hit location is important. For example, it can be used to determine if a player is hit in the leg and then slow them down based on the injury.
*/
GetBodyPartR15(this: Humanoid, part: BasePart): Enum.BodyPartR15;
/**
* This function returns the [Limb](https://developer.roblox.com/en-us/api-reference/enum/Limb) enum that is associated with the given [Part](https://developer.roblox.com/en-us/api-reference/class/Part)
*
* This function works for both R15 and R6 rigs, for example:
*
* \-- For R15
* print(humanoid:GetLimb(character.LeftUpperLeg)) -- Enum.Limb.LeftLeg
* print(humanoid:GetLimb(character.LeftLowerLeg)) -- Enum.Limb.LeftLeg
* print(humanoid:GetLimb(character.LeftFoot)) -- Enum.Limb.LeftLeg
*
* -- For R6
* print(humanoid:GetLimb(character:FindFirstChild("Left Leg"))) -- Enum.Limb.LeftLeg
*
* GetLimb will throw an error if the [Part's](https://developer.roblox.com/en-us/api-reference/class/Part) parent is not set to the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent.
*/
GetLimb(this: Humanoid, part: BasePart): Enum.Limb;
/**
* Tags: NotBrowsable
*/
GetMoveVelocity(this: Humanoid): Vector3;
/**
* This function returns an array of all [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that are currently being played on the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* A typical use for this function is stopping currently playing tracks using [AnimationTrack:Stop](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/Stop).
*
* Beware that this function will not return [AnimationTracks](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that have loaded but are **not playing**. If you want to track these you will need to index them manually. See below for one example of how this could be achieved:
*
* local animationTracks = {}
* local track = humanoid:LoadAnimation(animation)
* table.insert(animationTracks, track)
* @deprecated
*/
GetPlayingAnimationTracks(this: Humanoid): Array;
/**
* This function returns the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) current [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* The humanoid state describes the activity the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently doing, such as jumping or freefalling.
*
* See also
* --------
*
* * To change the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) state use [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState)
* * To enable or disable a particular state use [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled)
* * For more information on the different states available, see [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType)
*/
GetState(this: Humanoid): Enum.HumanoidStateType;
/**
* The GetStateEnabled function returns whether a [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is enabled for the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* The humanoid state describes the activity the humanoid is currently doing.
*
* When a particular [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is disabled, the humanoid can never enter that state. This is true regardless if the attempt to change state is made using [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState) or Roblox internal humanoid code.
*
* See also
* --------
*
* * For an event that fires when a humanoid state is enabled or disabled see [Humanoid.StateEnabledChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateEnabledChanged)
* * To enable or disable a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) state use [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled)
*/
GetStateEnabled(this: Humanoid, state: CastsToEnum): boolean;
/**
* The GetStatuses function returns a table of the Humanoid's statuses, and custom statuses.
* @deprecated
*/
GetStatuses(this: Humanoid): unknown;
/**
* The HasCustomStatus function returns boolean based on if custom statuses exist.
* @deprecated
*/
HasCustomStatus(this: Humanoid, status: string): boolean;
/**
* The HasStatus function returns a boolean based on if a status exists.
* @deprecated
*/
HasStatus(this: Humanoid, status?: CastsToEnum): boolean;
/**
* This function loads an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) onto a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), returning an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) that can be used for playback.
*
* The following code can be used to load an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation) onto a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* local animationTrack = humanoid:LoadAnimation(animation)
* animationTrack:Play()
*
* Should I load an Animation on the client or server?
* ---------------------------------------------------
*
* If the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is controlled by a particular client, as is the case with [Player](https://developer.roblox.com/en-us/api-reference/class/Player) [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character) then [Animations](https://developer.roblox.com/en-us/api-reference/class/Animation) should be loaded and played from that client.
*
* If the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) belongs to a NPC (Non Player Character) which the server has [network ownership](http://robloxdev.com/articles/Network-Ownership) of then the [Animations](https://developer.roblox.com/en-us/api-reference/class/Animation) should be loaded and played from the server.
*
* Although generally it is not advisable to do so, these rules can be bypassed using the [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator) object.
* @deprecated
*/
LoadAnimation(this: Humanoid, animation: Animation): AnimationTrack;
/**
* This function causes the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to walk in the given [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) _direction_.
*
* By default, the _direction_ given is in world terms. If the _relativeToCamera_ parameter is _true_ however the _direction_ given is relative to the [CurrentCamera's](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame). As the negative Z direction is considered 'forwards' in Roblox, the following code would make the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) walk in the direction of the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera).
*
* humanoid:Move(Vector3.new(0, 0, -1), true)
*
* When this function is called, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will move until the function is called again. However, if the default control scripts are being used this function will be overwritten when called on [Player](https://developer.roblox.com/en-us/api-reference/class/Player) [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character). This can be avoided by either not using the default control scripts, or calling this function every frame using [RunService:BindToRenderStep](https://developer.roblox.com/en-us/api-reference/function/RunService/BindToRenderStep) (see example).
*
* This function can be called on the server, but this should only be done when the server has [network ownership](https://developer.roblox.com/articles/Network-Ownership) of the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) assembly.
*
* See also
* --------
*
* * To make a[Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) walk to a point, use the [Humanoid:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Humanoid/MoveTo) function
* * For [Players](https://developer.roblox.com/en-us/api-reference/class/Player) the [Player:Move](https://developer.roblox.com/en-us/api-reference/function/Player/Move) function exists that calls this function
*/
Move(this: Humanoid, moveDirection: Vector3, relativeToCamera?: boolean): void;
/**
* This function causes the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to attempt to walk to the given location by setting the [Humanoid.WalkToPoint](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPoint) and [Humanoid.WalkToPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPart) properties.
*
* The _location_ and _part_ parameters correspond with what [Humanoid.WalkToPoint](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPoint) and [Humanoid.WalkToPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPart) will be set to.
*
* If the _part_ parameter is specified, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will still attempt to walk to the point. However, if the part moves then the point the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is walking to will move to be at the same position **relative to the part**. If the _part_ parameter is not specified, then the position the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is walking to will not change.
*
* The _reach goal_ state of a humanoid will timeout after 8 seconds if it doesn't reach its goal. This is done so that NPCs won't get stuck waiting for [Humanoid.MoveToFinished](https://developer.roblox.com/en-us/api-reference/event/Humanoid/MoveToFinished) to fire. If you don't want this to happen, you should repeatedly call MoveTo so that the timeout will keep resetting.
*/
MoveTo(this: Humanoid, location: Vector3, part?: BasePart): void;
/**
* This function removes all [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) worn by the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) parent. When this function is called, all [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) sharing an [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) with the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will be removed. For [Player](https://developer.roblox.com/en-us/api-reference/class/Player) [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character) this will remove all hats and other accessories.
*
* This function removes [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) by calling [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy) on them. This means the [Parents](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) of the accessories are set to _nil_ and locked.
*
* See also
* --------
*
* * To attach an [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) use the [Humanoid:AddAccessory](https://developer.roblox.com/en-us/api-reference/function/Humanoid/AddAccessory) function
* * To get all [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory) belonging to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) use the [Humanoid:GetAccessories](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetAccessories) function
*/
RemoveAccessories(this: Humanoid): void;
/**
* The RemoveCustomStatus function removes the defined custom status from the Status model in the Humanoid…
* @deprecated
*/
RemoveCustomStatus(this: Humanoid, status: string): boolean;
/**
* The RemoveStatus function removes the defined status from the Status model in the Humanoid.
* @deprecated
*/
RemoveStatus(this: Humanoid, status?: CastsToEnum): boolean;
/**
* ReplaceBodyPartR15 dynamically replaces a R15/Rthro limb part in a Humanoid with a different part. The part is automatically scaled as normal. In the image below, a R15 avatar has had their right hand replaced with a slightly larger version (also pictured).
*
* 
*
* This function is useful for modifying characters during gameplay or building characters from a base rig. The related function [GetBodyPartR15](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetBodyPartR15) can come in handy when using this function.
*/
ReplaceBodyPartR15(this: Humanoid, bodyPart: CastsToEnum, part: BasePart): boolean;
/**
* This function sets whether a given [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is enabled for the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* The humanoid state describes the activity the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently doing.
*
* When a particular [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is disabled, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) can never enter that state. This is true regardless if the attempt to change state is made using [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState) or Roblox internal [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) code.
*/
SetStateEnabled(this: Humanoid, state: CastsToEnum, enabled: boolean): void;
/**
* This function lowers the [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) by the given _amount_ if it is not protected by a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField)
*
* This function accepts negative values for the _amount_ parameter. This will increase the humanoid's [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health). However this will only have an effect if no [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) is present.
*
* How do ForceFields protect against TakeDamage
* ---------------------------------------------
*
* A [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is considered protected by a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) if a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) meets one of the following criteria:
*
* * The [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) shares the same [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) as the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)
* * The [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) is parented to the [Humanoid.RootPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart) of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)
* * The [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) is parented to an ancestor of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) other than the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace)
*
* To do damage to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) irrespective of any [ForceFields](https://developer.roblox.com/en-us/api-reference/class/ForceField) present, set [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) directly.
*
* For more information on how [ForceFields](https://developer.roblox.com/en-us/api-reference/class/ForceField) protect [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) see the [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) page
*/
TakeDamage(this: Humanoid, amount: number): void;
/**
* This function unequips any [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) currently equipped by the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)
*
* The unequipped [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) will be parented to the [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) of the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) associated with the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* If no [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) is equipped, this function will do nothing.
*
* Although [Tools](https://developer.roblox.com/en-us/api-reference/class/Tool) can be equipped by NPCs (Non Player Characters), this function only works on [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) with a corresponding [Player](https://developer.roblox.com/en-us/api-reference/class/Player). This is because a [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) object is required to parent the unequipped [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) to.
*
* See also
* --------
*
* * To instead equip a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool), use [Humanoid:EquipTool](https://developer.roblox.com/en-us/api-reference/function/Humanoid/EquipTool)
*/
UnequipTools(this: Humanoid): void;
/**
* This yield function makes the [character's](https://developer.roblox.com/en-us/api-reference/property/Player/Character) look match that of the passed in [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription). A copy of the passed look will then be cached in the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) as the current HumanoidDescription for the Humanoid.
*
* It allows you to quickly set and store a character's appearance using a stored look without having to set each property every time.
*
* See also
* --------
*
* * [Humanoid:GetAppliedDescription](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetAppliedDescription), returns the HumanoidDescription currently applied to the Humanoid
* * [Players:GetHumanoidDescriptionFromUserId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromUserId), gives back a HumanoidDescription which describes the Avatar for the passed in user
* * [Players:GetHumanoidDescriptionFromOutfitId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromOutfitId), gives back a HumanoidDescription whose parameters are initialized to match that of the passed in server-side outfit asset
* * [Player:LoadCharacterWithHumanoidDescription](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacterWithHumanoidDescription), spawns a player with the look from the HumanoidDescription Instance passed in
*
* Tags: Yields
*/
ApplyDescription(this: Humanoid, humanoidDescription: HumanoidDescription, assetTypeVerification?: CastsToEnum): void;
/**
* Tags: Yields
*/
ApplyDescriptionReset(this: Humanoid, humanoidDescription: HumanoidDescription, assetTypeVerification?: CastsToEnum): void;
/**
* If the emote could not be played because the emoteName is not found in the HumanoidDescription for the humanoid or the Humanoid is in the wrong HumanoidState for emotes then this API would return false to indicate that the emote was not played. The API would return true to indicate that the emote was played successfully.
*
* Tags: Yields
*/
PlayEmote(this: Humanoid, emoteName: string): boolean;
/**
* The AnimationPlayed event fires when an [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack) begins playing on the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* A common use for this function is to connect the [AnimationTrack.KeyframeReached](https://developer.roblox.com/en-us/api-reference/event/AnimationTrack/KeyframeReached) event for the playing AnimationTrack, so additional effects can be added to the animation (for example [Sounds](https://developer.roblox.com/en-us/api-reference/class/Sound) and [ParticleEmitters](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)).
*
* This event can be used for any [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) regardless if it belongs to the local player's client or not.
*
* See also
* --------
*
* * For the [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController) equivalent of this event, please see [AnimationController.AnimationPlayed](https://developer.roblox.com/en-us/api-reference/event/AnimationController/AnimationPlayed)
* @deprecated
*/
readonly AnimationPlayed: RBXScriptSignal<(animationTrack: AnimationTrack) => void>;
/**
* Fires when the speed at which a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is climbing changes.
*
* [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) can climb up ladders made out of [Parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [TrussParts](https://developer.roblox.com/en-us/api-reference/class/TrussPart).
*
* [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) climb at 70% of their [Humanoid.WalkSpeed](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkSpeed).
*
* This event will not always fire with a speed of 0 when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) stops climbing.
*
* See also
* --------
*
* * For swimming and running see the [Humanoid.Swimming](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Swimming) and [Humanoid.Running](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Running) events
* * You can also detect when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is climbing using the [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged) event
* * You can disable climbing using the [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled) function
*/
readonly Climbing: RBXScriptSignal<(speed: number) => void>;
/**
* The CustomStatusAdded event fires when a status is added to the Humanoid via the [Humanoid:AddCustomStatus](https://developer.roblox.com/en-us/api-reference/function/Humanoid/AddCustomStatus) method.
* @deprecated
*/
readonly CustomStatusAdded: RBXScriptSignal<(status: string) => void>;
/**
* The CustomStatusRemoved event fires when a status is removed from the Humanoid via the [Humanoid:RemoveCustomStatus](https://developer.roblox.com/en-us/api-reference/function/Humanoid/RemoveCustomStatus) method.
* @deprecated
*/
readonly CustomStatusRemoved: RBXScriptSignal<(status: string) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) dies, usually when [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) reaches 0. This could be caused either by disconnecting their head from their [Humanoid.Torso](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Torso), or directly setting the health property.
*
* This event only fires if the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace). If the _Dead_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is disabled it will not fire.
*/
readonly Died: RBXScriptSignal<() => void>;
/**
* The FallingDown event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters and leaves the _FallingDown_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* The [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will enter the _GettingUp_ state 3 seconds after the _FallingDown_ state is enabled. When this happens this event will fire with an _active_ value of _false_, and [Humanoid.GettingUp](https://developer.roblox.com/en-us/api-reference/event/Humanoid/GettingUp) will fire with an _active_ value of _true_.
*/
readonly FallingDown: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters or leaves the _Freefall_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* The _active_ parameter represents whether the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is entering or leaving the _Freefall_ state.
*
* Although the _Freefall_ state generally ends when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) reaches the ground, this event may fire with _active_ equal to _false_ if the state is changed while the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is falling. For this reason, you should use [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged) and listen for the _Landed_ state to work out when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) has landed.
*/
readonly FreeFalling: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters or leaves the _GettingUp_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* The _GettingUp_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) is a transition state that is activated shortly after the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters the _FallingDown_ (3 seconds) or _Ragdoll_ (1 second) [HumanoidStateTypes](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* When a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) attempts to get back up, this event will first fire with an _active_ parameter of _true_ before shortly after firing again with an _active_ parameter of _false_.
*
* See also
* --------
*
* * To force a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) to fall over, use the [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState) function to change the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) state to _FallingDown_
*/
readonly GettingUp: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) changes. However, it will not fire if the health is increasing from a value equal to or greater than the [Humanoid.MaxHealth](https://developer.roblox.com/en-us/api-reference/property/Humanoid/MaxHealth).
*
* When [Humanoid.Health](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Health) reaches zero, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will die and the [Humanoid.Died](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Died) event will fire. This event will fire with a value of zero.
*/
readonly HealthChanged: RBXScriptSignal<(health: number) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters and leaves the _Jumping_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* When a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) jumps this will fire with a _active_ parameter of _true_ before shortly afterwards firing again with an active parameter of _false_. This does not correspond with when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) has landed. For that, developers should listen for the _Landed_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) using [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged).
*
* The _active_ parameter of this event also corresponds with the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [Humanoid.Jump](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Jump) property.
*
* You can disable jumping using the [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled) function.
*/
readonly Jumping: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) finishes walking to a goal declared by the [Humanoid.WalkToPoint](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPoint) and [Humanoid.WalkToPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPart) properties.
*
* The [Humanoid.WalkToPoint](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPoint) and [Humanoid.WalkToPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkToPart) properties can be set individually, or using the [Humanoid:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Humanoid/MoveTo) function.
*
* If the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) reaches its goal within 8 seconds, this event will return with _reached_ as true. If the goal is not reached within 8 seconds the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will stop walking and _reached_ will be false. This timeout can be reset be calling [Humanoid:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Humanoid/MoveTo) again within the timeout period.
*/
readonly MoveToFinished: RBXScriptSignal<(reached: boolean) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters or leaves the _PlatformStanding_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* Whilst the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is in the _PlatformStanding_ state, the [Humanoid.PlatformStand](https://developer.roblox.com/en-us/api-reference/property/Humanoid/PlatformStand) property will be _true_.
*
* Whilst [Humanoid.PlatformStand](https://developer.roblox.com/en-us/api-reference/property/Humanoid/PlatformStand) is set to _true_, the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will be unable to move. For more information please see the page for [Humanoid.PlatformStand](https://developer.roblox.com/en-us/api-reference/property/Humanoid/PlatformStand).
*
* The PlatformStand [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) was associated with the now disabled [Platform](https://developer.roblox.com/en-us/api-reference/class/Platform) part. Despite this, it can still be used by developers.
*/
readonly PlatformStanding: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters or leaves the _Ragdoll_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
* The [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will enter the _GettingUp_ state 1 second after the _Ragdoll_ state is enabled. When this happens this event will fire with an _active_ value of _false_, and [Humanoid.GettingUp](https://developer.roblox.com/en-us/api-reference/event/Humanoid/GettingUp) will fire with an _active_ value of _true_.
*
* You can disable tripping by disabling the _Ragdoll_ and _FallingDown_ states using [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled).
*
* See also
* --------
*
* * [Humanoid.FallingDown](https://developer.roblox.com/en-us/api-reference/event/Humanoid/FallingDown) for the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) event connected with the _FallingDown_ state, which behaves similarly to _Ragdoll_
*/
readonly Ragdoll: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the speed at which a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is running changes.
*
* While running [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) cover, on average, their [Humanoid.WalkSpeed](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkSpeed) in studs per second.
*
* When the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) stops running this event will fire with a speed of 0.
*
* See also
* --------
*
* * For swimming and climbing see the [Humanoid.Swimming](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Swimming) and [Humanoid.Climbing](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Climbing) events
* * You can also detect when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is running using the [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged) event
*/
readonly Running: RBXScriptSignal<(speed: number) => void>;
/**
* This event fires when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) either sits in or gets up from a [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) or [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat).
*
* When a character comes into contact with a seat, they are attached to the seat and a sitting animation plays. For more information on this, see the [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) page.
*
* * If the character is sitting down, the `active` parameter will be **true** and `currentSeatPart` will be the seat they are currently sitting in.
* * If the character got up from a seat, the `active` parameter will be **false** and `currentSeatPart` will be nil.
*
* See also
* --------
*
* * [Humanoid.Sit](https://developer.roblox.com/en-us/api-reference/property/Humanoid/Sit), which indicates if a Humanoid is currently sitting
* * [Humanoid.SeatPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/SeatPart), which indicates the seat a Humanoid is currently sitting in, if any.
*/
readonly Seated: RBXScriptSignal<(active: boolean, currentSeatPart: Seat | VehicleSeat | undefined) => void>;
/**
* This event fires when the state of the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is changed.
*
* The humanoid state describes the activity the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is currently doing. It takes the form of a [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) value.
*
* See also:
* ---------
*
* * To get and set the state use [Humanoid:GetState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) and [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState)
* * Individual states can be disabled using [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled)
* * As there is no idle humanoid state, you should instead use the [Humanoid.Running](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Running) event or listen to the [RootPart's](https://developer.roblox.com/en-us/api-reference/property/Humanoid/RootPart) [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity) to work out when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is standing still
*/
readonly StateChanged: RBXScriptSignal<(oldValue: Enum.HumanoidStateType, newValue: Enum.HumanoidStateType) => void>;
/**
* The StateEnableChanged event fires when [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled) is called on the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* Parameters include the [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) in question along with a bool indicating if this state is now enabled.
*
* See also
* --------
*
* * To find if a state is currently enabled, use [Humanoid:GetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetStateEnabled)
* * To listen to [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) state changes use [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged)
*/
readonly StateEnabledChanged: RBXScriptSignal<(state: Enum.HumanoidStateType, isEnabled: boolean) => void>;
/**
* The StatusAdded event fires when a status is added to the Humanoid.
* @deprecated
*/
readonly StatusAdded: RBXScriptSignal<(status: Enum.Status) => void>;
/**
* The StatusRemoved event fires when a status is removed from the Humanoid.
* @deprecated
*/
readonly StatusRemoved: RBXScriptSignal<(status: Enum.Status) => void>;
/**
* This event does not fire when the \`Humanoid\` is strafing and should not be used by developers
*
* This event is fired when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters or leaves the _StrafingNoPhysics_ [HumanoidStateType](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* When the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) enters the _StrafingNoPhysics_ state this event will fire with an _active_ parameter of _true_. The event will fire again with _active_ equal to _false_ when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) leaves the _StrafingNoPhysics_ state.
*
* This event is associated with the _StrafingNoPhysics_ [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) state and does **not** fire when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is moving perpendicular to the direction it is facing. This state is currently unused, if it is set using [Humanoid:ChangeState](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ChangeState) the state will revert to _RunningNoPhysics_.
*/
readonly Strafing: RBXScriptSignal<(active: boolean) => void>;
/**
* This event fires when the speed at which a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is swimming in [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) water changes.
*
* [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid) swim at 87.5% of their [Humanoid.WalkSpeed](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkSpeed).
*
* This event will not always fire with a speed of 0 when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) stops swimming.
*
* See also
* --------
*
* * For running and climbing see the [Humanoid.Running](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Running) and [Humanoid.Climbing](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Climbing) events
* * You can also detect when a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is swimming using the [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged) event
* * You can disable swimming using the [Humanoid:SetStateEnabled](https://developer.roblox.com/en-us/api-reference/function/Humanoid/SetStateEnabled) function
*/
readonly Swimming: RBXScriptSignal<(speed: number) => void>;
/**
* This event fires when one of the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) limbs come in contact with another [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* The [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) the [Humanoid's](https://developer.roblox.com/en-us/api-reference/class/Humanoid) limb is touching along with the limb itself is given.
*
* This event will not fire when limbs belonging to the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) come into contact with themselves.
*
* Alternatives to the Humanoid Touched event
* ------------------------------------------
*
* Although the Humanoid.Touched event is useful, developers should consider if there are alternatives that suit their needs better before using it.
*
* * In most cases it is advised to connect a [BasePart.Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched) event for [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) of interest instead. This is because the Humanoid Touched event will constantly fire when the humanoid is moving. For example, in a dodgeball game it would be more practical to connect a touched event for the balls rather than the humanoid
* * For developers trying to work out when the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) has landed on the ground, the [Humanoid.StateChanged](https://developer.roblox.com/en-us/api-reference/event/Humanoid/StateChanged) event is more suitable. Alternatively, developers can use [Humanoid.FloorMaterial](https://developer.roblox.com/en-us/api-reference/property/Humanoid/FloorMaterial) to see if the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is standing on anything
*
* Notes
* -----
*
* * Connecting to this event will cause a [TouchTransmitter](https://developer.roblox.com/en-us/api-reference/class/TouchTransmitter) to be created in every limb
* * There is currently no equivalent of [BasePart.TouchEnded](https://developer.roblox.com/en-us/api-reference/event/BasePart/TouchEnded) for [Humanoids](https://developer.roblox.com/en-us/api-reference/class/Humanoid)
*/
readonly Touched: RBXScriptSignal<(touchingPart: BasePart, humanoidPart: BasePart) => void>;
}
/** **HumanoidDescription** is an object that stores a description a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) for R6 and R15 rigs. It can be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) in order to set a rig's scaling, clothing ([Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt), [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants), [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic)), [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory), [Animations](https://developer.roblox.com/en-us/api-reference/class/Animation) and [BodyColors](https://developer.roblox.com/en-us/api-reference/class/BodyColors).
*
* You can get a HumanoidDescription by using the following functions:
*
* * [Players:GetHumanoidDescriptionFromUserId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromUserId), for an outfit currently being worn by a user on [Roblox.com](http://Roblox.com)
*
* * [Players:GetHumanoidDescriptionFromOutfitId](https://developer.roblox.com/en-us/api-reference/function/Players/GetHumanoidDescriptionFromOutfitId), for an outfits created by a user on [Roblox.com](http://Roblox.com)
*
* * You can create a Humanoid rig model from a HumanoidDescription through [Players:CreateHumanoidModelFromDescription](https://developer.roblox.com/en-us/api-reference/function/Players/CreateHumanoidModelFromDescription).
*
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescription
*/
interface HumanoidDescription extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_HumanoidDescription: unique symbol;
/**
* **BackAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
BackAccessory: string;
/**
* 
*
* **BodyTypeScale** determines by which the shape of a Humanoid rig is interpolated from the standard R15 body shape (0) to a taller and more slender/realistic body type (1). Values outside of the \[0-1\] range are clamped. When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “BodyTypeScales” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* When the value of this property is 0, the [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale) property does not have any effect.
*
* In the image, three R15 figures whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following BodyTypeScales values (from left-to-right): 0, 0.5, 1.0. Also visible are 6 stacked 1x1x1 cube parts for reference.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale), which also affects rig proportions when this property is non-zero
* * [WidthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale), [HeightScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale) and [DepthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale), which provide finer control over the dimensions of a rig
* * [HeadScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadScale), which provides specific control over the scale of the rig's head
*/
BodyTypeScale: number;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **ClimbAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Climbing](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* See also
* --------
*
* * [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation), [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
ClimbAnimation: number;
/**
* 
*
* **DepthScale** determines by what factor the height (back-to-front distance) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is scaled, as well as all accessories not attached to its head. When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “BodyDepthScale” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* In the image, three R15 figures whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following DepthScale values (from left-to-right): 0.25, 1.0, 2.0.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale) and [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale), which can provide more realistic rig proportions
* * [WidthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale) and [HeightScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale)
*/
DepthScale: number;
/**
* **Face** determines the asset ID of the Face to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The type of the asset ID provided **must be for a Face** type asset and not a Decal or Image type asset.
*
* The actual face texture is rendered using a [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) in the Head named “face” or “Face”.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [GraphicTShirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/GraphicTShirt), [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt) and [Pants](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Pants), which also apply textures to a rig
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), which can change the mesh of the head
* * [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), which can apply one or more [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory)s to the face
*/
Face: number;
/**
* **FaceAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to the front of its face (such as glasses). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
* * [Face](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Face), a property that determines what Face texture is used on the head
*/
FaceAccessory: string;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **FallAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Freefall](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation), [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
FallAnimation: number;
/**
* **FrontAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to front of its torso (such as medals or ties). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
FrontAccessory: string;
/**
* 
*
* **GraphicTShirt** determines the [Graphic](https://developer.roblox.com/en-us/api-reference/property/ShirtGraphic/Graphic) used by a [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) when [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The asset type **must be for a T-Shirt** and not a Decal or Image.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt), which can provide the same functionality in addition to providing textures for the entire torso and arms
* * [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), which can change the color of the torso underneath the t-shirt texture
*/
GraphicTShirt: number;
/**
* **HairAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to its head resembling hair. The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in this property. An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
HairAccessory: string;
/**
* **HatAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to its head. The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
HatAccessory: string;
/**
* **Head** determines the asset ID of the Head to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm), [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg) and [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which are similar properties that also control body part
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), which controls the color of this limb
* * [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory) and [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), which all can apply [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory) objects which are joined to to the head
*/
Head: number;
/**
* **HeadColor** determines the [BodyColors.HeadColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/HeadColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which are similar properties that also control body colors
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), which controls the mesh used for the head
* * [Face](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Face), which applies a texture to the front of the head
*/
HeadColor: Color3;
/**
* 
*
* **HeadScale** determines by what factor the Head of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is scaled, as well as any accessories attached to it (such as those specified by [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory) and [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory)). When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “HeadScale” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* In the image, three R15 figures whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following HeadScale values (from left-to-right): 0.5, 1.0, 1.5.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale) and [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale), which can provide realistic rig proportions
* * [WidthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale), [HeightScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale) and [DepthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale), which provide finer control over other dimensions of a rig
*/
HeadScale: number;
/**
* 
*
* **HeightScale** determines by what factor the height (top-to-bottom distance) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is scaled, as well as all accessories not attached to its head. When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “BodyHeightScale” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* In the image, three R15 figures whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following HeightScale values (from left-to-right): 0.5, 1.0, 1.5.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale) and [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale), which can provide more realistic rig proportions
* * [WidthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale) and [DepthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale)
*/
HeightScale: number;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **IdleAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Running](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) at a speed near zero.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation), [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
IdleAnimation: number;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **JumpAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Jumping](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation), [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
JumpAnimation: number;
/**
* **LeftArm** determines the asset ID of the LeftArm to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg) and [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which are similar properties that also control body part
* * [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), which controls the color of this limb
*/
LeftArm: number;
/**
* **LeftArmColor** determines the [BodyColors.LeftArmColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/LeftArmColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). For R15 and Rthro rigs, this property controls both the upper and lower parts for this limb.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which are similar properties that also control body colors
* * [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm), which controls the mesh used for this limb
* * [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt), which can apply a texture to this limb
*/
LeftArmColor: Color3;
/**
* **LeftLeg** determines the asset ID of the LeftLeg to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm), and [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg), which are similar properties that also control body part
* * [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), which controls the color of this limb
*/
LeftLeg: number;
/**
* **LeftLegColor** determines the [BodyColors.LeftLegColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/LeftLegColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). For R15 and Rthro rigs, this property controls both the upper and lower parts for this limb.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which are similar properties that also control body colors
* * [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which controls the mesh used for this limb
* * [Pants](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Pants), which can apply a texture to this limb
*/
LeftLegColor: Color3;
MoodAnimation: number;
/**
* **NeckAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to its neck (such as scarves or necklaces). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
NeckAccessory: string;
/**
* 
*
* **Pants** determines the [PantsTemplate](https://developer.roblox.com/en-us/api-reference/property/Pants/PantsTemplate) used by a [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants) when [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The asset type **must be for a Pants** and not a Decal or Image.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt), a similar property which applies to a [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt) object
* * [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor) and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which can change the color of the body parts underneath the pants texture
*/
Pants: number;
/**
* 
*
* **ProportionScale** determines how wide (0) or narrow (1) a Humanoid rig. Values outside of the \[0-1\] range are clamped. When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “BodyProportionScale” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* When the value of [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale) is 0, this property does not have any effect.
*
* In the image, four R15 figures are visible whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following ProportionScale values (from left-to-right): 0, 0.5, 1.0, 0.0. Each have a BodyTypeScale of 1.0, except for the right which has 0.0. Also visible are 6 stacked 1x1x1 cube parts for reference. The table below lists the BodyTypeScale and ProportionScale values for each figure in the image.
*
* Value
*
* 1st
*
* 2nd
*
* 3rd
*
* Control
*
* BodyTypeScale
*
* 1.0
*
* 1.0
*
* 1.0
*
* 0.0
*
* ProportionScale
*
* 0.0
*
* 0.5
*
* 1.0
*
* 0.0
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale), which also affects rig proportions
* * [WidthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale), [HeightScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale) and [DepthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale), which provide finer control over the dimensions of a rig
* * [HeadScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadScale), which provides specific control over the scale of the rig's head
*/
ProportionScale: number;
/**
* **RightArm** determines the asset ID of the RightArm to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm), [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg) and [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which are similar properties that also control body part
* * [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), which controls the color of this limb
*/
RightArm: number;
/**
* **RightArmColor** determines the [BodyColors.RightArmColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/RightArmColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). For R15 and Rthro rigs, this property controls both the upper and lower parts for this limb.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which are similar properties that also control body colors
* * [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), which controls the mesh used for this limb
* * [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt), which can apply a texture to this limb
*/
RightArmColor: Color3;
/**
* **RightLeg** determines the asset ID of the RightLeg to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm) and [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which are similar properties that also control body part
* * [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which controls the color of this limb
*/
RightLeg: number;
/**
* **RightLegColor** determines the [BodyColors.RightLegColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/RightLegColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). For R15 and Rthro rigs, this property controls both the upper and lower parts for this limb.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), and [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), which are similar properties that also control body colors
* * [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg), which controls the mesh used for this limb
* * [Pants](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Pants), which can apply a texture to this limb
*/
RightLegColor: Color3;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **RunAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Running](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) at a moderate speed.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
RunAnimation: number;
/**
* 
*
* **Shirt** determines the [ShirtTemplate](https://developer.roblox.com/en-us/api-reference/property/Shirt/ShirtTemplate) used by a [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt) when [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid). The asset type **must be for a Shirt** and not a Decal or Image.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Pants](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Pants), a similar property which applies to a [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants) object
* * [GraphicTShirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/GraphicTShirt), a similar property which applies to a [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic) object
* * [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor) and [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), which can change the color of the body parts underneath the shirt texture
*/
Shirt: number;
/**
* **ShouldersAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to its shoulders (such as shoulder-mounted critters). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory) and [WaistAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WaistAccessory), which are similar properties that apply accessories like this one
*/
ShouldersAccessory: string;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **SwimAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Swimming](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType)
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation) and [WalkAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/WalkAnimation), which are similar properties that determine animations to play on the rig
*/
SwimAnimation: number;
/**
* **Torso** determines the asset ID of the Torso to be [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid).
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [Head](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Head), [RightArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArm), [LeftArm](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArm), [RightLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLeg) and [LeftLeg](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLeg), which are similar properties that also control body part
* * [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), which controls the color of this limb
*/
Torso: number;
/**
* **TorsoColor** determines the [BodyColors.TorsoColor3](https://developer.roblox.com/en-us/api-reference/property/BodyColors/TorsoColor3) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription). For R15 and Rthro rigs, this property controls both the upper and lower parts for this limb.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [HeadColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeadColor), [TorsoColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/TorsoColor), [LeftArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftArmColor), [RightArmColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightArmColor), [LeftLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/LeftLegColor), and [RightLegColor](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RightLegColor), which are similar properties that also control body colors
* * [Torso](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Torso), which controls the mesh used for this body part
* * [GraphicTShirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/GraphicTShirt) and [Shirt](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/Shirt), which can apply a texture to this body part
*/
TorsoColor: Color3;
/**
* **WaistAccessory** is a comma-separated list of asset IDs that determine what accessories should be added when the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription), usually those attached to its waist (such as belts). The list is kept sorted in descending order without duplicates.
*
* Any accessory can used in this property, even if it is meant to go in a different accessory spot. For example, an accessory meant to go on your back (such as a cape) could be included in [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory). An error is thrown if you try to apply a new description which shares any assets with the existing description but a different accessory property.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BackAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BackAccessory), [FaceAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FaceAccessory), [FrontAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FrontAccessory), [HairAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HairAccessory), [HatAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HatAccessory), [NeckAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/NeckAccessory) and [ShouldersAccessory](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ShouldersAccessory), which are similar properties that apply accessories like this one
*/
WaistAccessory: string;
/**
* When this description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), **WalkAnimation** determines the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) to play when its [state](https://developer.roblox.com/en-us/api-reference/function/Humanoid/GetState) is [Running](https://developer.roblox.com/en-us/api-reference/enum/HumanoidStateType) at a low speed
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [ClimbAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [FallAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/FallAnimation), [IdleAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/IdleAnimation), [JumpAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/JumpAnimation), [RunAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/RunAnimation) and [SwimAnimation](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/SwimAnimation), which are similar properties that determine animations to play on the rig
*/
WalkAnimation: number;
/**
* 
*
* **WidthScale** determines by what factor the width (left-to-right distance) of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) is scaled, as well as all accessories not attached to its head. When the description is [applied](https://developer.roblox.com/en-us/api-reference/function/Humanoid/ApplyDescription) to a Humanoid, this value maps to a “BodyWidthScale” [NumberValue](https://developer.roblox.com/en-us/api-reference/class/NumberValue) within the Humanoid.
*
* In the image above, three R15 figures whose [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s have [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription)s applied with the following WidthScale values (from left-to-right): 0.5, 1.0, 1.5.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [BodyTypeScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/BodyTypeScale) and [ProportionScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/ProportionScale), which can provide more realistic rig proportions
* * [HeightScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/HeightScale) and [DepthScale](https://developer.roblox.com/en-us/api-reference/property/HumanoidDescription/DepthScale)
*/
WidthScale: number;
/**
* **AddEmote** will add an Emote asset to the description given a name and its asset ID. The asset ID must be for an “Emote” asset (see [Featured emotes](https://www.roblox.com/catalog?Category=0&Subcategory=39) in the Catalog).
*
* You can add multiple emotes of the same name. All emotes of the same name can be removed using [RemoveEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote). If an emote with the same ID is added under the same name, [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged) fires.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [GetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote), which can be used to retrieve the emotes that have been added by this function
* * [SetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) and [RemoveEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote), which also manipulate what emotes have been added
* * [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged), which fires after this function is called
*/
AddEmote(this: HumanoidDescription, name: string, assetId: number): void;
/**
* Returns a table of an avatar's current accessories. If the second parameter (includeRigidAccessories) is true then the returned table will also include entries for rigid accessories from the rigid accessory properties.
*/
GetAccessories(this: HumanoidDescription, includeRigidAccessories: false): Array;
GetAccessories(this: HumanoidDescription, includeRigidAccessories: boolean): Array;
/**
* **GetEmotes** returns a dictionary of emotes that have been [added](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote) or [set](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) to this description. The keys of this dictionary are the names of the emotes, and the values are a non-empty array of emote IDs for that name.
*
* Example
* -------
*
* local hd = Instance.new("HumanoidDescription")
* hd:AddEmote("Salute", 3360689775)
* local emotes = hd:GetEmotes()
* for name, ids in pairs(emotes) do
* print(("The emote %s has %d ids:"):format(name, #ids))
* for \_, id in pairs(ids) do
* print(id)
* end
* end
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [SetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) and [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote), which can add emotes that may be returned by this function
* * [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged), which fires with the value returned this function after it may have changed
*/
GetEmotes(this: HumanoidDescription): EmoteDictionary;
/**
* **GetEquippedEmotes** returns an array of tables which indicate the `Name` and `Slot` of each equipped emote as it was set by [SetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEquippedEmotes).
*
* Example
* -------
*
* local hd = Instance.new("HumanoidDescription")
* hd:SetEmotes{Salute = {3360689775}, Agree = {4849487550}}
* hd:SetEquippedEmotes({"Salute", "Agree"})
* -- Iterate over the equipped emotes:
* for \_, t in pairs(hd:GetEquippedEmotes()) do
* print(("In slot %d: emote %s is equipped"):format(t.Slot, t.Name))
* end
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [SetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEquippedEmotes), which sets the currently equipped emotes and changes what this function returns
* * [EquippedEmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EquippedEmotesChanged), which fires when the function returned by this value may have changed
*/
GetEquippedEmotes(this: HumanoidDescription): EquippedEmotes;
/**
* **RemoveEmote** removes all emotes from the description that have been [added](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote) or [set](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) under the given name. If there are no added emotes with the given name, no error is thrown and [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged) **does not** fire.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [SetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) and [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote), which can add emotes that may be removed
* * [GetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEmotes), which can retrieve a dictionary of emotes that may be removed
*/
RemoveEmote(this: HumanoidDescription, name: string): void;
/**
* Accepts a table that sets the accessories and related properties for an avatar. If the second parameter (includeRigidAccessories) is true, then this function can also be used to set the rigid accessories in the rigid accessory properties. In this case any table entry that does not have an Order will be considered a rigid accessory and put in the appropriate property according to the AccessoryType.
*/
SetAccessories(this: HumanoidDescription, accessories: Array, includeRigidAccessories: boolean): void;
/**
* **SetEmotes** sets all of the emotes on this description given a table similar to that returned by [GetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEmotes). It fires [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged)
*
* Example
* -------
*
* local emotes = {
* Salute = {3360689775}, -- Syntax note: can also use \["Salute"\] = ...
* Agree = {4849487550},
* Disagree = {4849495710}
* }
* local hd = Instance.new("HumanoidDescription")
* hd:SetEmotes(emotes)
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote) and [RemoveEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote) which can modify the added emotes on an individual level
* * [EmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EmotesChanged), which fires when this function is called
*/
SetEmotes(this: HumanoidDescription, emotes: EmoteDictionary): void;
/**
* **SetEquippedEmotes** sets the currently equipped emotes given an array of emote names as they were passed to [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote) or [SetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes). It can also take an array of tables similar to that returned by [GetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEquippedEmotes). Calling this function fires [EquippedEmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EquippedEmotesChanged).
*
* Example
* -------
*
* local hd = Instance.new("HumanoidDescription")
* hd:SetEmotes{Salute = {3360689775}, Agree = {4849487550}}
* -- Can provide either an array of strings... (index is slot number)
* hd:SetEquippedEmotes({"Salute", "Agree"})
* -- ...or an array of tables as returned by GetEquippedEmotes (Slot and Name keys set)
* hd:SetEquippedEmotes({{Slot = 1, Name = "Salute"}, {Slot = 2, Name = "Agree"}})
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [GetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEquippedEmotes), which returns a value describing the equipped emotes set by this function
* * [EquippedEmotesChanged](https://developer.roblox.com/en-us/api-reference/event/HumanoidDescription/EquippedEmotesChanged), which fires when this function is called
*/
SetEquippedEmotes(this: HumanoidDescription, equippedEmotes: EquippedEmotes): void;
/**
* **EmotesChanged** fires when emotes are [added](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote), [removed](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote) or [set](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes) on the description. The event fires with the new emote table as returned by [GetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEmotes).
*
* If [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote) is called with the same name and ID as an existing emote, this event fires.
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [AddEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/AddEmote), [RemoveEmote](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/RemoveEmote) and [HumanoidDescription:SetEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEmotes), which can cause this event to be fired
*/
readonly EmotesChanged: RBXScriptSignal<(newEmotes: EmoteDictionary) => void>;
/**
* **EquippedEmotesChanged** fires when the equipped emotes are set on this description using [SetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEquippedEmotes). It provides the new equipped emotes in a table like that returned by [GetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEquippedEmotes).
*
* Example
* -------
*
* local hd = Instance.new("HumanoidDescription")
* hd.EquippedEmotesChanged:Connect(function (equippedEmotes)
* print(("We have %d emotes equipped"):format(#equippedEmotes))
* for \_, t in pairs(equippedEmotes) do
* print(("In slot %d: emote %s is equipped"):format(t.Slot, t.Name))
* end
* end)
* hd:SetEquippedEmotes({"Salute", "Agree"}) --> We have 2 emotes equipped
*
* See also
* --------
*
* * [HumanoidDescription System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), for more information on HumanoidDescriptions
* * [SetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/SetEquippedEmotes), which fires this event
* * [GetEquippedEmotes](https://developer.roblox.com/en-us/api-reference/function/HumanoidDescription/GetEquippedEmotes), which can be used to query the currently equipped emotes without this event firing
*/
readonly EquippedEmotesChanged: RBXScriptSignal<(newEquippedEmotes: EquippedEmotes) => void>;
}
interface IKControl extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_IKControl: unique symbol;
ChainRoot: Instance | undefined;
Enabled: boolean;
EndEffector: Instance | undefined;
EndEffectorOffset: CFrame;
Offset: CFrame;
Pole: Instance | undefined;
Priority: number;
SmoothTime: number;
Target: Instance | undefined;
Type: Enum.IKControlType;
Weight: number;
GetChainCount(this: IKControl): number;
GetChainLength(this: IKControl): number;
GetNodeLocalCFrame(this: IKControl, index: number): CFrame;
GetNodeWorldCFrame(this: IKControl, index: number): CFrame;
GetRawFinalTarget(this: IKControl): CFrame;
GetSmoothedFinalTarget(this: IKControl): CFrame;
}
interface ILegacyStudioBridge extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ILegacyStudioBridge: unique symbol;
}
interface LegacyStudioBridge extends ILegacyStudioBridge {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LegacyStudioBridge: unique symbol;
}
interface IXPService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_IXPService: unique symbol;
}
interface IncrementalPatchBuilder extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_IncrementalPatchBuilder: unique symbol;
AddPathsToBundle: boolean;
BuildDebouncePeriod: number;
HighCompression: boolean;
SerializePatch: boolean;
ZstdCompression: boolean;
}
/** An **InputObject** represents a single user input, such as mouse movement, touches, key presses and more. It is created when an input begins.
*
* The properties of this object vary according the [UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType). Each kind of input will undergo various changes to its [UserInputState](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputState). During the lifetime of an input, other properties which further describe the input may change, such as [Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position) and [Delta](https://developer.roblox.com/en-us/api-reference/property/InputObject/Delta). Keyboard and gamepad button presses will have the [KeyCode](https://developer.roblox.com/en-us/api-reference/property/InputObject/KeyCode) property set.
*
* Once created at the beginning of an input, the same object persists and is updated until the input ends. As a result, you can track the object's changes using the [Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) event as the user changes the input in question. You can also place these objects into a list of active inputs track and interact with the object after it's creation by an event such as [UserInputService.InputBegan](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputBegan). This is mostly useful for touch events, as each touch point will have a separate InputObject.
*
* See also
* ========
*
* * [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService), which passes an InputObject to [bound](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) action-handling functions
* * [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService), whose events and functions often use InputObject
* * [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject), whose events related to user input use InputObject
*/
interface InputObject extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InputObject: unique symbol;
/**
* A `Vector3` describing the Delta (change) between mouse/joystick movements.
*
* This is useful when used with the input's [position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position) to track the position and movement of the user's mouse/joystick, such as when you're creating custom movement or camera scripts. Consider tracking input object changes using the [Instance.Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) event or when user input changes via events such as [UserInputService.InputChanged](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputChanged) and [GuiObject.InputChanged](https://developer.roblox.com/en-us/api-reference/event/GuiObject/InputChanged).
*
* See also
* --------
*
* * [InputObject.KeyCode](https://developer.roblox.com/en-us/api-reference/property/InputObject/KeyCode)
* * [InputObject.Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position)
* * [InputObject.UserInputState](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputState)
* * [InputObject.UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType)
*/
Delta: Vector3;
/**
* Contains a [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode) enum that describes what kind of input was used. For types of input like keyboard, this describes what key was pressed. For inputs like the mouse, this provides no additional information.
*
* ### Enums
*
* Name
*
* Value
*
* Description
*
* ### Unknown
*
* 0
*
*
*
* ### Backspace
*
* 8
*
*
*
* ### Tab
*
* 9
*
*
*
* ### Clear
*
* 12
*
*
*
* ### Return
*
* 13
*
*
*
* ### Pause
*
* 19
*
*
*
* ### Escape
*
* 27
*
*
*
* ### Space
*
* 32
*
*
*
* ### QuotedDouble
*
* 34
*
*
*
* ### Hash
*
* 35
*
*
*
* ### Dollar
*
* 36
*
*
*
* ### Percent
*
* 37
*
*
*
* ### Ampersand
*
* 38
*
*
*
* ### Quote
*
* 39
*
*
*
* ### LeftParenthesis
*
* 40
*
*
*
* ### RightParenthesis
*
* 41
*
*
*
* ### Asterisk
*
* 42
*
*
*
* ### Plus
*
* 43
*
*
*
* ### Comma
*
* 44
*
*
*
* ### Minus
*
* 45
*
*
*
* ### Period
*
* 46
*
*
*
* ### Slash
*
* 47
*
*
*
* ### Zero
*
* 48
*
*
*
* ### One
*
* 49
*
*
*
* ### Two
*
* 50
*
*
*
* ### Three
*
* 51
*
*
*
* ### Four
*
* 52
*
*
*
* ### Five
*
* 53
*
*
*
* ### Six
*
* 54
*
*
*
* ### Seven
*
* 55
*
*
*
* ### Eight
*
* 56
*
*
*
* ### Nine
*
* 57
*
*
*
* ### Colon
*
* 58
*
*
*
* ### Semicolon
*
* 59
*
*
*
* ### LessThan
*
* 60
*
*
*
* ### Equals
*
* 61
*
*
*
* ### GreaterThan
*
* 62
*
*
*
* ### Question
*
* 63
*
*
*
* ### At
*
* 64
*
*
*
* ### LeftBracket
*
* 91
*
*
*
* ### BackSlash
*
* 92
*
*
*
* ### RightBracket
*
* 93
*
*
*
* ### Caret
*
* 94
*
*
*
* ### Underscore
*
* 95
*
*
*
* ### Backquote
*
* 96
*
*
*
* ### A
*
* 97
*
*
*
* ### B
*
* 98
*
*
*
* ### C
*
* 99
*
*
*
* ### D
*
* 100
*
*
*
* ### E
*
* 101
*
*
*
* ### F
*
* 102
*
*
*
* ### G
*
* 103
*
*
*
* ### H
*
* 104
*
*
*
* ### I
*
* 105
*
*
*
* ### J
*
* 106
*
*
*
* ### K
*
* 107
*
*
*
* ### L
*
* 108
*
*
*
* ### M
*
* 109
*
*
*
* ### N
*
* 110
*
*
*
* ### O
*
* 111
*
*
*
* ### P
*
* 112
*
*
*
* ### Q
*
* 113
*
*
*
* ### R
*
* 114
*
*
*
* ### S
*
* 115
*
*
*
* ### T
*
* 116
*
*
*
* ### U
*
* 117
*
*
*
* ### V
*
* 118
*
*
*
* ### W
*
* 119
*
*
*
* ### X
*
* 120
*
*
*
* ### Y
*
* 121
*
*
*
* ### Z
*
* 122
*
*
*
* ### LeftCurly
*
* 123
*
*
*
* ### Pipe
*
* 124
*
*
*
* ### RightCurly
*
* 125
*
*
*
* ### Tilde
*
* 126
*
*
*
* ### Delete
*
* 127
*
*
*
* ### KeypadZero
*
* 256
*
*
*
* ### KeypadOne
*
* 257
*
*
*
* ### KeypadTwo
*
* 258
*
*
*
* ### KeypadThree
*
* 259
*
*
*
* ### KeypadFour
*
* 260
*
*
*
* ### KeypadFive
*
* 261
*
*
*
* ### KeypadSix
*
* 262
*
*
*
* ### KeypadSeven
*
* 263
*
*
*
* ### KeypadEight
*
* 264
*
*
*
* ### KeypadNine
*
* 265
*
*
*
* ### KeypadPeriod
*
* 266
*
*
*
* ### KeypadDivide
*
* 267
*
*
*
* ### KeypadMultiply
*
* 268
*
*
*
* ### KeypadMinus
*
* 269
*
*
*
* ### KeypadPlus
*
* 270
*
*
*
* ### KeypadEnter
*
* 271
*
*
*
* ### KeypadEquals
*
* 272
*
*
*
* ### Up
*
* 273
*
*
*
* ### Down
*
* 274
*
*
*
* ### Right
*
* 275
*
*
*
* ### Left
*
* 276
*
*
*
* ### Insert
*
* 277
*
*
*
* ### Home
*
* 278
*
*
*
* ### End
*
* 279
*
*
*
* ### PageUp
*
* 280
*
*
*
* ### PageDown
*
* 281
*
*
*
* ### LeftShift
*
* 304
*
*
*
* ### RightShift
*
* 303
*
*
*
* ### LeftMeta
*
* 310
*
*
*
* ### RightMeta
*
* 309
*
*
*
* ### LeftAlt
*
* 308
*
*
*
* ### RightAlt
*
* 307
*
*
*
* ### LeftControl
*
* 306
*
*
*
* ### RightControl
*
* 305
*
*
*
* ### CapsLock
*
* 301
*
*
*
* ### NumLock
*
* 300
*
*
*
* ### ScrollLock
*
* 302
*
*
*
* ### LeftSuper
*
* 311
*
*
*
* ### RightSuper
*
* 312
*
*
*
* ### Mode
*
* 313
*
*
*
* ### Compose
*
* 314
*
*
*
* ### Help
*
* 315
*
*
*
* ### Print
*
* 316
*
*
*
* ### SysReq
*
* 317
*
*
*
* ### Break
*
* 318
*
*
*
* ### Menu
*
* 319
*
*
*
* ### Power
*
* 320
*
*
*
* ### Euro
*
* 321
*
*
*
* ### Undo
*
* 322
*
*
*
* ### F1
*
* 282
*
*
*
* ### F2
*
* 283
*
*
*
* ### F3
*
* 284
*
*
*
* ### F4
*
* 285
*
*
*
* ### F5
*
* 286
*
*
*
* ### F6
*
* 287
*
*
*
* ### F7
*
* 288
*
*
*
* ### F8
*
* 289
*
*
*
* ### F9
*
* 290
*
*
*
* ### F10
*
* 291
*
*
*
* ### F11
*
* 292
*
*
*
* ### F12
*
* 293
*
*
*
* ### F13
*
* 294
*
*
*
* ### F14
*
* 295
*
*
*
* ### F15
*
* 296
*
*
*
* ### World0
*
* 160
*
*
*
* ### World1
*
* 161
*
*
*
* ### World2
*
* 162
*
*
*
* ### World3
*
* 163
*
*
*
* ### World4
*
* 164
*
*
*
* ### World5
*
* 165
*
*
*
* ### World6
*
* 166
*
*
*
* ### World7
*
* 167
*
*
*
* ### World8
*
* 168
*
*
*
* ### World9
*
* 169
*
*
*
* ### World10
*
* 170
*
*
*
* ### World11
*
* 171
*
*
*
* ### World12
*
* 172
*
*
*
* ### World13
*
* 173
*
*
*
* ### World14
*
* 174
*
*
*
* ### World15
*
* 175
*
*
*
* ### World16
*
* 176
*
*
*
* ### World17
*
* 177
*
*
*
* ### World18
*
* 178
*
*
*
* ### World19
*
* 179
*
*
*
* ### World20
*
* 180
*
*
*
* ### World21
*
* 181
*
*
*
* ### World22
*
* 182
*
*
*
* ### World23
*
* 183
*
*
*
* ### World24
*
* 184
*
*
*
* ### World25
*
* 185
*
*
*
* ### World26
*
* 186
*
*
*
* ### World27
*
* 187
*
*
*
* ### World28
*
* 188
*
*
*
* ### World29
*
* 189
*
*
*
* ### World30
*
* 190
*
*
*
* ### World31
*
* 191
*
*
*
* ### World32
*
* 192
*
*
*
* ### World33
*
* 193
*
*
*
* ### World34
*
* 194
*
*
*
* ### World35
*
* 195
*
*
*
* ### World36
*
* 196
*
*
*
* ### World37
*
* 197
*
*
*
* ### World38
*
* 198
*
*
*
* ### World39
*
* 199
*
*
*
* ### World40
*
* 200
*
*
*
* ### World41
*
* 201
*
*
*
* ### World42
*
* 202
*
*
*
* ### World43
*
* 203
*
*
*
* ### World44
*
* 204
*
*
*
* ### World45
*
* 205
*
*
*
* ### World46
*
* 206
*
*
*
* ### World47
*
* 207
*
*
*
* ### World48
*
* 208
*
*
*
* ### World49
*
* 209
*
*
*
* ### World50
*
* 210
*
*
*
* ### World51
*
* 211
*
*
*
* ### World52
*
* 212
*
*
*
* ### World53
*
* 213
*
*
*
* ### World54
*
* 214
*
*
*
* ### World55
*
* 215
*
*
*
* ### World56
*
* 216
*
*
*
* ### World57
*
* 217
*
*
*
* ### World58
*
* 218
*
*
*
* ### World59
*
* 219
*
*
*
* ### World60
*
* 220
*
*
*
* ### World61
*
* 221
*
*
*
* ### World62
*
* 222
*
*
*
* ### World63
*
* 223
*
*
*
* ### World64
*
* 224
*
*
*
* ### World65
*
* 225
*
*
*
* ### World66
*
* 226
*
*
*
* ### World67
*
* 227
*
*
*
* ### World68
*
* 228
*
*
*
* ### World69
*
* 229
*
*
*
* ### World70
*
* 230
*
*
*
* ### World71
*
* 231
*
*
*
* ### World72
*
* 232
*
*
*
* ### World73
*
* 233
*
*
*
* ### World74
*
* 234
*
*
*
* ### World75
*
* 235
*
*
*
* ### World76
*
* 236
*
*
*
* ### World77
*
* 237
*
*
*
* ### World78
*
* 238
*
*
*
* ### World79
*
* 239
*
*
*
* ### World80
*
* 240
*
*
*
* ### World81
*
* 241
*
*
*
* ### World82
*
* 242
*
*
*
* ### World83
*
* 243
*
*
*
* ### World84
*
* 244
*
*
*
* ### World85
*
* 245
*
*
*
* ### World86
*
* 246
*
*
*
* ### World87
*
* 247
*
*
*
* ### World88
*
* 248
*
*
*
* ### World89
*
* 249
*
*
*
* ### World90
*
* 250
*
*
*
* ### World91
*
* 251
*
*
*
* ### World92
*
* 252
*
*
*
* ### World93
*
* 253
*
*
*
* ### World94
*
* 254
*
*
*
* ### World95
*
* 255
*
*
*
* ### ButtonX
*
* 1000
*
*
*
* ### ButtonY
*
* 1001
*
*
*
* ### ButtonA
*
* 1002
*
*
*
* ### ButtonB
*
* 1003
*
*
*
* ### ButtonR1
*
* 1004
*
*
*
* ### ButtonL1
*
* 1005
*
*
*
* ### ButtonR2
*
* 1006
*
*
*
* ### ButtonL2
*
* 1007
*
*
*
* ### ButtonR3
*
* 1008
*
*
*
* ### ButtonL3
*
* 1009
*
*
*
* ### ButtonStart
*
* 1010
*
*
*
* ### ButtonSelect
*
* 1011
*
*
*
* ### DPadLeft
*
* 1012
*
*
*
* ### DPadRight
*
* 1013
*
*
*
* ### DPadUp
*
* 1014
*
*
*
* ### DPadDown
*
* 1015
*
*
*
* ### Thumbstick1
*
* 1016
*
*
*
* ### Thumbstick2
*
* 1017
*
* ### See also
*
* * [InputObject.Delta](https://developer.roblox.com/en-us/api-reference/property/InputObject/Delta)
* * [InputObject.Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position)
* * [InputObject.UserInputState](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputState)
* * [InputObject.UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType)
*/
KeyCode: Enum.KeyCode;
/**
* This property describes a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) positional value of this input.
*
* For mouse and touch input, this is the screen position of the mouse/touch, described in the x and y components.
*
* For the mouse wheel input, the z component describes whether the wheel was moved forward (1), backwards (-1), or not at all (0).
*
* For [KeyCode](https://developer.roblox.com/en-us/api-reference/enum/KeyCode) input, this indicate's the position of the player's [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse).
*
* #See also
*
* * [InputObject.Delta](https://developer.roblox.com/en-us/api-reference/property/InputObject/Delta)
* * [InputObject.KeyCode](https://developer.roblox.com/en-us/api-reference/property/InputObject/KeyCode)
* * [InputObject.UserInputState](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputState)
* * [InputObject.UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType)
*/
Position: Vector3;
/**
* **UserInputState** describes the state of an input being performed, following a specific flow depending on the [UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType). It uses the enum of the same name, [UserInputState](https://developer.roblox.com/en-us/api-reference/enum/UserInputState). See the enum page for a list of all possible values for this property.
*
* See also
* --------
*
* * [InputObject.Delta](https://developer.roblox.com/en-us/api-reference/property/InputObject/Delta)
* * [InputObject.KeyCode](https://developer.roblox.com/en-us/api-reference/property/InputObject/KeyCode)
* * [InputObject.Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position)
* * [InputObject.UserInputType](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputType)
*/
UserInputState: Enum.UserInputState;
/**
* **UserInputType** is a property that describes for what kind of input this [InputObject](https://developer.roblox.com/en-us/api-reference/class/InputObject) represents, such as mouse, keyboard, touch or gamepad input. It uses the enum of the same name, [UserInputType](https://developer.roblox.com/en-us/api-reference/enum/UserInputType). See the enum page for a list of all possible values for this property.
*
* See also
* --------
*
* * [InputObject.Delta](https://developer.roblox.com/en-us/api-reference/property/InputObject/Delta)
* * [InputObject.KeyCode](https://developer.roblox.com/en-us/api-reference/property/InputObject/KeyCode)
* * [InputObject.Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position)
* * [InputObject.UserInputState](https://developer.roblox.com/en-us/api-reference/property/InputObject/UserInputState)
*/
UserInputType: Enum.UserInputType;
IsModifierKeyDown(this: InputObject, modifierKey: CastsToEnum): boolean;
}
/** InsertService is used to insert assets from the Roblox website, typically the [LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) function.
*
* To load an asset, the asset must be accessible by the creator of the game loading it, which can be either a user or group. Due to these restrictions, InsertService is useful for loading sensitive data, typically API or secret keys to be used with [HttpService](https://developer.roblox.com/en-us/api-reference/class/HttpService). Should a game be uploaded by a different creator, the sensitive data would not be accessible. See the [LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) function for more details on this security check.
*
* See Also
* --------
*
* * [AssetService](https://developer.roblox.com/en-us/api-reference/class/AssetService), which can provide information about assets you might want to load using InsertService
*/
interface InsertService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InsertService: unique symbol;
/**
* The AllowInsertFreeModels property toggles whether ''Free Models'' can be inserted into the game, regardless of whether the place owner owns the asset.
*
* Tags: NotReplicated, NotBrowsable
* @deprecated
*/
AllowInsertFreeModels: boolean;
/**
* @deprecated
*/
ApproveAssetId(this: InsertService, assetId: number): void;
/**
* @deprecated
*/
ApproveAssetVersionId(this: InsertService, assetVersionId: number): void;
/**
* The Insert function is an ancient method used to insert an [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) into Workspace.
* @deprecated
*/
Insert(this: InsertService, instance: Instance): void;
/**
* Tags: Yields
* @deprecated Use `GetBaseSets` instead
*/
GetBaseCategories(this: InsertService): unknown;
/**
* Returns an array of dictionaries, containing information about various Roblox approved sets.
*
* Tags: Yields
* @deprecated
*/
GetBaseSets(this: InsertService): Array;
/**
* Returns the most recently uploaded models in the specified category.
*
* Tags: Yields
*/
GetCollection(this: InsertService, categoryId: number): Array;
/**
* The GetFreeDecals function retrieves a list of Free [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s from the Catalog. The return type for this method is very odd, as it returns a single table wrapped in a table.
*
* The best way to explain it is to show a visual of the array returned:
*
* \[1\] = {
* CurrentStartIndex = 1, -- This can vary depending on the page you input.
* TotalCount = 21, -- Always 21.
* Results = {
* -- All parameters here are psuedo. They can vary depending on the asset.
* \[1\] = {
* Name = "Asset Name",
* AssetId = 0000000,
* AssetVersionId = 0000000,
* CreatorName = "Roblox",
* },
* -- \[2\], \[3\], and so on... up to \[21\]
* },
* }
*
* Yikes! That quite confusing. Unfortunately this method was added in the earlier days of Roblox, where easy to understand return-types weren't a priority.
*
* Thankfully, an example for iterating over this list has been provided at the bottom of this page.
*
* Additionally, if you want to insert [Models](https://developer.roblox.com/en-us/api-reference/class/Model) instead, you can use the [InsertService:GetFreeModels](https://developer.roblox.com/en-us/api-reference/function/InsertService/GetFreeModels) function.
*
* _Note:_ The page argument starts at 0. So Page 1 = 0, Page 2 = 1, etc.
*
* Tags: Yields
*/
GetFreeDecals(this: InsertService, searchText: string, pageNum: number): [Array];
/**
* The GetFreeModels function retrieves a list of Free [Models](https://developer.roblox.com/en-us/api-reference/class/Model) from the Catalog. The return type for this method is very odd, as it returns a single table wrapped in a table.
*
* The best way to explain it is to show a visual of the array returned:
*
* \[1\] = {
* CurrentStartIndex = 1, -- This can vary depending on the page you input.
* TotalCount = 21, -- Always 21.
* Results = {
* -- All parameters here are psuedo. They can vary depending on the asset.
* \[1\] = {
* Name = "Asset Name",
* AssetId = 0000000,
* AssetVersionId = 0000000,
* CreatorName = "Roblox",
* }
* -- \[2\], \[3\], and so on... up to \[21\]
* }
* }
*
* An example for iterating over this list has been provided at the bottom of this page.
*
* Additionally, if you would like to insert free \`Decal|Decals\`, you can use the \`InsertService/GetFreeDecals\` function.
*
* Tags: Yields
*/
GetFreeModels(this: InsertService, searchText: string, pageNum: number): [Array];
/**
* Returns the latest AssetVersionId of an asset for assets created by the place creator.
*
* Can be used in combination with [LoadAssetVersion](https://developer.roblox.com/api-reference/function/InsertService/LoadAssetVersion "LoadAssetVersion") to load the latest version of a model, even if it gets updated while the game is running.
*
* Tags: Yields
*/
GetLatestAssetVersionAsync(this: InsertService, assetId: number): number;
/**
* Tags: Yields
* @deprecated Use `GetUserSets` instead
*/
GetUserCategories(this: InsertService, userId: number): unknown;
/**
* Returns an array of dictionaries, containing information about sets owned by the user.
*
* This includes
*
* * Sets the user is subscribed to.
* * Sets that the user created.
* * A single set containing the models created by the user.
* * A single set containing the decals created by the user.
*
* Notes
* -----
*
* * All values in the dictionaries are [strings](https://developer.roblox.com/articles/String "Strings"), even if they are a number.
*
*
*
* **Dictionary Contents**
*
* Name
*
* Description
*
* Name
*
* The name of the set.
*
* Description
*
* The description of the set.
*
* ImageAssetId
*
* An assetId for the icon of the set.
*
* CreatorName
*
* The creator of the set.
*
* AssetSetId
*
* The set's unique ID on the website.
*
* CategoryId
*
* Identical to AssetSetId
*
* SetType
*
* The type of set that this set is.
*
* Tags: Yields
*/
GetUserSets(this: InsertService, userId: number): Array;
/**
* The LoadAsset function fetches an asset given its ID and returns a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) containing the asset. For example, to load this public [Doge](https://www.roblox.com/library/257489726/Doge) [Model](https://developer.roblox.com/en-us/api-reference/class/Model), which has the asset Id _**257489726**_, you can use:
*
* local assetId = 257489726
* local InsertService = game:GetService("InsertService")
* local model = InsertService:LoadAsset(assetId)
* model.Parent = workspace
*
* Calls to this function may fail if a server providing a model is having problems. As such, it's generally a good idea to wrap calls to this function in `pcall` to catch these kinds of errors.
*
* local assetId = 257489726
* local InsertService = game:GetService("InsertService")
* local success, model = pcall(InsertService.LoadAsset, InsertService, assetId)
* if success and model then
* print("Model loaded successfully")
* model.Parent = workspace
* else
* print("Model failed to load!")
* end
*
* Security Check
* --------------
*
* An asset loaded by this function must be **created or owned** by either the game creator or Roblox. Additionally, benign asset types such as t-shirts, shirts, pants and avatar accessories are loadable from any game as they are public.
*
* See also
* --------
*
* * [AssetService:GetBundleDetailsAsync](https://developer.roblox.com/en-us/api-reference/function/AssetService/GetBundleDetailsAsync), to find out which assets are associated with a bundle.
* * For plugins, see [DataModel:GetObjects](https://developer.roblox.com/en-us/api-reference/function/DataModel/GetObjects)
*
* Tags: Yields
*/
LoadAsset(this: InsertService, assetId: number): Model;
/**
* Returns a model inserted into [InsertService](https://developer.roblox.com/en-us/api-reference/class/InsertService) containing the asset with the given assetVersionId.
*
* Tags: Yields
*/
LoadAssetVersion(this: InsertService, assetVersionId: number): Model;
/**
* Tags: Hidden
*/
readonly InternalDelete: RBXScriptSignal<(instance: Instance) => void>;
}
interface InternalSyncItem extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InternalSyncItem: unique symbol;
}
interface InternalSyncService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InternalSyncService: unique symbol;
}
/** JointInstance is the base class for joints, such as Connectors, Welds, and Snaps.
*
* [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld), [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap), [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint), [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), and [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) joints all combine multiple parts into the same Assembly. An assembly is a rigid body if none of its parts are anchored. No physical forces can ever separate the parts of an Assembly or move them relative to each other unless the joints are removed or updated. They're a single body.
*
* Every Assembly has a root part, see [BasePart:GetRootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart). When a JointInstance's [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) is modified the root part will stay where it was.
*
* Welds do not have any directionality. [Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) or [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1), doesn't matter. You can imagine rigid joints forming a tree branching down from the root part. All the parts down the tree from root will move, and their welded “children” in this tree will move with them.
*
* A typical Roblox avatar is a single assembly. Here's a visualization of this tree in a basic R15 humanoid rig on the left, and a representation of this implicit tree of which parts move relative to which parts on the right.
*
* 
*/
interface JointInstance extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_JointInstance: unique symbol;
/**
* This property determines if the joint is currently active in the world. If true, the joint is active.
*
* If the [JointInstance](https://developer.roblox.com/en-us/api-reference/class/JointInstance) is not in [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) or [JointsService](https://developer.roblox.com/en-us/api-reference/class/JointsService), or one of its parts is not in Workspace the joint will be inactive.
*
* Rigid joints like [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld), [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap), [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint), [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), or [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) may also be disabled due to conflicts with other rigid joints, such as joints between the same two parts or indirect cycles in the weld graph. Joints disabled this way may be re-enabled later when another joint or part is added or removed.
*
* Tags: NotReplicated
*/
readonly Active: boolean;
/**
* C0 is the position aspect of the orientation between two parts in a weld. [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) and [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) move accordingly to this value, which denotes their respective positions.
*/
C0: CFrame;
/**
* Is subtracted from the [JointInstance.C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) property to create an offset point for [JointInstance.Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1).
*/
C1: CFrame;
/**
* This property sets whether the joint is active or not.
*
* When this property is set to true, if the joints's [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) and [JointInstance.Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1) properties are set, then the joint will ensure that its two parts will be connected and behave according to joint type (e.g. [Welds](https://developer.roblox.com/en-us/api-reference/class/Weld), and [Snaps](https://developer.roblox.com/en-us/api-reference/class/Snap)).
*
* See also
* --------
*
* * [JointInstance.Active](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Active), determines if the joint is currently active in the world
*/
Enabled: boolean;
/**
* The first [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that the joint connects.
*/
Part0?: BasePart;
/**
* The second [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that the joint connects.
*/
Part1?: BasePart;
}
/** The base class for classic motor joints. */
interface DynamicRotate extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DynamicRotate: unique symbol;
/**
* The base angle of the DynamicRotate object, in radians.
*/
BaseAngle: number;
}
/** A RotateP object joins two parts together and allows rotation about a set axis. The joint will attempt to rotate the two parts until a desired rotational position is reached. This object is most commonly created by the SteppingMotor [SurfaceType](https://developer.roblox.com/en-us/api-reference/enum/SurfaceType). If created through a script, a RotateP's behavoir is still governed by the SurfaceInput of [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0).
*
* The three inputs of note are as follows:
*
*
* * NoInput: The joint will not rotate under its own power. It can still be rotated by external forces (such as from a character pushing one of the parts).
*
* * Constant: The joint will rotate based on the ParamB property of \`JointInstance/Part0\`. This rotation is measured in radians per physics frame (which is approximately 1/60th of a second).
* * Sin: The joint will rotate based on the ParamA and ParamB properties of \`JointInstance/Part0\`. The rotation measured in radians per physics frame is calculated by the function: RotationRate = ParamA \* sin(distributedGameTime \* ParamB). distributedGameTime is the current time of the game measured in seconds.
*/
interface RotateP extends DynamicRotate {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RotateP: unique symbol;
}
/** A RotateV object joins two parts together and allows rotation about a set axis. This object is most commonly created by the Motor [SurfaceType](https://developer.roblox.com/en-us/api-reference/enum/SurfaceType). If created through a script, a RotateV's behavior is still governed by the SurfaceInput of [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0).
*
* The three inputs of note are as follows:
*
*
* * NoInput: The joint will not rotate under its own power. It can still be rotated by external forces (such as from a character pushing one of the parts).
*
* * Constant: The joint will rotate based on the ParamB property of \`JointInstance/Part0\`. This rotation is measured in radians per physics frame (which is approximately 1/60th of a second).
* * Sin: The joint will rotate based on the ParamA and ParamB properties of \`JointInstance/Part0\`. The rotation measured in radians per physics frame is calculated by the function: RotationRate = ParamA \* sin(distributedGameTime \* ParamB). distributedGameTime is the current time of the game measured in seconds.
*/
interface RotateV extends DynamicRotate {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RotateV: unique symbol;
}
/** Glue is a type of joint that can break when enough force is applied. */
interface Glue extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Glue: unique symbol;
/**
* F0 helps determining the Glue face of a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue), which determines the amount of force needed to break the joint.
*/
F0: Vector3;
/**
* F1 helps determining the Glue face of a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue), which determines the amount of force needed to break the joint.
*/
F1: Vector3;
/**
* F2 helps determining the Glue face of a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue), which determines the amount of force needed to break the joint.
*/
F2: Vector3;
/**
* F3 helps determining the Glue face of a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue), which determines the amount of force needed to break the joint.
*/
F3: Vector3;
}
/** The ManualSurfaceJointInstance is the base class for [ManualGlue](https://developer.roblox.com/en-us/api-reference/class/ManualGlue). This instance (when created) also used to cause the server to crash, however this behaviour has since been fixed. */
interface ManualSurfaceJointInstance extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ManualSurfaceJointInstance: unique symbol;
}
/** **ManualGlue** is a joint created in a similar manner to the [ManualWeld](https://developer.roblox.com/en-us/api-reference/class/ManualWeld) class. It functions identically to the [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue) class. */
interface ManualGlue extends ManualSurfaceJointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ManualGlue: unique symbol;
}
/** An object that holds two parts together. It is commonly created when the _Join Always_ setting in Studio is turned on.
*
* Functions identically to [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld).
*
* See also [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) for a newer alternative using the [constraints](https://developer.roblox.com/en-us/articles/constraints) system that does not require [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) or [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) properties to be manually set.
*
* Root part
* ---------
*
* Every Assembly has a root part, see [BasePart:GetRootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart). When a ManualWeld's [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) is modified the root part will stay where it was.
*
* Directionality
* --------------
*
* ManualWelds do not have any directionality. [Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) or [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1), doesn't matter. You can imagine rigid joints forming a tree branching down from the root part. All the parts down the tree from root will move, and their welded “children” in this tree will move with them.
*/
interface ManualWeld extends ManualSurfaceJointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ManualWeld: unique symbol;
}
/** An object used to make movable [JointInstance](https://developer.roblox.com/en-us/api-reference/class/JointInstance) between two Parts. */
interface Motor extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Motor: unique symbol;
/**
* Displays the current rotation of the motor in radians.
*
* Tags: NotReplicated
*/
CurrentAngle: number;
/**
* The desired angle to turn the motor to in radians. The motor will attempt to reach this angle (provided [Motor.MaxVelocity](https://developer.roblox.com/en-us/api-reference/property/Motor/MaxVelocity) is greater than 0.
*/
DesiredAngle: number;
/**
* The maximum velocity the motor can use to reach [Motor.DesiredAngle](https://developer.roblox.com/en-us/api-reference/property/Motor/DesiredAngle) measured in radians per physics frame (1/60th of a second).
*/
MaxVelocity: number;
/**
* Sets [Motor.DesiredAngle](https://developer.roblox.com/en-us/api-reference/property/Motor/DesiredAngle) of the motor.
*/
SetDesiredAngle(this: Motor, value: number): void;
}
/** **Motor6D** joins two [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) ([Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) and [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1)) together in an animatable way. The [Transform](https://developer.roblox.com/en-us/api-reference/property/Motor6D/Transform) property determines the offset between these parts. This can be set manually using [RunService.Stepped](https://developer.roblox.com/en-us/api-reference/event/RunService/Stepped) or through an [Animator](https://developer.roblox.com/en-us/api-reference/class/Animator).
*
* Models whose parts are joined by Motor6D are usually referred to as rigs, typically for [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s. There are two primary kinds of rigs for [Player](https://developer.roblox.com/en-us/api-reference/class/Player) avatars: R6 and R15.
*/
interface Motor6D extends Motor {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Motor6D: unique symbol;
/**
* The internal CFrame that is manipulated by Animations when a Motor6D is being animated. It is recommended to use this property for custom animations rather than [JointInstance.C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) and [JointInstance.C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1).
*
* Transform is the transformation between the “parent” [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) and the “child” part. The “parent” part will always be the part that is more directly connected to the JointInstance.C0. This is not affected by which part is assigned to [JointInstance.Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) and which is [JointInstance.Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1). If the side the root part is on changes the interpretation of Transform will be inverted.
*
* Similar to a [WeldJoint](https://developer.roblox.com/en-us/articles/weld), an active Motor6D will rigidly hold its two parts such that:
* `PartParent.CFrame * CParent * Transform == PartChild.CFrame * Child`
*
* Tags: Hidden, NotReplicated
*/
Transform: CFrame;
}
/** The Rotate object is used to allow rotation between two parts. Most commonly created through the Hinge SurfaceType on a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). If created like this, the rotation will be about the normal vector from the face of the part the hinge is placed on. If created through a script the axis and point of rotation can be defined arbitrarily. */
interface Rotate extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Rotate: unique symbol;
}
/** An object that holds two objects rigidly together. Most commonly created when [BasePart:MakeJoints](https://developer.roblox.com/en-us/api-reference/function/BasePart/MakeJoints) is called on parts where Inlet and Stud [SurfaceType](https://developer.roblox.com/en-us/api-reference/enum/SurfaceType) are touching.
*
* Functionally identical to [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld).
*
* See also [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) for a newer alternative using the [constraints](https://developer.roblox.com/en-us/articles/constraints) system that does not require [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) or [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) properties to be manually set.
*
* Root part
* ---------
*
* Every Assembly has a root part, see [BasePart:GetRootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart). When a Snap's [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) is modified the root part will stay where it was.
*
* Directionality
* --------------
*
* Snaps do not have any directionality. [Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) or [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1), doesn't matter. You can imagine rigid joints forming a tree branching down from the root part. All the parts down the tree from root will move, and their welded “children” in this tree will move with them.
*/
interface Snap extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Snap: unique symbol;
}
/** The VelocityMotor is a special type of joint that works similarly to a [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), but it uses a [MotorFeature](https://developer.roblox.com/en-us/api-reference/class/MotorFeature) and a [Hole](https://developer.roblox.com/en-us/api-reference/class/Hole) to create the connection.
*
* In order for this object to work correctly:
*
*
* * The VelocityMotor must be parented inside of a [MotorFeature](https://developer.roblox.com/en-us/api-reference/class/MotorFeature)
*
* * The \`MotorFeature\` needs to be parented inside of a \`BasePart\`
* * A \`Hole\` needs to be parented inside of another \`BasePart\`
* * The VelocityMotor's \`VelocityMotor/Hole\` property should be assigned to the hole you parented inside of the other part.
*/
interface VelocityMotor extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_VelocityMotor: unique symbol;
/**
* Displays the angle that the motor is at in radians.
*/
CurrentAngle: number;
/**
* The desired angle to be reached. The motor will attempt to reach this angle.
*/
DesiredAngle: number;
/**
* The [Hole](https://developer.roblox.com/en-us/api-reference/class/Hole) linked to this VelocityMotor.
*/
Hole: Hole | undefined;
/**
* The maximum amount of velocity able to be reached.
*/
MaxVelocity: number;
}
/** An object used to hold two objects together in a relative position, regardless of whether they're touching. This object is placed inside of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) and the [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1) property determines which other part should be welded to the original part. Two [CFrames](https://developer.roblox.com/en-us/api-reference/datatype/CFrame), [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) and [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1), then determine how the parts should be placed.
*
* See also [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) for a newer alternative using the [constraints](https://developer.roblox.com/en-us/articles/constraints) system that does not require [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) or [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) properties to be manually set.
*
* While the weld is [Active](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Active), it maintains the part positions such that:
* `part1.CFrame * C1 == Part0.CFrame * C0`
*
* Root part
* ---------
*
* Every Assembly has a root part, see [BasePart:GetRootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart). When a Weld's [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) is modified the root part will stay where it was.
*
* Directionality
* --------------
*
* Welds do not have any directionality. [Part0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part0) or [Part1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/Part1), doesn't matter. You can imagine rigid joints forming a tree branching down from the root part. All the parts down the tree from root will move, and their welded “children” in this tree will move with them.
*/
interface Weld extends JointInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Weld: unique symbol;
}
/** The JointsService is a service that stores joints created by surface connections. It also has API available for visualizing surface to surface contact, and joining surfaces together. */
interface JointsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_JointsService: unique symbol;
/**
* Will remove any 'create joints' that were made visible via the [JointsService:ShowPermissibleJoints](https://developer.roblox.com/en-us/api-reference/function/JointsService/ShowPermissibleJoints) method.
*/
ClearJoinAfterMoveJoints(this: JointsService): void;
/**
* Updates all visible joints for the parts assigned by the [JointsService:SetJoinAfterMoveTarget](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveTarget) and [JointsService:SetJoinAfterMoveInstance](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveInstance) methods.
*/
CreateJoinAfterMoveJoints(this: JointsService): void;
/**
* Sets the PVInstance that will be connected with the target PVInstance specified by [JointsService:SetJoinAfterMoveTarget](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveTarget).
*/
SetJoinAfterMoveInstance(this: JointsService, joinInstance: PVInstance): void;
/**
* Sets the PVInstance that will be connected with the PVInstance specified by [JointsService:SetJoinAfterMoveInstance](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveInstance).
*/
SetJoinAfterMoveTarget(this: JointsService, joinTarget: PVInstance): void;
/**
* When used it will visibly display a potential surface connection between the two [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), which were set with [JointsService:SetJoinAfterMoveTarget](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveTarget) and [JointsService:SetJoinAfterMoveInstance](https://developer.roblox.com/en-us/api-reference/function/JointsService/SetJoinAfterMoveInstance).
*/
ShowPermissibleJoints(this: JointsService): void;
}
/** A Keyframe holds the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s applied to joints in a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) at a given point of time in an animation. [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)s are interpolated between during animation playback.
*
* Note, in most cases developers do not need to manipulate [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence)s as the animation editor covers most animation functionality. However, in some cases a developer may wish to generate an animation from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or build their own plugin.
*
* **Structure**
*
* Keyframes are held within a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) and contain [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) objects. The poses are named in accordance with the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s they correspond to and are structured in terms of joint hierarchy. This means each [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is parented to the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) corresponding to the part it is attached to. See below for a visual example.
*
* 
*
* Note, as [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s are named in accordance with the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s they correspond to, animations require distinct part names to play correctly.
*
* **Interpolation**
*
* During animation playback the poses in different keyframes are interpolated between. This allows a smooth animation to be created without needing to define every frame. Note, the style of interpolation is determined in the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) object. The Keyframe object merely holds the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s at a defined point of time in the animation ([Keyframe.Time](https://developer.roblox.com/en-us/api-reference/property/Keyframe/Time)).
*/
interface Keyframe extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Keyframe: unique symbol;
/**
* This property gives the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe)'s time position (in seconds) in an animation. This determines the time at which the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s inside the keyframe will be shown.
*
* Note the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) with the highest time value in a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) is used to determine the length of the animation.
*/
Time: number;
/**
* This function adds a [KeyframeMarker](https://developer.roblox.com/en-us/api-reference/class/KeyframeMarker) to the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) by parenting it to the keyframe. It is functionally identical to setting the marker's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to the Keyframe.
*
* Note, this function will not error when an instance other than a KeyframeMarker is given as the parameter and will parent it successfully.
*
* More about Keyframes
* --------------------
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names do not need to be unique. For example, if an Animation has three keyframes named “Particles” the connected event returned by [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal) will fire each time one of these keyframes is reached.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names can be set in the Roblox Animation Editor when creating or editing an animation. They cannot however be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on an existing animation prior to playing it.
*
* See also
* --------
*
* * [Keyframe:RemoveMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/RemoveMarker)
* * [Keyframe:GetMarkers](https://developer.roblox.com/en-us/api-reference/function/Keyframe/GetMarkers)
* * [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal)
*/
AddMarker(this: Keyframe, marker: KeyframeMarker): void;
/**
* This function adds a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) to the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) by parenting it to the keyframe. It is functionally identical to setting the pose's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to the keyframe.
*
* Note, this function will not error when an instance other than a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is given as the pose parameter and will parent it successfully.
*/
AddPose(this: Keyframe, pose: Pose): void;
/**
* This function returns an array containing all [KeyframeMarkers](https://developer.roblox.com/en-us/api-reference/class/KeyframeMarker) that have been added to the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe). Note, this function will only return [instances](https://developer.roblox.com/en-us/api-reference/class/Instance) of type KeyframeMarker.
*
* More about Keyframes
* --------------------
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names do not need to be unique. For example, if an Animation has three keyframes named “Particles” the connected event returned by [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal) will fire each time one of these keyframes is reached.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names can be set in the Roblox Animation Editor when creating or editing an animation. They cannot however be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on an existing animation prior to playing it.
*
* See also
* --------
*
* * [Keyframe:AddMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/AddMarker)
* * [Keyframe:RemoveMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/RemoveMarker)
* * [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal)
*/
GetMarkers(this: Keyframe): Array;
/**
* This function returns an array containing all [Poses](https://developer.roblox.com/en-us/api-reference/class/Pose) that have been added to a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe).
*/
GetPoses(this: Keyframe): Array;
/**
* This function removes a [KeyframeMarker](https://developer.roblox.com/en-us/api-reference/class/KeyframeMarker) from the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) by settings its [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to nil.
*
* The KeyframeMarker's Instance.Parent is set to nil but it is not destroyed. This means, provided the marker is referenced it can be re-parented later.
*
* Note, this function will not error when an instance other than a KeyframeMarker is given as the parameter.
*
* More about Keyframes
* --------------------
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names do not need to be unique. For example, if an Animation has three keyframes named “Particles” the connected event returned by [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal) will fire each time one of these keyframes is reached.
*
* [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) names can be set in the Roblox Animation Editor when creating or editing an animation. They cannot however be set by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) on an existing animation prior to playing it.
*
* See also
* --------
*
* * [Keyframe:AddMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/AddMarker)
* * [Keyframe:GetMarkers](https://developer.roblox.com/en-us/api-reference/function/Keyframe/GetMarkers)
* * [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal)
*/
RemoveMarker(this: Keyframe, marker: KeyframeMarker): void;
/**
* This function removes a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) from the [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) by setting its [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to nil.
*
* The [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)'s [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) is set to nil, but it is not destroyed. This means, provided the pose is referenced it can be re-parented later.
*
* Note, this function will not error when an instance other than a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is given as the pose parameter.
*/
RemovePose(this: Keyframe, pose: Pose): void;
}
/** A KeyframeMarker is an instance meant to represent an event that will eventually be fired when a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) is hit.
*
* Using a KeyframeMarker
* ----------------------
*
* KeyframeMarkers should always be parented to a Keyframe via setting the parent directly or using the [Keyframe:AddMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/AddMarker) function of Keyframe. KeyframeMarkers can also be removed directly or using the [Keyframe:RemoveMarker](https://developer.roblox.com/en-us/api-reference/function/Keyframe/RemoveMarker) function, and polled to check which markers are attached to a specific Keyframe using [Keyframe:GetMarkers](https://developer.roblox.com/en-us/api-reference/function/Keyframe/GetMarkers).
*
* Whenever a Keyframe is detected as an animation is running, there will be an event fired for each KeyframeMarker that is parented to the Keyframe. These events are identifiable by the name of the KeyframeMarker. You can retrieve and listen to these events using the `AnimationTrack/GetKeyframeMarkerReached` function. Optionally, you may set the [KeyframeMarker.Value](https://developer.roblox.com/en-us/api-reference/property/KeyframeMarker/Value) property of the KeyframeMarker in order to pass along a value with the event being fired.
*
* It inherits the [Keyframe.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) property from [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) and behaves identically. Names are used for identification and no not need to be unique. When multiple KeyFrameMarkers with the same name are attached to a KeyFrame, events such as the one returned by [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal) will fire for every marker.
*
* See also
* --------
*
* * [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe), holds the [Poses](https://developer.roblox.com/en-us/api-reference/class/Pose) applied to joints in a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) at a given point of time in an animation
* * [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack), controls the playback of an animation on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController)
* * [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation), holds a reference to animation data required to play custom animations on characters or other models using the Roblox animation system
*/
interface KeyframeMarker extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_KeyframeMarker: unique symbol;
/**
* A value that is specified for a [KeyframeMarker](https://developer.roblox.com/en-us/api-reference/class/KeyframeMarker). Whenever the signal created from [AnimationTrack:GetMarkerReachedSignal](https://developer.roblox.com/en-us/api-reference/function/AnimationTrack/GetMarkerReachedSignal) gets fired, this value will be passed into the connected function.
*
* See also
* --------
*
* * [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe), holds the [Poses](https://developer.roblox.com/en-us/api-reference/class/Pose) applied to joints in a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) at a given point of time in an animation
* * [AnimationTrack](https://developer.roblox.com/en-us/api-reference/class/AnimationTrack), controls the playback of an animation on a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) or [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController)
*/
Value: string;
}
/** The KeyframeSequenceProvider is a service that is used to load and preview [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence)s. It includes a number of functions that are useful when working with [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation)s.
*
* What is a KeyframeSequence?
* ---------------------------
*
* The animation data Roblox uses in the playback of an animation, referenced by the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) property, is constructed from a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence). Every animation has a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) associated with it. [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence)s are usually created by the Roblox Animation Editor but can be created through other plugins or even manually.
*
* For more information, see the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) page.
*
* What does the KeyframeSequenceProvider do?
* ------------------------------------------
*
* The KeyframeSequenceProvider has a number of uses.
*
* * Download the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) associated with an animation content ID from the Roblox website
* * Generate a temporary id to locally preview an animation
* * Fetch the content IDs of animations owned by a particular user.
*/
interface KeyframeSequenceProvider extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_KeyframeSequenceProvider: unique symbol;
/**
* Generates a temporary asset ID from a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) that can be used for localized testing of an animation.
*
* This function performs the same function to [KeyframeSequenceProvider:RegisterKeyframeSequence](https://developer.roblox.com/en-us/api-reference/function/KeyframeSequenceProvider/RegisterKeyframeSequence) however this function generates an _active://_ URL instead of a hash.
*
* The ID generated can be used in an [Animation](https://developer.roblox.com/en-us/api-reference/class/Animation)'s [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) property for testing.
*
* The asset ID generated by this function is temporary and cannot be used outside of Studio. Developers wishing to generate an asset ID that can be used online should upload the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) to Roblox.
*/
RegisterActiveKeyframeSequence(this: KeyframeSequenceProvider, keyframeSequence: KeyframeSequence): string;
/**
* Generates a temporary asset ID from a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) that can be used for localized testing of an animation.
*
* This function performs the same function to [KeyframeSequenceProvider:RegisterActiveKeyframeSequence](https://developer.roblox.com/en-us/api-reference/function/KeyframeSequenceProvider/RegisterActiveKeyframeSequence) however this function generates a hash instead of an _active://_ URL.
*
* The ID generated can be used for the [Animation.AnimationId](https://developer.roblox.com/en-us/api-reference/property/Animation/AnimationId) property to test animations.
*
* The asset ID generated by this function is temporary and cannot be used outside of Studio. Developers wishing to generate an asset ID that can be used online should upload the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) to Roblox.
*/
RegisterKeyframeSequence(this: KeyframeSequenceProvider, keyframeSequence: KeyframeSequence): string;
/**
* This function returns an [InventoryPages](https://developer.roblox.com/en-us/api-reference/class/InventoryPages) object which can be used to iterate over animations owned by a specific user.
*
* This function has a number of potential uses, such as allowing users to browse and import animations into a custom animation plugin.
*
* Tags: Yields
*/
GetAnimations(this: KeyframeSequenceProvider, userId: number): InventoryPages;
/**
* GetKeyframeSequenceAsync returns a [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) based on the specified assetId. The assetId must correspond to an animation. The function will yield until the [KeyframeSequence](https://developer.roblox.com/en-us/api-reference/class/KeyframeSequence) is loaded from the website. Because this is a webcall it should wrapped in a pcall.
*
* Tags: Yields
*/
GetKeyframeSequenceAsync(this: KeyframeSequenceProvider, assetId: string): KeyframeSequence;
}
interface LSPFileSyncService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LSPFileSyncService: unique symbol;
}
interface LanguageService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LanguageService: unique symbol;
}
/** Light is a root class for dynamic lighting related objects. */
interface Light extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Light: unique symbol;
/**
* Sets how bright the emitted light is, defaults to 1.
*/
Brightness: number;
/**
* The color of the emitted light.
*/
Color: Color3;
/**
* If set to true, light will be emitted from the source object.
*/
Enabled: boolean;
/**
* If set to true, will project shadows if light is blocked by an obstacle.
*/
Shadows: boolean;
}
/** A PointLight is a light source that emits illumination from a single point. Light is emitted spherically based on the [PointLight.Range](https://developer.roblox.com/en-us/api-reference/property/PointLight/Range) of the PointLight.
*
* In order for a PointLight to provide illumination, it must be the direct child of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) (the part or attachment itself must be a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace)).
*
* If a PointLight is parented to a part, then the light will emanate from the part's [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position). If a PointLight is parented to an attachment, then the light will emanate from the attachment's [Attachment.WorldPosition](https://developer.roblox.com/en-us/api-reference/property/Attachment/WorldPosition).
*
* For more light types, see the **see also** section.
*
* See Also
* --------
*
* * [SurfaceLight](https://developer.roblox.com/en-us/api-reference/class/SurfaceLight)
* * [SpotLight](https://developer.roblox.com/en-us/api-reference/class/SpotLight)
*/
interface PointLight extends Light {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PointLight: unique symbol;
/**
* The size of the area that the PointLight will illuminate.
*/
Range: number;
}
/** A spotlight emits light of a specified [Color](https://developer.roblox.com/en-us/api-reference/property/Light/Color) and [Brightness](https://developer.roblox.com/en-us/api-reference/property/Light/Brightness) in the shape of a cone with a spherical base. This object is ideal for **directional** light sources like flashlights and headlights.
*
* [Range](https://developer.roblox.com/en-us/api-reference/property/SpotLight/Range) controls the distance of illumination and [Angle](https://developer.roblox.com/en-us/api-reference/property/SpotLight/Angle) defines the angle of light emission from the cone's apex as illustrated below.
*
* A spotlight must be a direct child of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) and will exhibit the following behavior:
*
* * When the spotlight is parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), the [SpotLight.Face](https://developer.roblox.com/en-us/api-reference/property/SpotLight/Face) property determines the face of the part from which light emanates.
* * Although [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment) don't have faces, the [SpotLight.Face](https://developer.roblox.com/en-us/api-reference/property/SpotLight/Face) property determines the axis of the attachment from which light emanates; **\-Z** is front, **+X** is right, **+Y** is top, etc.
*
* 
*
* See Also
* --------
*
* * [SurfaceLight](https://developer.roblox.com/en-us/api-reference/class/SurfaceLight)
* * [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight)
*/
interface SpotLight extends Light {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SpotLight: unique symbol;
/**
* The angle of which the light is shone from the SpotLight.
*/
Angle: number;
/**
* Sets the side of the parent that the SpotLight comes from.
*/
Face: Enum.NormalId;
/**
* The size of the area that the SpotLight will illuminate.
*/
Range: number;
}
/** A SurfaceLight is a light source that emits illumination of a specified [Light.Color](https://developer.roblox.com/en-us/api-reference/property/Light/Color) and [Light.Brightness](https://developer.roblox.com/en-us/api-reference/property/Light/Brightness) from a [SurfaceLight.Face](https://developer.roblox.com/en-us/api-reference/property/SurfaceLight/Face) for a specified [SurfaceLight.Range](https://developer.roblox.com/en-us/api-reference/property/SurfaceLight/Range).
*
* In order for a SurfaceLight to provide illumination, it must be the direct child of a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) (the part or attachment itself must be a descendant of the Workspace). If a SurfaceLight is parented to a part, then the light will emanate from the part's selected face(s). If parented to an attachment SurfaceLight is equivalent to a [SpotLight](https://developer.roblox.com/en-us/api-reference/class/SpotLight).
*
*
* For more light types, please see the **see also** section.
*
* See Also
* --------
*
* * [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight)
* * [SpotLight](https://developer.roblox.com/en-us/api-reference/class/SpotLight)
*/
interface SurfaceLight extends Light {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SurfaceLight: unique symbol;
/**
* The angle of which the light is shone from the SurfaceLight.
*/
Angle: number;
/**
* Sets the side of the parent that the SurfaceLight comes from.
*/
Face: Enum.NormalId;
/**
* The distance from the SurfaceLight's face that will illuminate.
*/
Range: number;
}
/** **Note**
*
* Fog properties are hidden when Lighting contains an `[Atmosphere](Atmosphere)` object.
*
* The Lighting service controls the environmental lighting in a game. It includes a range of adjustable properties that can be used to change how lighting appears and interacts with other objects.
*
* Developers can change the color and appearance of lighting in their place using properties such as [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) and [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient).
*
* In addition to controlling environmental lighting, the Lighting service also configures any fog in the game using the [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor), [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) properties.
*
* Lighting, along with [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera), is one of the two places where [PostEffect](https://developer.roblox.com/en-us/api-reference/class/PostEffect)s such as the [SunRaysEffect](https://developer.roblox.com/en-us/api-reference/class/SunRaysEffect) and [BlurEffect](https://developer.roblox.com/en-us/api-reference/class/BlurEffect) are displayed once parented to.
*
* Notes
* -----
*
* * Lighting only controls environmental lighting and not dynamic light objects such as the [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight)
* * Prior to the introduction of [ServerStorage](https://developer.roblox.com/en-us/api-reference/class/ServerStorage) and [ReplicatedStorage](https://developer.roblox.com/en-us/api-reference/class/ReplicatedStorage) lighting was used for storage. This behavior is not supported and should not be used in new work
*/
interface Lighting extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Lighting: unique symbol;
/**
* The lighting hue applied to areas that are occluded from the sky, such as indoor areas.
*
* This property defaults to 0, 0, 0 (black).
*
* As long as the red, green and blue channels of this property do not exceed the corresponding channels in [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) the change in hue will be reserved for areas occluded from the sun/moon. The effective [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) value is clamped to be greater than or equal to Ambient in all channels. This means, if a channel of Ambient exceeds its corresponding [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) channel then the hue will begin to apply to outdoor areas.
*
* Note, when [Lighting.GlobalShadows](https://developer.roblox.com/en-us/api-reference/property/Lighting/GlobalShadows) is disabled there is no distinction between areas occluded and areas that are not. In this case [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) will be ignored and the hue from the Ambient property will be applied everywhere.
*
* For more properties that influence the color of lighting, please see `Lighting/ColorShiftBottom` and `Lighting/ColorShiftTop`.
*/
Ambient: Color3;
/**
* The intensity of illumination in the place.
*
* Changing this value will influence the impact of the light source (sun or moon) on the map's lighting. When brightness is set to 0, there will be no effect due to [Lighting.ColorShift_Top](https://developer.roblox.com/en-us/api-reference/property/Lighting/ColorShift_Top) or [Lighting.ColorShift_Bottom](https://developer.roblox.com/en-us/api-reference/property/Lighting/ColorShift_Bottom) as the light source is having no effect. Note, it will not influence the shadows created by the [Lighting.GlobalShadows](https://developer.roblox.com/en-us/api-reference/property/Lighting/GlobalShadows) property.
*
* Whilst this property is not clamped, the effect is clamped between 0 and 2. Meaning setting Brightness to 10 will be no different to setting it to 2.
*
* Note, [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) and [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) can also be used to influence how bright a place appears. For example, setting [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) to 255, 255, 255 will make the place appear brighter than its default value of 127, 127, 127 (as it is more white).
*/
Brightness: number;
/**
* A numerical representation (in hours) of the current time of day used by [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting).
*
* Note, this property does not correspond with the actual time of day and will not change during the game unless it has been changed by a script.
*
* For a measure of [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting)'s time formatted as a 24 hour string use `Lighting/CurrentTime`. Changing `Lighting/CurrentTime` or using [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) will also change this property.
*
* Using ClockTime requires the time to be normalized:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local hours = minutesNormalised / 60
*
* Lighting.ClockTime = hours
*
* wait()
* end
*
* Using [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay) requires the time to be normalized and a string formatted:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local seconds = minutesNormalised \* 60
* local hours = string.format("%02.f", math.floor(seconds/3600))
* local mins = string.format("%02.f", math.floor(seconds/60 - (hours\*60)))
* local secs = string.format("%02.f", math.floor(seconds - hours\*3600 - mins \*60))
* local timeString = hours..":"..mins..":"..secs
*
* Lighting.TimeOfDay = timeString
*
* wait()
* end
*
* Using [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) requires no extra processing:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* Lighting:SetMinutesAfterMidnight(minutesAfterMidnight)
*
* wait()
* end
*
* Tags: NotReplicated
*/
ClockTime: number;
ColorShift_Bottom: Color3;
ColorShift_Top: Color3;
/**
* Ambient light that is derived from the environment. The value of this property defaults to 0.
*
* It is similar to [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) and [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) property but it's dynamic and can change according sky and time of day. It is recommended when this property is increased, Ambient and OutdoorAmbient are decreased accordingly.
*
* Note
* ----
*
* * It also makes skybox show up at night
*/
EnvironmentDiffuseScale: number;
/**
* Specular light derived from environment. The value of this property defaults to 0.
*
* It will make smooth objects reflect the environment. Especially important to make metal more realistic.
*/
EnvironmentSpecularScale: number;
/**
* This property determines the exposure compensation amount which applies a bias to the exposure level of the scene prior to the tonemap step. Defaults to 0.
*
* * A value of +1 indicates twice as much exposure and -1 means half as much exposure.
* * A value of 0 indicates no exposure compensation will be done.
* * Range: -5 to 5
*
* This property is replicated and can be set from scripts or [Studio](https://developer.roblox.com/en-us/api-reference/class/Studio).
*
* local Lighting = game:GetService("Lighting")
* Lighting.ExposureCompensation = 5
*
* You can use this property to adjust the exposure amount prior to the tonemap step to show more detail either in lighter or darker areas. This is needed as we move to a HDR pipeline.
*
* When [Lighting.Technology](https://developer.roblox.com/en-us/api-reference/property/Lighting/Technology) is set to [Legacy](https://developer.roblox.com/en-us/api-reference/enum/Technology), this property has no effect.
*
* local Lighting = game:GetService("Lighting")
*
* -- ExposureCompensation has no effect because Lighting's Technology is Legacy
* Lighting.Technology = Enum.Technology.Legacy
* Lighting.ExposureCompensation = 5
*/
ExposureCompensation: number;
/**
* **Note**
*
* Fog properties are hidden when Lighting contains an `[Atmosphere](../../Class/Atmosphere)` object.
*
* A \`DataType/Color3\` value giving the hue of \`Lighting\`'s fog.
*
* How does fog work?
* ------------------
*
* Fog in Roblox is displayed in a plane perpendicular to the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera)s direction. It fades between the [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) property where it is not visible, to the [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) property where it is fully opaque. The effect of fog is it blends color with the FogColor.
*
* At distances greater than [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd), color will be determined entirely by the FogColor. However at distances between [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) the degree to which the color is blended depends on the position.
*
* Roblox's fog uses linear interpolation between [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd). This means if [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) is 10 and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) is 20, at a distance of 15 studs the fog will be at 50%. That means the color of a pixel at 15 studs will be 50% its normal color blended with 50% of the fog color.
*
* local Lighting = game:GetService("Lighting")
* -- fog will fade between 25 and 200 studs
* Lighting.FogStart = 25
* Lighting.FogEnd = 200
*
* Note, fog does not obscure the skybox.
*
* For more information about fog please see this [blog post](https://blog.roblox.com/2011/12/roblox-secrets-revealed-fog-blog/).
*/
FogColor: Color3;
/**
* **Note**
*
* Fog properties are hidden when Lighting contains an `[Atmosphere](../../Class/Atmosphere)` object.
*
* The depth from the \`Workspace/CurrentCamera\`, in studs, at which fog will be completely opaque.
*
* How does fog work?
* ------------------
*
* Fog in Roblox is displayed in a plane perpendicular to the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera)s look direction. It fades between the [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) property where it is not visible, to the FogEnd property where it is fully opaque. The effect of fog is it blends color with the [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor).
*
* At distances greater than FogEnd, color will be determined entirely by the [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor). However at distances between [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and FogEnd the degree to which the color is blended depends on the position.
*
* Roblox's fog uses linear interpolation between [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and FogEnd. This means if [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) is 10 and FogEnd is 20, at a distance of 15 studs the fog will be at 50%. That means the color of a pixel at 15 studs will be 50% its normal color blended with 50% of the fog color.
*
* local Lighting = game:GetService("Lighting")
* -- fog will fade between 25 and 200 studs
* Lighting.FogStart = 25
* Lighting.FogEnd = 200
*
* The color of the fog can be adjusted using [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor).
*
* Note, fog does not obscure the skybox.
*
* For more information about fog please see this [blog post](https://blog.roblox.com/2011/12/roblox-secrets-revealed-fog-blog/).
*/
FogEnd: number;
/**
* **Note**
*
* Fog properties are hidden when Lighting contains an `[Atmosphere](../../Class/Atmosphere)` object.
*
* The depth from the \`Workspace/CurrentCamera\`, in studs, at which fog begins to show.
*
* How does fog work?
* ------------------
*
* Fog in Roblox is displayed in a plane perpendicular to the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera)s look direction. It fades between the FogStart property where it is not visible, to the [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) property where it is fully opaque. The effect of fog is it blends color with the [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor).
*
* At distances greater than [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd), color will be determined entirely by the [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor). However at distances between FogStart and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) the degree to which the color is blended depends on the position.
*
* Roblox's fog uses linear interpolation between FogStart and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd). This means if FogStart is 10 and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) is 20, at a distance of 15 studs the fog will be at 50%. That means the color of a pixel at 15 studs will be 50% its normal color blended with 50% of the fog color.
*
* local Lighting = game:GetService("Lighting")
* -- fog will fade between 25 and 200 studs
* Lighting.FogStart = 25
* Lighting.FogEnd = 200
*
* The color of the fog can be adjusted using [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor).
*
* Note, fog does not obscure the skybox.
*
* For more information about fog please see this [blog post](https://blog.roblox.com/2011/12/roblox-secrets-revealed-fog-blog/).
*/
FogStart: number;
/**
* The geographic latitude, in degrees, of the scene, influencing the result of [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting)s time on the position of the sun and moon.
*
* When calculating the position of the sun, the earth's tilt is also taken into account.
*
* Changing GeographicLatitude will alter the position of the sun at every [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay). Developers looking to obtain the sun or moon's position should use [Lighting:GetSunDirection](https://developer.roblox.com/en-us/api-reference/function/Lighting/GetSunDirection) or [Lighting:GetMoonDirection](https://developer.roblox.com/en-us/api-reference/function/Lighting/GetMoonDirection).
*/
GeographicLatitude: number;
/**
* Toggles voxel-based dynamic lighting in the game
*
* What does GlobalShadows do?
* ---------------------------
*
* When set to true, shadows are rendered in sheltered areas depending on the position of the sun and moon. The lighting hue applied to these areas is determined by the [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) property. The lighting hue in all other areas is determined by the [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) property.
*
* When disabled, shadows are not drawn and no distinction is made between indoor and outdoor areas. As a result, the [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) property determines the lighting hue and [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient) will do nothing.
*
* Shadows are calculated using a voxel system, and each lighting voxel is 4x4x4 studs. This means objects need to be larger than 4x4x4 studs to display a realistic shadow. Shadows are also recalculated when [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are moving.
*
* Note, this property is unrelated to shadows from characters which are displayed regardless of what GlobalShadows is set to.
*
* For more information about Roblox's dynamic lighting, please see this [blog post](https://blog.roblox.com/2013/02/dynamic-lighting-and-shadows-the-voxel-solution/).
*
* Toggling GlobalShadows
* ----------------------
*
* Developers toggling the GlobalShadows setting will notice that disabling it makes the place considerably darker. This is because when GlobalShadows is disabled [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) is used to calculate the lighting hue in both indoor and ourdoor spaces. This darkness can be resolved by setting [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) to a higher value such as [Lighting.OutdoorAmbient](https://developer.roblox.com/en-us/api-reference/property/Lighting/OutdoorAmbient)'s default value of 127, 127, 127.
*
* In most cases developers are recommended to leave GlobalShadows enabled due to the superior visual appearance. See the image below for a comparison.
*
* 
*/
GlobalShadows: boolean;
/**
* The lighting hue applied to outdoor areas.
*
* This property defaults to 127, 127, 127.
*
* As long as the red, green and blue channels of [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) do not exceed the corresponding channels in this property, the hue of the lighting in outdoor areas will be determined by this property. The effective OutdoorAmbient value is clamped to be greater than or equal to [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) in all channels. This means, if a channel of [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) exceeds its corresponding OutdoorAmbient channel then the hue of [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) will begin to apply to outdoor areas. For a visual demonstration of this, please see the images below.
*
* 
*
* Note, when [Lighting.GlobalShadows](https://developer.roblox.com/en-us/api-reference/property/Lighting/GlobalShadows) is disabled there is no distinction between areas occluded from the sky and areas that are not. In this case OutdoorAmbient will be ignored and the hue from the [Lighting.Ambient](https://developer.roblox.com/en-us/api-reference/property/Lighting/Ambient) property will be applied everywhere.
*
* For more properties that influence the color of lighting, please see [Lighting.ColorShift_Bottom](https://developer.roblox.com/en-us/api-reference/property/Lighting/ColorShift_Bottom) and [Lighting.ColorShift_Top](https://developer.roblox.com/en-us/api-reference/property/Lighting/ColorShift_Top).
*/
OutdoorAmbient: Color3;
/**
* This property determines whether outlines are enabled or disabled in a place.
*
* Outlines can be disabled on a global basis, using this [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) property, or alternatively on a surface-by-surface basis for [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s using [SurfaceType](https://developer.roblox.com/en-us/api-reference/enum/SurfaceType).
*
* Although this property can be set by scripts, it recommended this property is set in Roblox Studio prior to publishing the place.
* @deprecated
*/
Outlines: boolean;
/**
* This is supposed to change the color of player shadows, but currently doesn't do anything.
*
* Tags: NotReplicated
* @deprecated
*/
ShadowColor: Color3;
/**
* Controls how blurry the shadows are. The value of this property defaults to 0.2.
*
* This property only works when [Lighting.Technology](https://developer.roblox.com/en-us/api-reference/property/Lighting/Technology) mode is [ShadowMap](https://developer.roblox.com/en-us/api-reference/enum/Technology) or [Future](https://developer.roblox.com/en-us/api-reference/enum/Technology) and the device is capable of ShadowMap.
*/
ShadowSoftness: number;
/**
* A 24 hour string representation of the current time of day used by [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting).
*
* Note, this property does not correspond with the actual time of day and will not change during the game unless it has been changed by a script.
*
* For a numeric measure of [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting)'s time use [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime). Changing [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) or using [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) will also change this property.
*
* Using TimeOfDay requires the time to be normalized and a string formatted:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local seconds = minutesNormalised \* 60
* local hours = string.format("%02.f", math.floor(seconds/3600))
* local mins = string.format("%02.f", math.floor(seconds/60 - (hours\*60)))
* local secs = string.format("%02.f", math.floor(seconds - hours\*3600 - mins \*60))
* local timeString = hours..":"..mins..":"..secs
*
* Lighting.TimeOfDay = timeString
*
* wait()
* end
*
* Using [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) requires the time to be normalized:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local hours = minutesNormalised / 60
*
* Lighting.ClockTime = hours
*
* wait()
* end
*
* Using [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) requires no extra processing:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* Lighting:SetMinutesAfterMidnight(minutesAfterMidnight)
*
* wait()
* end
*/
TimeOfDay: string;
/**
* Returns the number of minutes that have passed after midnight for the purposes of lighting.
*
* This number will be nearly identical to [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) multiplied by 60.
*
* This number will not always be equal to the value given in [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) as it returns minutes after midnight in the current day.
*
* For [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting)s time formatted as a string, see [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay).
*/
GetMinutesAfterMidnight(this: Lighting): number;
/**
* Returns a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) representing the direction of the moon from the position 0, 0, 0.
*
* Note, when the moon has 'set' and is no longer visible, the [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) returned by this function will continue to point towards the moon below the map.
*
* Developers looking to change the positioning of the moon should use the [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) or [Lighting.GeographicLatitude](https://developer.roblox.com/en-us/api-reference/property/Lighting/GeographicLatitude) properties.
*
* A variant of this function exists for obtaining the direction of the sun, [Lighting:GetSunDirection](https://developer.roblox.com/en-us/api-reference/function/Lighting/GetSunDirection).
*/
GetMoonDirection(this: Lighting): Vector3;
/**
* Returns the moon's current phase. There is no way to change the moon's phase so this will always return 0.75
*/
GetMoonPhase(this: Lighting): number;
/**
* Returns a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) representing the direction of the sun from the position 0, 0, 0.
*
* Note, when the sun has set and is no longer visible, the [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) returned by this function will continue to point towards the sun below the map.
*
* Developers looking to change the positioning of the sun should use the [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) or [Lighting.GeographicLatitude](https://developer.roblox.com/en-us/api-reference/property/Lighting/GeographicLatitude) properties.
*
* A variant of this function exists for obtaining the direction of the moon, [Lighting:GetMoonDirection](https://developer.roblox.com/en-us/api-reference/function/Lighting/GetMoonDirection).
*/
GetSunDirection(this: Lighting): Vector3;
/**
* Sets [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay) and [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) to the given number of minutes after midnight.
*
* How can I make a day / night script?
* ------------------------------------
*
* SetMinutesAfterMidnight allows a numerical value to be used, for example in a day/night cycle [Script](https://developer.roblox.com/en-us/api-reference/class/Script), without the need to convert to a string in the format required by [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay). It also allows values greater than 24 hours to be given that correspond to times in the next day. See the code snippets below for an example.
*
* Using [Lighting.TimeOfDay](https://developer.roblox.com/en-us/api-reference/property/Lighting/TimeOfDay) requires the time to be normalized and a string formatted:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local seconds = minutesNormalised \* 60
* local hours = string.format("%02.f", math.floor(seconds/3600))
* local mins = string.format("%02.f", math.floor(seconds/60 - (hours\*60)))
* local secs = string.format("%02.f", math.floor(seconds - hours\*3600 - mins \*60))
* local timeString = hours..":"..mins..":"..secs
*
* Lighting.TimeOfDay = timeString
*
* wait()
* end
*
* Using [Lighting.ClockTime](https://developer.roblox.com/en-us/api-reference/property/Lighting/ClockTime) requires the time to be normalized:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* local minutesNormalised = minutesAfterMidnight % (60 \* 24)
* local hours = minutesNormalised / 60
*
* Lighting.ClockTime = hours
*
* wait()
* end
*
* Using [Lighting:SetMinutesAfterMidnight](https://developer.roblox.com/en-us/api-reference/function/Lighting/SetMinutesAfterMidnight) requires no extra processing:
*
* minutesAfterMidnight = 0
* while true do
* minutesAfterMidnight = minutesAfterMidnight + 1
*
* Lighting:SetMinutesAfterMidnight(minutesAfterMidnight)
*
* wait()
* end
*/
SetMinutesAfterMidnight(this: Lighting, minutes: number): void;
/**
* This event fires when a [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) property is changed or a [Sky](https://developer.roblox.com/en-us/api-reference/class/Sky) is added or removed from [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting).
*
* Although this event fires when most properties of [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) are changed, developers should be aware of the few exceptions:
*
* * Changing [Lighting.GlobalShadows](https://developer.roblox.com/en-us/api-reference/property/Lighting/GlobalShadows) will not fire this event
* * The fog properties, [Lighting.FogColor](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogColor), [Lighting.FogStart](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogStart) and [Lighting.FogEnd](https://developer.roblox.com/en-us/api-reference/property/Lighting/FogEnd) will not fire this event
*
* In cases where this behavior is not desired, the [Instance.Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) event or [Instance:GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal) function can be used.
*/
readonly LightingChanged: RBXScriptSignal<(skyChanged: boolean) => void>;
}
interface LiveScriptingService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LiveScriptingService: unique symbol;
}
/** LocalizationService is the service responsible for handling automated translation.
*
* It is used as a storage for [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) objects used by automatic text replacement.
*
* LocalizationService will only use its child LocalizationTables for automatic text replacement unless [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable) is specified on a GUI object or its ancestors.
*/
interface LocalizationService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LocalizationService: unique symbol;
/**
* This property shows the locale id used for the localization of core and internal features such as [CoreGui](https://developer.roblox.com/en-us/api-reference/class/CoreGui) and [CoreScripts](https://developer.roblox.com/en-us/api-reference/class/CoreScript).
*
* This will return a string with the two letter code (for example, “en-us”) for the locale.
*
* Tags: NotReplicated
*/
readonly RobloxLocaleId: string;
/**
* This property shows the locale id that the local player has set for their operating system.
*
* This will return a string with the two letter code (for example, “en-us”) for the locale.
*
* Tags: NotReplicated
*/
readonly SystemLocaleId: string;
/**
* Returns a list of [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) objects used for localizing CoreScripts.
*/
GetCorescriptLocalizations(this: LocalizationService): Array;
/**
* Returns an `Array`, where each element of the returned `Array` is itself an `Array` of entries in the same format as described in [LocalizationTable:GetEntries](https://developer.roblox.com/en-us/api-reference/function/LocalizationTable/GetEntries). The order of the elements in the returned `Array` is the same order that the [LocalizationTables](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) will be searched through to attempt autotranslation for the provided [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance). The entry elements within a particular [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) are returned in an unspecified order.
*
* This function returns entries regardless of whether the object is a [GuiBase2d](https://developer.roblox.com/en-us/api-reference/class/GuiBase2d) with [GuiBase2d.AutoLocalize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AutoLocalize) enabled. An object that is a [GuiBase2d](https://developer.roblox.com/en-us/api-reference/class/GuiBase2d) will not actually be autotranslated unless [GuiBase2d.AutoLocalize](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/AutoLocalize) is enabled.
*
* The ordering of the tables is as follows:
*
* * First, it looks for the earliest [GuiBase2d](https://developer.roblox.com/en-us/api-reference/class/GuiBase2d) ancestor of the object (including the provided object) that has a [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable). Tables then append in the same order as described in [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable) by going up through the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) ancestors of that [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable). If no such [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable) is found, no tables append in this step. If `instance` is `nil`, no tables append in this step.
* * Next, tables from the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) hierarchy under [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) append. For each child [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) of [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService), it appends tables going up from the lowest descendant [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) of the tables parented to the service, all the way up to the children of the service. If there are no
* children of [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) that are [LocalizationTables](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable), then no tables append in this step.
* * Finally, the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) appends to the array. If there is no cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable), or the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) has not yet loaded, then no table appends in this step.
*
* This function does not yield. It will not wait until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) has loaded.
*/
GetTableEntries(this: LocalizationService, instance?: Instance): unknown;
/**
* This function takes a player as an argument and returns a [Translator](https://developer.roblox.com/en-us/api-reference/class/Translator) instance which can be used to perform translations for that locale if any are available. The entries used for localization are the entries provided by the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) hierarchy under [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) as well as the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable), if it is available and already loaded. This will be the same set of entries returned by `LocalizationService/GetTableEntries(nil)`.
*
* This function does not yield. It will not wait until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) has loaded.
*
* See also
* --------
*
* * [LocalizationService:GetTranslatorForPlayerAsync](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForPlayerAsync) has the same functionality as this function, except that it yields until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) has been loaded.
* * [LocalizationService:GetTranslatorForLocaleAsync](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForLocaleAsync), returns a Translator to be used for translations using the provided locale.
*/
GetTranslatorForPlayer(this: LocalizationService, player: Player): Translator;
/**
* Returns a country/region code string according to player's client IP geolocation. The supported country/region codes are as follows:
*
* Code
*
* Country/Region
*
* US
*
* United States
*
* GB
*
* United Kingdom
*
* CA
*
* Canada
*
* AF
*
* Afghanistan
*
* AX
*
* Aland Islands
*
* AL
*
* Albania
*
* DZ
*
* Algeria
*
* AS
*
* American Samoa
*
* AD
*
* Andorra
*
* AO
*
* Angola
*
* AI
*
* Anguilla
*
* AQ
*
* Antarctica
*
* AG
*
* Antigua and Barbuda
*
* AR
*
* Argentina
*
* AM
*
* Armenia
*
* AW
*
* Aruba
*
* AU
*
* Australia
*
* AT
*
* Austria
*
* AZ
*
* Azerbaijan
*
* BS
*
* Bahamas
*
* BH
*
* Bahrain
*
* BD
*
* Bangladesh
*
* BB
*
* Barbados
*
* BY
*
* Belarus
*
* BE
*
* Belgium
*
* BZ
*
* Belize
*
* BJ
*
* Benin
*
* BM
*
* Bermuda
*
* BT
*
* Bhutan
*
* BO
*
* Bolivia
*
* BQ
*
* Bonaire, Saint Eustatius and Saba
*
* BA
*
* Bosnia and Herzegovina
*
* BW
*
* Botswana
*
* BV
*
* Bouvet Island
*
* BR
*
* Brazil
*
* IO
*
* British Indian Ocean Territory
*
* BN
*
* Brunei Darussalam
*
* BG
*
* Bulgaria
*
* BF
*
* Burkina Faso
*
* BI
*
* Burundi
*
* KH
*
* Cambodia
*
* CM
*
* Cameroon
*
* CV
*
* Cape Verde
*
* KY
*
* Cayman Islands
*
* CF
*
* Central African Republic
*
* TD
*
* Chad
*
* CL
*
* Chile
*
* CN
*
* China
*
* CX
*
* Christmas Island
*
* CC
*
* Cocos Islands
*
* CO
*
* Colombia
*
* KM
*
* Comoros
*
* CG
*
* Congo
*
* CD
*
* Congo (DRC)
*
* CK
*
* Cook Islands
*
* CR
*
* Costa Rica
*
* CI
*
* Ivory Coast
*
* HR
*
* Croatia
*
* CW
*
* Curaçao
*
* CY
*
* Cyprus
*
* CZ
*
* Czech Republic
*
* DK
*
* Denmark
*
* DJ
*
* Djibouti
*
* DM
*
* Dominica
*
* DO
*
* Dominican Republic
*
* EC
*
* Ecuador
*
* EG
*
* Egypt
*
* SV
*
* El Salvador
*
* GQ
*
* Equatorial Guinea
*
* ER
*
* Eritrea
*
* EE
*
* Estonia
*
* ET
*
* Ethiopia
*
* FK
*
* Falkland Islands (Malvinas)
*
* FO
*
* Faroe Islands
*
* FJ
*
* Fiji
*
* FI
*
* Finland
*
* FR
*
* France
*
* GF
*
* French Guiana
*
* PF
*
* French Polynesia
*
* TF
*
* French Southern Territories
*
* GA
*
* Gabon
*
* GM
*
* Gambia
*
* GE
*
* Georgia
*
* DE
*
* Germany
*
* Code
*
* Country/Region
*
* GH
*
* Ghana
*
* GI
*
* Gibraltar
*
* GR
*
* Greece
*
* GL
*
* Greenland
*
* GD
*
* Grenada
*
* GP
*
* Guadeloupe
*
* GU
*
* Guam
*
* GT
*
* Guatemala
*
* GG
*
* Guernsey
*
* GN
*
* Guinea
*
* GW
*
* Guinea-Bissau
*
* GY
*
* Guyana
*
* HT
*
* Haiti
*
* HM
*
* Heard Island and the McDonald Islands
*
* VA
*
* Holy See
*
* HN
*
* Honduras
*
* HK
*
* Hong Kong
*
* HU
*
* Hungary
*
* IS
*
* Iceland
*
* IN
*
* India
*
* ID
*
* Indonesia
*
* IQ
*
* Iraq
*
* IE
*
* Ireland
*
* IM
*
* Isle of Man
*
* IL
*
* Israel
*
* IT
*
* Italy
*
* JM
*
* Jamaica
*
* JP
*
* Japan
*
* JE
*
* Jersey
*
* JO
*
* Jordan
*
* KZ
*
* Kazakhstan
*
* KE
*
* Kenya
*
* KI
*
* Kiribati
*
* KR
*
* Korea
*
* KW
*
* Kuwait
*
* KG
*
* Kyrgyzstan
*
* LA
*
* Laos
*
* LV
*
* Latvia
*
* LB
*
* Lebanon
*
* LS
*
* Lesotho
*
* LR
*
* Liberia
*
* LY
*
* Libya
*
* LI
*
* Liechtenstein
*
* LT
*
* Lithuania
*
* LU
*
* Luxembourg
*
* MO
*
* Macao
*
* MK
*
* Macedonia
*
* MG
*
* Madagascar
*
* MW
*
* Malawi
*
* MY
*
* Malaysia
*
* MV
*
* Maldives
*
* ML
*
* Mali
*
* MT
*
* Malta
*
* MH
*
* Marshall Islands
*
* MQ
*
* Martinique
*
* MR
*
* Mauritania
*
* MU
*
* Mauritius
*
* YT
*
* Mayotte
*
* MX
*
* Mexico
*
* FM
*
* Micronesia
*
* MD
*
* Moldova
*
* MC
*
* Monaco
*
* MN
*
* Mongolia
*
* ME
*
* Montenegro
*
* MS
*
* Montserrat
*
* MA
*
* Morocco
*
* MZ
*
* Mozambique
*
* MM
*
* Myanmar
*
* NA
*
* Namibia
*
* NR
*
* Nauru
*
* NP
*
* Nepal
*
* NL
*
* Netherlands
*
* AN
*
* Netherlands Antilles
*
* NC
*
* New Caledonia
*
* NZ
*
* New Zealand
*
* NI
*
* Nicaragua
*
* NE
*
* Niger
*
* NG
*
* Nigeria
*
* NU
*
* Niue
*
* NF
*
* Norfolk Island
*
* MP
*
* Northern Mariana Islands
*
* NO
*
* Norway
*
* OM
*
* Oman
*
* Code
*
* Country/Region
*
* PK
*
* Pakistan
*
* PW
*
* Palau
*
* PS
*
* Palestine
*
* PA
*
* Panama
*
* PG
*
* Papua New Guinea
*
* PY
*
* Paraguay
*
* PE
*
* Peru
*
* PH
*
* Philippines
*
* PN
*
* Pitcairn Islands
*
* PL
*
* Poland
*
* PT
*
* Portugal
*
* PR
*
* Puerto Rico
*
* QA
*
* Qatar
*
* RE
*
* Reunion
*
* RO
*
* Romania
*
* RU
*
* Russian Federation
*
* RW
*
* Rwanda
*
* BL
*
* Saint Barthelemy
*
* SH
*
* Saint Helena, Ascension and Tristan da Cunha
*
* KN
*
* Saint Kitts and Nevis
*
* LC
*
* Saint Lucia
*
* MF
*
* Saint Martin
*
* PM
*
* Saint Pierre and Miquelon
*
* VC
*
* Saint Vincent and the Grenadines
*
* WS
*
* Samoa
*
* SM
*
* San Marino
*
* ST
*
* Sao Tome and Principe
*
* SA
*
* Saudi Arabia
*
* SN
*
* Senegal
*
* RS
*
* Serbia
*
* SC
*
* Seychelles
*
* SL
*
* Sierra Leone
*
* SG
*
* Singapore
*
* SX
*
* Sint Maarten
*
* SK
*
* Slovakia
*
* SI
*
* Slovenia
*
* SB
*
* Solomon Islands
*
* SO
*
* Somalia
*
* ZA
*
* South Africa
*
* GS
*
* South Georgia and the South Sandwich Islands
*
* SS
*
* South Sudan
*
* ES
*
* Spain
*
* LK
*
* Sri Lanka
*
* SR
*
* Suriname
*
* SJ
*
* Svalbard and Jan Mayen
*
* SZ
*
* Swaziland
*
* SE
*
* Sweden
*
* CH
*
* Switzerland
*
* TW
*
* Taiwan
*
* TJ
*
* Tajikistan
*
* TZ
*
* Tanzania
*
* TH
*
* Thailand
*
* TL
*
* Timor-leste
*
* TG
*
* Togo
*
* TK
*
* Tokelau
*
* TO
*
* Tonga
*
* TT
*
* Trinidad and Tobago
*
* TN
*
* Tunisia
*
* TR
*
* Turkey
*
* TM
*
* Turkmenistan
*
* TC
*
* Turks and Caicos Islands
*
* TV
*
* Tuvalu
*
* UG
*
* Uganda
*
* UA
*
* Ukraine
*
* AE
*
* United Arab Emirates
*
* UM
*
* United States Minor Outlying Islands
*
* UY
*
* Uruguay
*
* UZ
*
* Uzbekistan
*
* VU
*
* Vanuatu
*
* VE
*
* Venezuela
*
* VN
*
* Vietnam
*
* VG
*
* Virgin Islands (British)
*
* VI
*
* Virgin Islands (US)
*
* WF
*
* Wallis and Futuna
*
* EH
*
* Western Sahara
*
* YE
*
* Yemen
*
* ZM
*
* Zambia
*
* ZW
*
* Zimbabwe
*
* CU
*
* Cuba
*
* IR
*
* Iran
*
* SY
*
* Syria
*
* KP
*
* North Korea
*
* See also
* --------
*
* * [PolicyService:GetPolicyInfoForPlayerAsync](https://developer.roblox.com/en-us/api-reference/function/PolicyService/GetPolicyInfoForPlayerAsync), returns policy information about a player which is based on geolocation, age group and platform
*
* Tags: Yields
*/
GetCountryRegionForPlayerAsync(this: LocalizationService, player: Player): string;
/**
* This function takes a locale code as an argument and yields until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) for that locale has been loaded, if available. It then returns a [Translator](https://developer.roblox.com/en-us/api-reference/class/Translator) object which can be used to perform translations for that locale if any are available.
* The entries used for localization are the entries provided by the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) hierarchy under [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) as well as the cloud table (if available). This will be the same set of entries returned by `LocalizationService/GetTableEntries(nil)`.
*
* This function can error and thus should be wrapped in a [pcall](https://developer.roblox.com/en-us/articles/built-in-functions-&-variables-—-lua).
*
* See also
* --------
*
* * [LocalizationService:GetTranslatorForPlayer](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForPlayer) gets the translator corresponding to the locale of the provided player. This function is deprecated and should not be used in new work.
* * [LocalizationService:GetTranslatorForPlayerAsync](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForPlayerAsync) yields until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) for the locale of the provided player has loaded and then gets the translator corresponding to the locale of the provided player.
*
* Tags: Yields
*/
GetTranslatorForLocaleAsync(this: LocalizationService, locale: string): Translator;
/**
* This function takes a player as an argument and yields until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) for that player's locale has been loaded, if available. It then returns a [Translator](https://developer.roblox.com/en-us/api-reference/class/Translator) object which can be used to perform translations for that locale if any are available.
* The entries used for localization are the entries provided by the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) hierarchy under [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) as well as the cloud table (if available). This will be the same set of entries returned by [GetTableEntries(nil)](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTableEntries).
*
* This function can error and thus should be wrapped in a [pcall](https://developer.roblox.com/en-us/articles/built-in-functions-&-variables-—-lua).
*
* See also
* --------
*
* * [LocalizationService:GetTranslatorForPlayer](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForPlayer), same functionality as this function except that it does not yield and does not wait until the cloud [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) for the player's locale has been loaded. This function is deprecated and should not be used in new work.
* * [LocalizationService:GetTranslatorForLocaleAsync](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetTranslatorForLocaleAsync), returns a Translator to be used for translations using the provided locale.
*
* Tags: Yields
*/
GetTranslatorForPlayerAsync(this: LocalizationService, player: Player): Translator;
}
/** A LocalizationTable is a database of translations. It contains source strings and translations for various languages. It is used with the [Translator](https://developer.roblox.com/en-us/api-reference/class/Translator) and [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) auto-translator system to control text translations in the game.
*
* LocalizationTables are designed to be treated as resources, like a texture or a script. They are not optimized to be modified at runtime. Changing the contents of a table will cause the entire contents of the table to be replicated to all players.
*
*
* LocalizationTable Entries
* -------------------------
*
* Each LocalizationTable contains a set of entries. Each entry contains the translations of the text, along with some special fields:
*
* * **Key** is an optional unique key for fast hash lookups in code. If it is non-empty it must be unique in the table.
* * **Source** is the orignal text in the source language that will be used by the [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService) automatic text replacement system to match GUI text and render a translation instead. The Source field can be filled by the text capture tools, or can be set manually. For key-based lookups the Source value can be used as a translation for [LocalizationTable.SourceLocaleId](https://developer.roblox.com/en-us/api-reference/property/LocalizationTable/SourceLocaleId) if the entry doesn't have a translation for that locale. If Source is empty then the entry will not be used by the automatic replacement system.
* * **Context** is the full Instance name for the object that the text appeared on. Context is used for disambiguation by the automatic text replacement system. When multiple matches for the Source are found, the system will pick the best match by matching backwards from the end of the Context string. There are other more robust ways to handle disambiguation available as well, like using multiple tables with [GuiBase2d.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/GuiBase2d/RootLocalizationTable).
* * **Example** is whatever you want it to be. If the text capture tool guessed some parameters for a string the Example field will contain an example of them used in context.
*
*
* All of these fields are optional, but at least either Key or Source must be non-empty. No two entries can have the same Key, Source, and Context.
*
* The **Source** field and all translation strings must be valid [LocalizationService format strings](https://developer.roblox.com/articles/Format-Strings).
*/
interface LocalizationTable extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LocalizationTable: unique symbol;
/**
* The default IETF tag to use if the ''languageKey'' parameter is excluded from the [LocalizationTable:GetString](https://developer.roblox.com/en-us/api-reference/function/LocalizationTable/GetString) method.
*
* Tags: Hidden, NotReplicated
* @deprecated Use `SourceLocaleId` instead
*/
DevelopmentLanguage: string;
/**
* The object that is being targeted for localization by this table. Localization is applied to it and all of it's descendants.
*
* Tags: Hidden, NotReplicated
* @deprecated Use `RootLocalizationTable` instead
*/
Root: Instance | undefined;
/**
* The Roblox locale of the input key strings for this table, for example “en-us” or “es-es.” This is typically the “development language” of the game. For a Translator that merges multiple LocalizationTable objects, it's the LocaleId of the Default LocalizationTable. Defaults to “en-us”.
*/
SourceLocaleId: string;
/**
* @deprecated Use `GetEntries` instead
*/
GetContents(this: LocalizationTable): string;
/**
* The GetEntries function returns an array of dictionaries contained in a given `/LocalizationTable`, where each dictionary represents an entry of localization data.
*
* To set the entries of a LocalizationTable, you can use [LocalizationTable:SetEntries](https://developer.roblox.com/en-us/api-reference/function/LocalizationTable/SetEntries).
*
* Each dictionary in the array contains the following fields:
*
* Index
*
* Type
*
* Description
*
* ### Key
*
* [string](https://developer.roblox.com/api-reference/lua-docs/string)
*
* A lookup key for this specific entry in the LocalizationTable.
*
* ### Source
*
* [string](https://developer.roblox.com/api-reference/lua-docs/string)
*
* The string used to format the localized string. Used as a lookup if a Key is not provided.
*
* ### Context
*
* [string](https://developer.roblox.com/api-reference/lua-docs/string)
*
* An \`Instance/GetFullName\` path to the object that was used to generate the LocalizationTable. Used as a lookup if a Key is not provided.
*
* ### Example
*
* [string](https://developer.roblox.com/api-reference/lua-docs/string)
*
* The string used to format the localization. Optional.
*
* ### Values
*
* [string](https://developer.roblox.com/api-reference/lua-docs/string)
*
* A dictionary of language translations for this localization entry. The keys of this dictionary are locale ids, and the values are strings that are used to apply localization for the language corresponding to the locale id.
*/
GetEntries(this: LocalizationTable): Array;
/**
* The GetString function returns a translation based on the specified language and key.
* @deprecated Use `GetTranslator` instead
*/
GetString(this: LocalizationTable, targetLocaleId: string, key: string): string;
/**
* Returns a [Translator](https://developer.roblox.com/en-us/api-reference/class/Translator) for entries in this LocalizationTable, in the specified language. The translator will first search in this table and then look in ancestor tables.
*/
GetTranslator(this: LocalizationTable, localeId: string): Translator;
/**
* Removes an entry from the LocalizationTable, using the specified _key_, _source_, and _context_ to narrow down the specific entry to be removed.
*/
RemoveEntry(this: LocalizationTable, key: string, source: string, context: string): void;
/**
* Removes a single language translation from the LocalizationTable, using the provided _key_, _source_, _context_, and _localeId_ to narrow down the specific entry to be removed.
*/
RemoveEntryValue(this: LocalizationTable, key: string, source: string, context: string, localeId: string): void;
/**
* Deprecated in favor of [LocalizationTable:RemoveEntry](https://developer.roblox.com/en-us/api-reference/function/LocalizationTable/RemoveEntry).
*
* Calling RemoveKey is the same as making the following call to RemoveEntry:
*
* LocalizationTable:RemoveEntry(key,"","")
* @deprecated Use `RemoveEntry` instead
*/
RemoveKey(this: LocalizationTable, key: string): void;
/**
* Removes all translations from the LocalizationTable with the specified localeId.
*/
RemoveTargetLocale(this: LocalizationTable, localeId: string): void;
/**
* The SetContents function sets the contents of the LocalizationTable, via the legacy JSON format.
* @deprecated Use `SetEntries` instead
*/
SetContents(this: LocalizationTable, contents: string): void;
/**
* Sets the contents of the LocalizationTable.
*
* The entries parameter should be an array of dictionaries in the same format as the one returned from the [LocalizationTable:GetEntries](https://developer.roblox.com/en-us/api-reference/function/LocalizationTable/GetEntries) function.
*/
SetEntries(this: LocalizationTable, entries: Array): void;
/**
* @deprecated Use `SetEntryValue` instead
*/
SetEntry(this: LocalizationTable, key: string, targetLocaleId: string, text: string): void;
/**
* Sets the **Context** field of a LocalizationTable entry to _newContext_, using the specified _key_, _source_, and _context_ to narrow down the entry that will have this change applied.
*/
SetEntryContext(this: LocalizationTable, key: string, source: string, context: string, newContext: string): void;
/**
* Sets the **Example** field of a LocalizationTable entry to _example_, using the specified _key_, _source_, and _context_ to narrow down the entry that will have this change applied.
*/
SetEntryExample(this: LocalizationTable, key: string, source: string, context: string, example: string): void;
/**
* Sets the **Key** field of a LocalizationTable entry to _newKey_, using the specified _key_, _source_, and _context_ to narrow down the entry that will have this change applied.
*/
SetEntryKey(this: LocalizationTable, key: string, source: string, context: string, newKey: string): void;
/**
* Sets the **Source** field of a LocalizationTable entry to _newSource_, using the specified _key_, _source_, and _context_ to narrow down the entry that will have this change applied.
*/
SetEntrySource(this: LocalizationTable, key: string, source: string, context: string, newSource: string): void;
/**
* Sets the text of the specified localeId in a LocalizationTable entry, using the specified _key_, _source_, and _context_ to narrow down the entry that will have this change applied.
*/
SetEntryValue(this: LocalizationTable, key: string, source: string, context: string, localeId: string, text: string): void;
}
interface CloudLocalizationTable extends LocalizationTable {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CloudLocalizationTable: unique symbol;
}
interface LodDataEntity extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LodDataEntity: unique symbol;
/**
* Tags: Hidden, NotReplicated
*/
EntityLodEnabled: boolean;
}
interface LodDataService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LodDataService: unique symbol;
}
interface LogReporterService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LogReporterService: unique symbol;
}
/** **Unreliable Behavior**
*
* This may have changing, unexpected or unreliable behavior depending on how the game engine logs things. It should not be relied upon for any important game logic.
*
* A service that allows you to read outputted text.
*/
interface LogService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LogService: unique symbol;
ClearOutput(this: LogService): void;
/**
* **Unreliable Behavior**
*
* This may have changing, unexpected or unreliable behavior depending on how the game engine logs things. It should not be relied upon for any important game logic.
*
* Returns a table of tables, each with the message string, message type, and timestamp of a message that the client displays in the output window.
*
* See also
* --------
*
* * [LogService.MessageOut](https://developer.roblox.com/en-us/api-reference/event/LogService/MessageOut) - An event that fires when text is added to the output from the client
*/
GetLogHistory(this: LogService): Array;
/**
* Fires when the client outputs text.
*/
readonly MessageOut: RBXScriptSignal<(message: string, messageType: Enum.MessageType) => void>;
}
/** The base class for all objects which contain Lua code. [Script](https://developer.roblox.com/en-us/api-reference/class/Script), [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript) and [CoreScript](https://developer.roblox.com/en-us/api-reference/class/CoreScript) all inherit from LuaSourceContainer. */
interface LuaSourceContainer extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LuaSourceContainer: unique symbol;
/**
* Tags: Hidden
*/
readonly LockGrantedOrNot: RBXScriptSignal<(granted: boolean) => void>;
/**
* Tags: Hidden
*/
readonly LostLock: RBXScriptSignal<() => void>;
/**
* Tags: Hidden
*/
readonly RequestLock: RBXScriptSignal<() => void>;
}
/** The base class for all script objects which run automatically. */
interface BaseScript extends LuaSourceContainer {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BaseScript: unique symbol;
/**
* Determines whether a [BaseScript](https://developer.roblox.com/en-us/api-reference/class/BaseScript) will run or not.
*
* [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s and [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s, when parented to a valid parent, will run when Disabled is false.
*
* If Disabled is set to true whilst a script is running, the current thread will be terminated.
*
* If Disabled is set to true from false, the script will run again. This means the Disabled property can be toggled to restart a script:
*
* scriptObject.Disabled = false
* scriptObject.Disabled = true
*
* Note, the above code snippet cannot be used within the script itself. This is because once the script is disabled the thread will terminate.
*/
Disabled: boolean;
/**
* Tags: NotReplicated
*/
Enabled: boolean;
/**
* The content ID of an uploaded script. When set binds the uploaded code to the script's [Script.Source](https://developer.roblox.com/en-us/api-reference/property/Script/Source).
*
* By default, this property is set to _'\[Embedded\]'_. This means the source of the script is not linked to an upload script and is instead written in the script.
*
* script.LinkedSource = "http://www.roblox.com/asset/?id=1014476" -- link source
*
* Developers should remove a linked source via the properties window, rather than setting the property to _'\[Embedded\]'_.
*
* For the LinkedSource property for [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript)s, please see [ModuleScript.LinkedSource](https://developer.roblox.com/en-us/api-reference/property/ModuleScript/LinkedSource).
*/
LinkedSource: string;
RunContext: Enum.RunContext;
}
/** A Script is a type of Lua code container that will run its contents on the server. By default, Scripts have `print("Hello, world")` as their contents. The instant that the following conditions are met, a Script's Lua code is run in a new thread:
*
* * Disabled property is false
* * The Script object is a descendant of the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) or
* [ServerScriptService](https://developer.roblox.com/en-us/api-reference/class/ServerScriptService)
*
* The Script will continue to run until the above conditions are not met, it terminates or it raises an error (unless that error is raised by a function connected to some event that is firing). Additionally, the thread will be stopped if the Script or one of its ancestors is destroyed. A script will continue to run even if the [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) property is set to nil (and the Script is not destroyed).
*
* It has access to server-side objects, properties and events. For example, Scripts can award badges to players using [BadgeService](https://developer.roblox.com/en-us/api-reference/class/BadgeService), while a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) on the client cannot. Actions taken by LocalScripts that are not replicated (due to [Workspace.FilteringEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/FilteringEnabled)) will not be visible to Scripts.
*/
interface Script extends BaseScript {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Script: unique symbol;
}
/** A LocalScript is a Lua source container that runs Lua code on a client connected to a Roblox server. They are used to access client-only objects, such as the player's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera). For code run through LocalScripts, the LocalPlayer property of the [Players](https://developer.roblox.com/en-us/api-reference/class/Players) service will return the player whose client is running the script.
*
* A LocalScript will **only** run Lua code if it is a descendant of one of the following objects:
*
* * A Player's [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack), such as a child of a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool)
* * A Player's [character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) model
* * A Player's [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui)
* * A Player's [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts).
* * The [ReplicatedFirst](https://developer.roblox.com/en-us/api-reference/class/ReplicatedFirst) service
*/
interface LocalScript extends Script {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LocalScript: unique symbol;
}
/** A ModuleScript is a type of Lua source container that runs once and must return exactly one value. This value is then returned by a call to `require` given the ModuleScript as the only argument. ModuleScripts run once and only once per Lua environment and return the exact same value for subsequent calls to `require`.
*
* ModuleScripts are essential objects for adhering to the don't-repeat-yourself (DRY) principle. When you write a function, write it only once and use it everywhere. Having multiple copies of a function is disastrous when you need to change that behavior. So, you should define functions or groups of functions in ModuleScripts and have your Scripts and LocalScripts call `require` on your ModuleScripts. Keep your code organized!
*
* It's important to know that return values from ModuleScripts are independent with regards to LocalScripts and Scripts, and other environments like the Command Bar. Using `require` on a ModuleScript in a LocalScript will run the code on the client, even if a Script did so already on the server. Similarly, in Roblox Studio, using `require` on a ModuleScript in the hierarchy with the Command Bar will give a similar behavior. So, be careful if you are using a ModuleScript on the client and server at the same time, or debugging it within Studio.
*
* Note that the first call to `require` on a ModuleScript will not yield (halt) unless the ModuleScript yields (e.g. calls `wait`). The current thread that called `require` will yield until a ModuleScript returns a value. A run time error is generated if this doesn't happen. If a ModuleScript is attempting to `require` another ModuleScript that in turn tries to `require`s it, the **thread will hang and never halt (cyclic `require` calls do not generate errors).** Be mindful of your module dependencies in large projects!
*
* If a ModuleScript object is has its Name property set to 'MainModule' and is uploaded to Roblox as a model to your account, Scripts can use `require` with the uploaded model's AssetId instead. This allows you to create private modules on your Roblox account!
*/
interface ModuleScript extends LuaSourceContainer {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ModuleScript: unique symbol;
/**
* Used to store a URL that points to an online script source. Binds the online code to the script's [Script.Source](https://developer.roblox.com/en-us/api-reference/property/Script/Source).
*/
LinkedSource: string;
}
interface LuauScriptAnalyzerService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_LuauScriptAnalyzerService: unique symbol;
}
interface MarkerCurve extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MarkerCurve: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Length: number;
GetMarkerAtIndex(this: MarkerCurve, index: number): object;
GetMarkers(this: MarkerCurve): unknown;
InsertMarkerAtTime(this: MarkerCurve, time: number, marker: string): unknown;
RemoveMarkerAtIndex(this: MarkerCurve, startingIndex: number, count?: number): number;
}
/** MarketplaceService is the game service that is responsible for in-game transactions.
*
* The most notable functions are [PromptProductPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptProductPurchase) and [PromptPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptPurchase), as well as the callback [ProcessReceipt](https://developer.roblox.com/en-us/api-reference/property/MarketplaceService/ProcessReceipt) which must be well defined so that transactions do not fail.
*
* MarketplaceService also has functions that fetch information about developer products ([GetProductInfo](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/GetProductInfo) and [GetDeveloperProductsAsync](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/GetDeveloperProductsAsync)), game passes ([UserOwnsGamePassAsync](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/UserOwnsGamePassAsync)), and other assets ([PlayerOwnsAsset](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PlayerOwnsAsset)).
*
* Monetization
* ------------
*
* Learning to use MarketplaceService is the first step towards learning to monetize a game on Roblox. Another important game service regarding monetization is [DataStoreService](https://developer.roblox.com/en-us/api-reference/class/DataStoreService) which is responsible for saving and loading data like that of purchases.
*
* See also
* --------
*
* * [Monetization Guides](https://developer.roblox.com/learn-roblox/monetization), learning materials related to monetizing your game
*/
interface MarketplaceService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MarketplaceService: unique symbol;
/**
* Used to prompt a user to purchase a bundle with the given bundleId
*/
PromptBundlePurchase(this: MarketplaceService, player: Player, bundleId: number): void;
/**
* Used to prompt a user to purchase a game pass with the given assetId.
*/
PromptGamePassPurchase(this: MarketplaceService, player: Player, gamePassId: number): void;
/**
* Used to prompt a user to purchase Premium. If the user is already premium, the user will receive an error message “You are already subscribed to Roblox Premium! Please try again.”
*
* 
*
* To learn more about and incorporating Premium into your game, and monetizing your game with the Premium Payout system, take a look at [this](https://developer.roblox.com/articles/premium-payouts) article.
*
* See also
* --------
*
* * [MarketplaceService.PromptPremiumPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptPremiumPurchaseFinished), fires when the Premium purchase UI closes
* * [Players.PlayerMembershipChanged](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerMembershipChanged), fires when the game server recognizes that a player's membership has changed
*/
PromptPremiumPurchase(this: MarketplaceService, player: Player): void;
/**
* Used to prompt a user to purchase a product with the given product id.
*/
PromptProductPurchase(
this: MarketplaceService,
player: Player,
productId: number,
equipIfPurchased?: boolean,
currencyType?: CastsToEnum,
): void;
/**
* PromptPurchase is used to prompt a player to purchase an item with the given `assetId`. Below is a screenshot of the purchase dialogue that appears when this function is called.
*
* 
*
* The above dialogue was triggered using the following:
*
* game:GetService("MarketplaceService"):PromptPurchase(game.Players.LocalPlayer, 4367427794)
*
* For game passes, use [MarketplaceService:PromptGamePassPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptGamePassPurchase).
*/
PromptPurchase(
this: MarketplaceService,
player: Player,
assetId: number,
equipIfPurchased?: boolean,
currencyType?: CastsToEnum,
): void;
PromptSubscriptionPurchase(this: MarketplaceService, user: Player, subscriptionId: string): void;
/**
* Returns a [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) object which contains information for all of the current game's developer products.
*
* Tags: Yields
*/
GetDeveloperProductsAsync(this: MarketplaceService): StandardPages<{
Description: string;
PriceInRobux: number;
ProductId: number;
IconImageAssetId: number;
Name: string;
}>;
/**
* This function provides information about an asset, developer product or game pass given its **assetId** and the [InfoType](https://developer.roblox.com/en-us/api-reference/enum/InfoType) (Asset, Product or GamePass respectively).
*
* Information about the queried item is provided in a dictionary with the following keys. Note that not all information is provided or necessarily relevant for the kind of object you are querying.
*
* Name
*
* Type
*
* Description
*
* `Name`
*
* string
*
* The name shown on the asset's page
*
* `Description`
*
* string
*
* The description as shown on the asset's page; can be nil if blank
*
* `PriceInRobux`
*
* number
*
* The cost of purchasing the asset using Robux
*
* `Created`
*
* timestamp[](#timestamp)
*
* Timestamp of when the asset was created, e.g. `2018-08-01T17:55:11.98Z`[](#timestamp)
*
* `Updated`
*
* timestamp[](#timestamp)
*
* Timestamp of when the asset was last updated by its creator, e.g. `2018-08-01T17:55:11.98Z`
*
* `ContentRatingTypeId`
*
* number
*
* Indicates whether the item is marked as 13+ in catalog
*
* `MinimumMembershipLevel`
*
* number
*
* The minimum subscription level necessary to purchase the item
*
* `IsPublicDomain`
*
* boolean
*
* Describes whether the asset can be taken for free
*
* **Creator Information**
*
* `Creator`
*
* Dictionary
*
* A table of information describing the creator of the asset (see following lines)
*
* `Creator.CreatorType`
*
* string
*
* Either `User` or `Group`
*
* `Creator.CreatorTargetId`
*
* number
*
* The ID of the creator user or group
*
* `Creator.Name`
*
* string
*
* The name/username of the creator
*
* `Creator.Id`
*
* number
*
* (Use CreatorTargetId instead)
*
* **Assets**
*
* `AssetId`
*
* number
*
* If InfoType was Asset, this is the ID of the given asset.
*
* `AssetTypeId`
*
* number
*
* The type of asset (e.g. place, model, shirt)[\*](#assetTypes)
*
* `IsForSale`
*
* boolean
*
* Describes whether the asset is purchasable
*
* `IsLimited`
*
* boolean
*
* Describes whether the asset is a "limited item" that is no longer (if ever) sold
*
* `IsLimitedUnique`
*
* boolean
*
* Describes whether the asset is a "limited unique" ("Limited U") item that only has a fixed number sold
*
* `IsNew`
*
* boolean
*
* Describes whether the asset is marked as "new" in the catalog
*
* `Remaining`
*
* number
*
* The remaining number of items a limited unique item may be sold
*
* `Sales`
*
* number
*
* The number of items the asset has been sold
*
* `SaleAvailabilityLocations`
*
* Dictionary
*
* The item's [ProductLocationRestriction](https://developer.roblox.com/en-us/api-reference/enum/ProductLocationRestriction) or sale location setting (e.g. anywhere, Shop only).
*
* `CanBeSoldInThisGame`
*
* boolean
*
* Describes whether the asset is purchasable in the current experience.
*
* **Developer Products and Game Passes**
*
* `ProductId`
*
* number
*
* If the InfoType was Product, this is the product ID
*
* `IconImageAssetId`
*
* number
*
* This is the asset ID of the product/pass icon, or 0 if there isn't one
*
* \* See [Asset Types](https://developer.roblox.com/en-us/articles/asset-types) for the asset type ID numbers.
* †Timestamps are formatted using [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601)
*
* Possible Errors
* ---------------
*
* If no such item exists with the given ID, this function will throw an error:
*
* * For developer products, the error is:
*
* > _MarketplaceService:getProductInfo() failed because rawProductInfo was empty_
*
* * For game passes and assets, the error is:
*
* > _MarketplaceService:getProductInfo() failed because HTTP 0 (HTTP 400 (HTTP/1.1 400 BadRequest))_
*
* See also
* --------
*
* * [Monetization Guides](https://developer.roblox.com/learn-roblox/monetization), learning materials related to monetizing your game
*
* Tags: Yields
*/
GetProductInfo(this: MarketplaceService, id: number): AssetProductInfo;
GetProductInfo(this: MarketplaceService, id: number, infoType: CastsToEnum): AssetProductInfo;
GetProductInfo(this: MarketplaceService, id: number, infoType: CastsToEnum): BundleInfo;
GetProductInfo(
this: MarketplaceService,
id: number,
infoType: CastsToEnum,
): GamePassProductInfo;
GetProductInfo(
this: MarketplaceService,
id: number,
infoType: CastsToEnum,
): DeveloperProductInfo;
GetProductInfo(
this: MarketplaceService,
id: number,
infoType: CastsToEnum,
): SubscriptionProductInfo;
GetProductInfo(
this: MarketplaceService,
id: number,
infoType?: CastsToEnum,
): AssetProductInfo | BundleInfo | GamePassProductInfo | DeveloperProductInfo | SubscriptionProductInfo;
/**
* Tags: Yields
*/
GetSubscriptionProductInfoAsync(this: MarketplaceService, subscriptionId: string): object;
/**
* Tags: Yields
*/
GetUserSubscriptionPaymentHistoryAsync(this: MarketplaceService, user: Player, subscriptionId: string): unknown;
/**
* Tags: Yields
*/
GetUserSubscriptionStatusAsync(this: MarketplaceService, user: Player, subscriptionId: string): object;
/**
* Returns whether the inventory of given [Player](https://developer.roblox.com/en-us/api-reference/class/Player) contains an asset, given the ID. This method can query for hats, models, sounds, etc. This function takes a small amount of time to send a request the Roblox website.
*
* In the case that a query fails, this function will throw an error. Therefore, it is recommended to wrap calls to this function in `pcall`.
*
* * This method should not be used for **game passes**, since they use a separate ID system. Legacy game passes that still depend on an asset ID should use [GamePassService:PlayerHasPass](https://developer.roblox.com/en-us/api-reference/function/GamePassService/PlayerHasPass) instead of this method.
* * This method cannot be used to check for **developer products** since they can be purchased multiple times but not owned themselves. Use a [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) to save when a developer has bought a developer product instead.
*
* Tags: Yields
*/
PlayerOwnsAsset(this: MarketplaceService, player: Player, assetId: number): boolean;
/**
* Tags: Yields
*/
PlayerOwnsBundle(this: MarketplaceService, player: Player, bundleId: number): boolean;
/**
* UserOwnsGamePassAsync returns true if the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) with the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) owns the game pass with the given **game pass ID** (not to be confused with asset ID).
*
* Caching Behavior
* ----------------
*
* Results of this function are remembered so that repeated calls will return quicker. This function will always return true if the player owns the game pass upon first entering a server after having purchased the game pass. If the game pass is purchased in-game (through [PromptGamePassPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptGamePassPurchase)), this function may return false due to the caching behavior. Conversely, should the player delete the game pass from their inventory, this function may return true despite the player not owning the game pass.
*
* History
* -------
*
* Previously, querying player ownership of game passes required the use of the now-deprecated [GamePassService:PlayerHasPass](https://developer.roblox.com/en-us/api-reference/function/GamePassService/PlayerHasPass) function. This was changed in April 2018 when [game passes received their own ID system](https://devforum.roblox.com/t/live-changes-to-game-passes/116918).
*
* On [Release 350](https://developer.roblox.com/resources/release-note/Release-Note-for-350) (August 2018), this function was changed so that the result is cached. Previously, it made a request every time it was called.
*
* Tags: Yields
*/
UserOwnsGamePassAsync(this: MarketplaceService, userId: number, gamePassId: number): boolean;
readonly PromptBundlePurchaseFinished: RBXScriptSignal<(player: Player, bundleId: number, wasPurchased: boolean) => void>;
/**
* This event fires when a purchase dialogue of a game pass is closed. This fires right as the dialogue closes when the player presses “Cancel” at the prompt, or “OK” at the success/error message.
*
* * For **developer product** purchase prompts, connect to
* [MarketplaceService.PromptProductPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptProductPurchaseFinished). In order to
* process such purchases you need to set the
* [ProcessReceipt](https://developer.roblox.com/en-us/api-reference/property/MarketplaceService/ProcessReceipt) callback in a
* single script.
*
* * For **affiliate gear sales** or other assets, use
* [MarketplaceService.PromptPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptPurchaseFinished).
*/
readonly PromptGamePassPurchaseFinished: RBXScriptSignal<(player: Player, gamePassId: number, wasPurchased: boolean) => void>;
/**
* This event fires when the Premium purchase modal closes, specifically when the player presses “Cancel” at the prompt, “OK” at the error message, or after the payment UI closes.
*
* To learn more about and incorporating Premium into your game, and monetizing your game with the Premium Payouts system, take a look at [this](https://developer.roblox.com/articles/premium-payouts) article.
*
* See also
* --------
*
* * [MarketplaceService:PromptPremiumPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptPremiumPurchase), used to prompt a user to purchase Premium
* * [Players.PlayerMembershipChanged](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerMembershipChanged), fires when the game server recognizes that a player's membership has changed
*/
readonly PromptPremiumPurchaseFinished: RBXScriptSignal<() => void>;
/**
* This event fires when a purchase dialogue of a developer product is closed. This fires right as the dialogue closes when the player presses “Cancel” at the prompt, or “OK” at the success/error message. **Do not use this event to process developer product purchases!** For this, you must set the [ProcessReceipt](https://developer.roblox.com/en-us/api-reference/property/MarketplaceService/ProcessReceipt) callback once.
*
* * For **game passes**, use [MarketplaceService.PromptGamePassPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptGamePassPurchaseFinished).
* * For **affiliate gear sales** or other assets, use [MarketplaceService.PromptPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptPurchaseFinished).
*
* Unlike the similarly-named events above, this event fires with a [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) and not a reference to the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) object. Despite this event's deprecation, it is currently the only way to detect when a developer product's purchase dialog is closed.
*
* Example
* -------
*
* Below is a screenshot of a game pass purchase prompt. The function in the code sample runs immediately after the player presses “Cancel” or after the player buys the developer product then presses “OK”. Should there be an issue with the purchase, the event also fires.
*
* 
*
* local MarketplaceService = game:GetService("MarketplaceService")
*
* MarketplaceService.PromptProductPurchaseFinished:Connect(function (...)
* -- Print all the details of the prompt, for example:
* -- PromptProductPurchaseFinished 269323 327064551 true
* print("PromptProductPurchaseFinished", ...)
* end)
*/
readonly PromptProductPurchaseFinished: RBXScriptSignal<(userId: number, productId: number, isPurchased: boolean) => void>;
/**
* For new game passes using a \*Game Pass ID\*, use \`MarketplaceService/PromptGamePassPurchaseFinished\`
*
* PromptPurchaseFinished fires when a purchase dialogue of an affiliate gear sale or other asset is closed. This fires right as the dialogue closes when the player presses “Cancel” at the prompt, or “OK” at the success/error message.
*
* * For **game passes**, use [MarketplaceService.PromptGamePassPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptGamePassPurchaseFinished).
* * For **developer product** purchase prompts, connect to [MarketplaceService.PromptProductPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptProductPurchaseFinished). In order to process such purchases you need to set the [ProcessReceipt](https://developer.roblox.com/en-us/api-reference/property/MarketplaceService/ProcessReceipt) callback in a single script.
*
* Example
* -------
*
* Below is a screenshot of an affiliate gear sale prompt. The function in the code sample runs immediately after the player presses “Cancel” or after the user buys the item then presses “OK”. Should there be an issue with the purchase, the event also fires.
* 
*
* local MarketplaceService = game:GetService("MarketplaceService")
*
* MarketplaceService.PromptPurchaseFinished:connect(function (...)
* -- Print all the details of the prompt, for example:
* -- PromptPurchaseFinished PlayerName 11377306 true
* print("PromptPurchaseFinished", ...)
* end)
*/
readonly PromptPurchaseFinished: RBXScriptSignal<(player: Player, assetId: number, isPurchased: boolean) => void>;
readonly PromptSubscriptionPurchaseFinished: RBXScriptSignal<(user: Player, subscriptionId: string, didTryPurchasing: boolean) => void>;
ProcessReceipt: ((receiptInfo: ReceiptInfo) => Enum.ProductPurchaseDecision) | undefined;
}
interface MaterialGenerationService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MaterialGenerationService: unique symbol;
}
interface MaterialGenerationSession extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MaterialGenerationSession: unique symbol;
}
interface MaterialService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MaterialService: unique symbol;
GetBaseMaterialOverride(this: MaterialService, material: CastsToEnum): string;
GetMaterialVariant(this: MaterialService, material: CastsToEnum, name: string): MaterialVariant;
SetBaseMaterialOverride(this: MaterialService, material: CastsToEnum, name: string): void;
}
interface MaterialVariant extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MaterialVariant: unique symbol;
BaseMaterial: Enum.Material;
CustomPhysicalProperties: PhysicalProperties;
MaterialPattern: Enum.MaterialPattern;
StudsPerTile: number;
}
interface MemoryStoreHashMap extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MemoryStoreHashMap: unique symbol;
/**
* Tags: Yields
*/
GetAsync(this: MemoryStoreHashMap, key: string): unknown;
/**
* Tags: Yields
*/
RemoveAsync(this: MemoryStoreHashMap, key: string): void;
/**
* Tags: Yields
*/
SetAsync(this: MemoryStoreHashMap, key: string, value: unknown, expiration: number): boolean;
/**
* Tags: Yields
*/
UpdateAsync(this: MemoryStoreHashMap, key: string, transformFunction: Callback, expiration: number): unknown;
}
/** Provides access to a queue within MemoryStore. A queue is a data structure that provides temporary storage for arbitrary items (up to the maximum item size – see [`MemoryStore Limits`](https://developer.roblox.com/en-us/articles/memory-store). Each queue item has a numeric priority: MemoryStore retrieves items with higher priority from the queue first, and it retrieves Items with the same priority in order of addition.
*
* Items in the queue can optionally be set to expire after a certain amount of time. Expired items simply disappear from the queue as if they were never added.
*/
interface MemoryStoreQueue extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MemoryStoreQueue: unique symbol;
/**
* Adds an item to the queue.
*
* Tags: Yields
*/
AddAsync(this: MemoryStoreQueue, value: unknown, expiration: number, priority?: number): void;
/**
* Reads one or more items from the queue as a single atomic operation.
*
* This method does not automatically delete the returned items from the queue but makes them invisible to other ReadAsync calls for the period of the invisibility timeout. The items must be explicitly removed from the queue with [MemoryStoreQueue:RemoveAsync](https://developer.roblox.com/en-us/api-reference/function/MemoryStoreQueue/RemoveAsync) before the invisibility timeout expires. The invisibility timeout defaults to 30 seconds unless a different value was provided in [MemoryStoreService:GetQueue](https://developer.roblox.com/en-us/api-reference/function/MemoryStoreService/GetQueue).
*
* Tags: Yields
*/
ReadAsync(
this: MemoryStoreQueue,
count: number,
allOrNothing?: boolean,
waitTimeout?: number,
): LuaTuple<[items: Array, id: string]>;
/**
* Removes an item or items previously read from the queue. This method uses the identifier returned by [MemoryStoreQueue:ReadAsync](https://developer.roblox.com/en-us/api-reference/function/MemoryStoreQueue/ReadAsync) to identify the items to remove. If called after the invisibility timeout has expired, the call has no effect.
*
* Tags: Yields
*/
RemoveAsync(this: MemoryStoreQueue, id: string): void;
}
/** A top-level singleton class which exposes methods to access specific primitives within the MemoryStoreService. Use it for any data that rapidly changes that other servers can restore, such as global leaderboards, matchmaking queues, and auction houses.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*/
interface MemoryStoreService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MemoryStoreService: unique symbol;
GetHashMap(this: MemoryStoreService, name: string): MemoryStoreHashMap;
/**
* Returns a [MemoryStoreQueue](https://developer.roblox.com/en-us/api-reference/class/MemoryStoreQueue) instance for the provided name. The name is global within the game, thus any place that uses the same name will access the same queue.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*/
GetQueue(this: MemoryStoreService, name: string, invisibilityTimeout?: number): MemoryStoreQueue;
/**
* Returns a [MemoryStoreSortedMap](https://developer.roblox.com/en-us/api-reference/class/MemoryStoreSortedMap) instance for the provided name. The name is global within the game, so any place that uses the same name will access the same sorted map.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*/
GetSortedMap(this: MemoryStoreService, name: string): MemoryStoreSortedMap;
}
/** Provides access to a sorted map within MemoryStore. A sorted map is a collection of items where string keys are associated with arbitrary values (up to the maximum allowed size – see [MemoryStore Limits](https://developer.roblox.com/en-us/articles/memory-store)). The keys are arranged in alphabetical order. */
interface MemoryStoreSortedMap extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MemoryStoreSortedMap: unique symbol;
/**
* Retrieves the value of a key in the sorted map.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*
* Tags: Yields
*/
GetAsync(this: MemoryStoreSortedMap, key: string): unknown;
/**
* Gets items within a sorted range of keys.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*
* Tags: Yields
*/
GetRangeAsync(this: MemoryStoreSortedMap, direction: CastsToEnum, count: number, exclusiveLowerBound: unknown, exclusiveUpperBound: unknown): unknown;
/**
* Removes the provided key from the sorted map.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*
* Tags: Yields
*/
RemoveAsync(this: MemoryStoreSortedMap, key: string): void;
/**
* Sets the value of the key overwriting any existing key value.
*
* Tags: Yields
*/
SetAsync(this: MemoryStoreSortedMap, key: string, value: unknown, expiration: number, sortKey: unknown): boolean;
/**
* Retrieves the value of a key from a sorted map and lets you update it to a new value via a callback function.
*
* This method accepts a callback function that transforms the old value into the updated value as required. The method retrieves the existing key value and passes it to the transform function which returns the new value for the item, with these exceptions:
*
* * If the key does not exist, the old value passed to the function will be nil.
* * If the function returns nil, the update is canceled.
*
* The new value is saved only if the key was not updated (e.g. by a different game server) since the moment it was read. If the value did change, the transform function is invoked again with the most recent item value. This cycle repeats until the value is saved successfully or the transform function returns nil to abort the operation.
*
* For a more in-depth look, take a look at the [Memory Store](https://developer.roblox.com/en-us/articles/memory-store) article.
*
* Tags: Yields
*/
UpdateAsync(
this: MemoryStoreSortedMap,
key: string,
transformFunction: (value: unknown) => T,
expiration: number,
): T;
}
interface MessageBusConnection extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MessageBusConnection: unique symbol;
}
interface MessageBusService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MessageBusService: unique symbol;
}
/** The MessagingService allows game servers in the same game to communicate with each other in real time (< 1 second) using topics. Topics are developer defined strings (1-80 characters) that game servers can send and receive messages.
*
* Delivery is best effort and not guaranteed. Make sure to architect your game so delivery failures are not critical.
*
* Limitations
* -----------
*
* Note: these limits are subject to change at any time.
*
* Limit
*
* Maximum
*
* ### Size of message
*
* 1kB
*
* ### Messages sent per game server
*
* 150 + 60 \* (number of players in this game server) per minute
*
* ### Messages received per topic
*
* (10 + 20 \* number of servers) per minute
*
* ### Messages received for entire game
*
* (100 + 50 \* number of servers) per minute
*
* See also
* --------
*
* [Cross-Server Messaging Guide](https://developer.roblox.com/articles/cross-server-messaging), explores how to communicate between game servers in greater detail with relevant code samples
*/
interface MessagingService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MessagingService: unique symbol;
/**
* This function sends the provided message to all subscribers to the topic, triggering their registered callbacks to be invoked.
*
* Yields until the message is received by the backend.
*
* See also
* --------
*
* * [cross server messaging](https://developer.roblox.com/en-us/articles/cross-server-messaging), explores how to communicate between game servers in greater detail with relevant code samples
* * [MessagingService:SubscribeAsync](https://developer.roblox.com/en-us/api-reference/function/MessagingService/SubscribeAsync), begins listening to the given topic
*
* Tags: Yields
*/
PublishAsync(this: MessagingService, topic: string, message: unknown): void;
/**
* This function registers a callback to begin listening to the given topic. The callback is invoked when a topic receives a message. It can be called multiple times for the same topic.
*
* Callback
* --------
*
* The callback is invoked with two arguments:
*
* Field
*
* Summary
*
* ### Data
*
* Developer supplied payload
*
* ### Sent
*
* Unix time in seconds at which the message was sent
*
* It yields until the subscription is properly registered and returns a connection object.
*
* To unsubscribe, call [:Disconnect()](https://developer.roblox.com/en-us/api-reference/datatype/RBXScriptConnection) on the returned object. Once Disconnect() is called, the callback should never be invoked. Killing the script containing the connections also causes the underlying connect to be unsubscribed.
*
* See also
* --------
*
* * [Cross-Server Messaging Guide](https://developer.roblox.com/en-us/articles/cross-server-messaging), explores how to communicate between game servers in greater detail with relevant code samples
* * [MessagingService:PublishAsync](https://developer.roblox.com/en-us/api-reference/function/MessagingService/PublishAsync), sends the provided message to all subscribers to the topic, triggering their registered callbacks to be invoked
*
* Tags: Yields
*/
SubscribeAsync(
this: MessagingService,
topic: string,
callback: (message: { Data: unknown; Sent: number }) => void,
): RBXScriptConnection;
}
interface MetaBreakpoint extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MetaBreakpoint: unique symbol;
}
interface MetaBreakpointContext extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MetaBreakpointContext: unique symbol;
}
interface MetaBreakpointManager extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MetaBreakpointManager: unique symbol;
}
/** **Mouse** has been superseded by [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) and [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService), which cover a broader scope, are more feature rich, and support **cross-platform** patterns better. It remains supported because of its widespread use, but you should strongly consider using these alternatives.
*
* The **Mouse** object houses various API for pointers, primarily for buttons and raycasting. It can be accessed through [Player:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Player/GetMouse) called on the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript). It is also passed by the [Tool.Equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped) event.
*
* * It is most notable for the [Icon](https://developer.roblox.com/en-us/api-reference/property/Mouse/Icon) property, which changes the cursor's appearance.
* * It continually raycasts the screen mouse position into the 3D world using the [TargetFilter](https://developer.roblox.com/en-us/api-reference/property/Mouse/TargetFilter) property, storing the results of the raycast in the [Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit), [Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target), and [TargetSurface](https://developer.roblox.com/en-us/api-reference/property/Mouse/TargetSurface) properties. These can be useful for simple cases, but [WorldRoot:Raycast](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/Raycast) should be used in more complicated scenarios (whitelists, etc).
* * [Plugins](https://developer.roblox.com/en-us/api-reference/class/Plugin) can use use [Plugin:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Plugin/GetMouse) to get a [PluginMouse](https://developer.roblox.com/en-us/api-reference/class/PluginMouse), which behaves similarly.
*
* \-- From a LocalScript:
* local Players = game:GetService("Players")
* local player = Players.LocalPlayer
* local mouse = Player:GetMouse()
* -- Setting the mouse icon
* mouse.Icon = "rbxasset://SystemCursors/Wait"
*
* Notes
* -----
*
* * This object does not control/restrict pointer movement. For this, see [UserInputService.MouseBehavior](https://developer.roblox.com/en-us/api-reference/property/UserInputService/MouseBehavior) and [UserInputService.MouseDeltaSensitivity](https://developer.roblox.com/en-us/api-reference/property/UserInputService/MouseDeltaSensitivity).
* * If two functions are connected to same input event, such as [Button1Down](https://developer.roblox.com/en-us/api-reference/event/Mouse/Button1Down), **both** functions will run when the event fires. There is no concept of sinking/passing input, as events don't support this behavior. However, [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService) does have this behavior through [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction).
* * While a mouse may not be available on all platforms, Mouse will still function on mobile (touch) and console (gamepad), which don't typically have mice or pointer hardware. For explicit cross-platform behaviors, use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) and [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService).
*/
interface Mouse extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Mouse: unique symbol;
/**
* This property indicates [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) of the mouse's position in 3D space. Note that [Mouse.TargetFilter](https://developer.roblox.com/en-us/api-reference/property/Mouse/TargetFilter) and its descendants will be ignored.
*
* Developers can get obtain the position of Hit like so:
*
* local position = mouse.Hit.p
*
* Hit is often used by [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool)s to fire a weapon towards the mouse in third person.
*
* Developers looking for the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) the mouse is pointing at should use [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target).
*
* How is Mouse.Hit calculated?
* ----------------------------
*
* The position of the Hit CFrame is calculated as the point of intersection between the mouse's internal [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) (an extended version of [Mouse.UnitRay](https://developer.roblox.com/en-us/api-reference/property/Mouse/UnitRay)) and an object in 3D space (such as a part).
*
* The orientation of the Hit CFrame corresponds with the direction of the [Mouse.UnitRay](https://developer.roblox.com/en-us/api-reference/property/Mouse/UnitRay).
*
* local unitRayDirection = mouse.UnitRay.Direction
* local mouseHitDirection = mouse.Hit.lookVector
* -- unitRayDirection ≈ mouseHitDirection
* -- the vectors are approximately equal
*
* Note, the roll of the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) is not used when calculating the orientation of the Hit [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame).
*
* The mouse's internal ray extends for 1000 studs. If the mouse is not pointing at an object in 3D space (for example when pointing at the sky), this property will be 1000 studs away from the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera).
*
* Tags: NotReplicated
*/
readonly Hit: CFrame;
/**
* **Icon** is a property that determines the image used as the pointer. If blank, a default arrow is used. While the cursor hovers over a [GuiButton](https://developer.roblox.com/en-us/api-reference/class/GuiButton), this property is temporarily ignored.
*
* To hide the cursor entirely, **do not** use a transparent image – instead, set [UserInputService.MouseIconEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/MouseIconEnabled) to false. For more information on how to change the mouse's icon, please see [this tutorial](https://developer.roblox.com/en-us/articles/mouse-icon-appearance).
*
* Designing a Cursor
* ------------------
*
* The following guidelines may prove useful when creating your own mouse cursors:
*
* * The dimensions of the image used determines the size of the cursor.
* * The **center** of the image is where mouse inputs are issued.
* * The default mouse image is 64x64 pixels, with the mouse taking up 17x24 pixels of space.
*
* System Cursors for [PluginMouse](https://developer.roblox.com/en-us/api-reference/class/PluginMouse)
* ----------------------------------------------------------------------------------------------------
*
* When using a [PluginMouse](https://developer.roblox.com/en-us/api-reference/class/PluginMouse) retrieved from [Plugin:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Plugin/GetMouse), you can use the following icons similar to your system's default cursors, such as hands, arrows, I-beams, etc. You can use these with GUI events like [MouseEnter](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseEnter), [MouseLeave](https://developer.roblox.com/en-us/api-reference/event/GuiObject/MouseLeave), and [MouseButton1Down](https://developer.roblox.com/en-us/api-reference/event/GuiButton/MouseButton1Down) to provide a consistent studio experience when interacting with certain kinds of GUI components. Note that these only work for studio plugins; they will not work for other [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) objects.
*
* Look\*
*
* Asset
*
* Suggested Use
*
* 
*
* `rbxasset://SystemCursors/Arrow`
*
* Default clicking and selection.
*
* 
*
* `rbxasset://SystemCursors/PointingHand`
*
* Hovering over an active link/button.
*
* 
*
* `rbxasset://SystemCursors/OpenHand`
*
* Hovering over a draggable item.
*
* 
*
* `rbxasset://SystemCursors/ClosedHand`
*
* Dragging an item.
*
* 
*
* `rbxasset://SystemCursors/IBeam`
*
* Hovering in a text field.
*
* 
*
* `rbxasset://SystemCursors/SizeNS`
*
* Hovering over a vertical resize handle.
*
* 
*
* `rbxasset://SystemCursors/SizeEW`
*
* Hovering over a horizontal resize handle.
*
* 
*
* `rbxasset://SystemCursors/SizeNESW`
*
* Hovering over a corner resize handle.
*
* 
*
* `rbxasset://SystemCursors/SizeNWSE`
*
* Hovering over a corner resize handle.
*
* 
*
* `rbxasset://SystemCursors/SizeAll`
*
* Hovering over a multi-direction resize handle.
*
* 
*
* `rbxasset://SystemCursors/SplitNS`
*
* Hovering over a vertical "split" handle.
*
* 
*
* `rbxasset://SystemCursors/SplitEW`
*
* Hovering over a horizontal "split" handle.
*
* 
*
* `rbxasset://SystemCursors/Forbidden`
*
* Hovering over a locked/forbidden item.
*
* 
*
* `rbxasset://SystemCursors/Wait`
*
* Indicating an action is in progress.
*
* 
*
* `rbxasset://SystemCursors/Busy`
*
* Indicating the system is busy.
*
* 
*
* `rbxasset://SystemCursors/Cross`
*
* Hovering over a pinpoint selection area.
*
* \* These appearances are approximations – the actual look is dependent on your operating system.
*/
Icon: string;
/**
* The origin [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) property is a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) indicating where the mouse originated from. It is positioned at the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) and oriented toward the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse)'s 3D position.
*
* [Mouse.UnitRay](https://developer.roblox.com/en-us/api-reference/property/Mouse/UnitRay) starts at the same position as Origin, and extends for a stud in the same direction.
*
* local unitRay = mouse.UnitRay
* local origin = mouse.Origin
* -- unitRay.Direction = origin.p
* -- unitRay.Direction ≈ origin.lookVector
*
* For the position of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) in 3D space, see [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit).
*
* Tags: NotReplicated
*/
readonly Origin: CFrame;
/**
* The object in 3D space the [mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) is pointing to.
*
* Notes
* -----
*
* * If [Mouse.TargetFilter](https://developer.roblox.com/en-us/api-reference/property/Mouse/TargetFilter) has been set, the target filter and its descendants will be ignored.
* * When the mouse is not pointing at a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), for example when it is pointing at the sky, Target will be nil.
* * Developers looking for the position of the mouse in 3D space should use [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit).
*
* Tags: NotReplicated
*/
readonly Target: BasePart | undefined;
/**
* This property determines an object to be ignored by the mouse when calculating [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target). The descendants of the object are also ignored, so it is possible to ignore multiple objects so long as they are a descendant of the object to which this property is set. This property is useful when filtering models containing special effects or decorations that should not affect [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) or [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target).
*
* This property can be set to any [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) or nil, for example:
*
* local Players = game:GetService("Players")
* local player = Players.LocalPlayer
* local mouse = player:GetMouse()
* mouse.TargetFilter = workspace.Model
*
* -- Now, when the player hovers the cursor over the model, mouse.Target will be some object
* -- behind workspace.Model, if there is one.
*
* This property is essentially a single-object blacklist for mouse raycasting. For more in-depth control on raycasting, see the following functions of [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace): `Workspace/FindPartOnRay|FindPartOnRay`, `Workspace/FindPartOnRayWithWhitelist|FindPartOnRayWithWhitelist` and `Workspace/FindPartOnRayWithIgnoreList|FindPartOnRayWithIgnoreList`.
*
* The [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) of the [Players.LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) is ignored by the mouse automatically.
*/
TargetFilter: Instance | undefined;
/**
* This property indicates the [NormalId](https://developer.roblox.com/en-us/api-reference/enum/NormalId) of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) surface at which the mouse is pointing. This property is derived from the world position of mouse ([Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit)) and the part toward which the mouse is pointing ([Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target)).
*
* This property isn't meaningful when the mouse is not pointing at a part, for example when the mouse is pointing at the sky. At the moment, this property is set to 'Right' under these circumstances. Before using this property, check that the mouse's target is not nil.
*
* local Players = game:GetService("Players")
* local player = Players.LocalPlayer
* local mouse = player:GetMouse()
* -- Check that there exists a part at which the mouse is pointing
* if mouse.Target then
* print("The mouse is pointing to the " .. mouse.TargetSurface.Name .. " side of " .. mouse.Target.Name)
* else
* print("The mouse is not pointing at anything.")
* end
*
* Tags: NotReplicated
*/
readonly TargetSurface: Enum.NormalId;
/**
* The UnitRay property is a [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) directed toward the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse)'s position in 3D space (described by [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit)). It originates from the [CFrame](https://developer.roblox.com/en-us/api-reference/property/Camera/CFrame) of the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Like all unit rays, it has a distance of 1.
*
* local Players = game:GetService("Players")
* local player = Players.LocalPlayer
* local mouse = player:GetMouse()
* print(mouse.UnitRay.Direction.magnitude) -- Always 1
*
* Tags: NotReplicated
*/
readonly UnitRay: Ray;
/**
* The ViewSizeX property describes the horizontal component of the game window's size in pixels.
*
* Tags: NotReplicated
*/
readonly ViewSizeX: number;
/**
* The ViewSizeY property describes the vertical component of the game window's size in pixels. This length includes the space used by the topbar.
*
* Tags: NotReplicated
*/
readonly ViewSizeY: number;
/**
* When detecting changes in the mouse's position on-screen, it is recommended that you use [ContextActionService:BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) with `Enum.UserInputType.MouseMovement` or [UserInputService.InputChanged](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputChanged), which both describe the position of the mouse using the [Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position) (a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3)) of an [InputObject](https://developer.roblox.com/en-us/api-reference/class/InputObject), instead of using this and related properties.
*
* The X property describes the horizontal component of the mouse's position on the screen. The position is measured in pixels relative to the top left corner, under the topbar. This property can be used in conjunction with [Mouse.Y](https://developer.roblox.com/en-us/api-reference/property/Mouse/Y) to produce a [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) representing the mouse's position:
*
* local position = Vector2.new(mouse.X, mouse.Y)
*
* This property does not fire [Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) or the signal returned from [GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal). Use the [Mouse.Move](https://developer.roblox.com/en-us/api-reference/event/Mouse/Move) event instead.
*
* Tags: NotReplicated
*/
readonly X: number;
/**
* When detecting changes in the mouse's position on-screen, it is recommended that you use [ContextActionService:BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) with `Enum.UserInputType.MouseMovement` or [UserInputService.InputChanged](https://developer.roblox.com/en-us/api-reference/event/UserInputService/InputChanged), which both describe the position of the mouse using the [Position](https://developer.roblox.com/en-us/api-reference/property/InputObject/Position) (a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3)) of an [InputObject](https://developer.roblox.com/en-us/api-reference/class/InputObject), instead of using this and related properties.
*
* The Y property describes the vertical component of the mouse's position on the screen. The position is measured in pixels relative to the top left corner, under the topbar. This property can be used in conjunction with [Mouse.X](https://developer.roblox.com/en-us/api-reference/property/Mouse/X) to produce a [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) representing the mouse's position:
*
* local position = Vector2.new(mouse.X, mouse.Y)
*
* This property does not fire [Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) or the signal returned from [GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal). Use the [Mouse.Move](https://developer.roblox.com/en-us/api-reference/event/Mouse/Move) event instead.
*
* Tags: NotReplicated
*/
readonly Y: number;
/**
* The Button1Down even fires when the the player presses their left mouse button.
*
* This can also be accessed from a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). For example, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), the code below prints Button1Down whenever the left mouse button is pressed:
*
* local Tool = script.Parent --make sure this is a Tool object
*
* Tool.Equipped:Connect(function(Mouse)
* Mouse.Button1Down:Connect(function()
* print("Button1Down")
* end)
* end)
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* For information on how to obtain the mouse object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Button1Down: RBXScriptSignal<() => void>;
/**
* Fires when the left mouse button is released.
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Button1Up: RBXScriptSignal<() => void>;
/**
* The Button2Down even fires when the the player presses their right mouse button.
*
* This can also be accessed from a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). For example, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), the code below prints Button2Down whenever the right mouse button is pressed:
*
* local Tool = script.Parent --make sure this is a Tool object
*
* Tool.Equipped:Connect(function(Mouse)
* Mouse.Button2Down:Connect(function()
* print("Button2Down")
* end)
* end).
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* For information on how to obtain the mouse object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Button2Down: RBXScriptSignal<() => void>;
/**
* Fired when the right mouse button is released.
*
* mouse.Button2Up:Connect(function()
* print("button 2 up!")
* end
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Button2Up: RBXScriptSignal<() => void>;
/**
* Fired during every heartbeat that the mouse isn't being passed to another mouse event.
*
* Note, this event should not be used to determine when the mouse is still. As it fires every heartbeat it will fire between [Mouse.Move](https://developer.roblox.com/en-us/api-reference/event/Mouse/Move) events.
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Idle: RBXScriptSignal<() => void>;
/**
* This event fires when a Key is pressed, with the passed argument being the key that was pressed.
*
* Notes
* -----
*
* * Not all keys generate this event. However, you can get around this with a few of the keys, “/” for example, by using the [Mouse.KeyUp](https://developer.roblox.com/en-us/api-reference/event/Mouse/KeyUp) event.
* * Some keys generate the same string as other keys.
* * It's possible for the string to be empty (possibly due to “\\0” key code).
* @deprecated Use `InputBegan` instead
*/
readonly KeyDown: RBXScriptSignal<(key: string) => void>;
/**
* This event is fired when a Key is released, with the passed argument being the key that was released.
*
* Notes
* -----
*
* * Not all keys generate this event. However, you can get around this with a few of the keys, “/” for example, by using the \[\[API:Class/Mouse/KeyUp|KeyUp\]\] event.
* * Some keys generate the same string as other keys.
* * It's possible for the string to be empty (possibly due to “\\0” key code).
* @deprecated Use `InputEnded` instead
*/
readonly KeyUp: RBXScriptSignal<(key: string) => void>;
/**
* Fired when the mouse is moved.
*
* Note, this event is fired when the mouse's position is updated, therefore it will fire repeatedly whilst being moved.
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Developers can find out the position of the mouse in world-space, and if it is pointing at any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) using the [Mouse.Hit](https://developer.roblox.com/en-us/api-reference/property/Mouse/Hit) and [Mouse.Target](https://developer.roblox.com/en-us/api-reference/property/Mouse/Target) properties.
*
* mouse.Move:Connect(function()
* local position = mouse.Hit.p
* local target = mouse.Target
* print(target, position)
* end)
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly Move: RBXScriptSignal<() => void>;
/**
* The WheelBackward event fires when the mouse wheel is scrolled backwards. Possible uses for this event include toggling a gun's scope in a first person shooter (FPS) or zooming the player's camera.
*
* This can be used alongside the scrolling forward event, [Mouse.WheelForward](https://developer.roblox.com/en-us/api-reference/event/Mouse/WheelForward).
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly WheelBackward: RBXScriptSignal<() => void>;
/**
* The WheelForward event fires when the mouse wheel is scrolled forwards. Possible uses for this event include toggling a gun's scope in a first person shooter (FPS) or zooming the player's camera.
*
* This can be used alongside the scrolling backward event, [Mouse.WheelBackward](https://developer.roblox.com/en-us/api-reference/event/Mouse/WheelBackward).
*
* For information on how to obtain the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object, please see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*
* Note, developers are recommended to use [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) instead of the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object in new work.
*/
readonly WheelForward: RBXScriptSignal<() => void>;
}
/** The PlayerMouse behaves identically to the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object that is obtained using [Tool.Equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped). It can be accessed from [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s using the local player's [Player:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Player/GetMouse) method.
*
* The only difference between the PlayerMouse and the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) object is the PlayerMouse can be obtained using the [Player:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Player/GetMouse) method.
*
* In most cases developers are advised to use the new [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService). However the PlayerMouse and Mouse objects remain supported for a number of reasons.
*
* For more information on how to use the mouse object, see the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) page.
*/
interface PlayerMouse extends Mouse {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlayerMouse: unique symbol;
}
/** The NetworkMarker is used to tell the client when the server has finished loading the world for the client. */
interface NetworkMarker extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_NetworkMarker: unique symbol;
/**
* Fired when the server has finished replicating the world to the client.
*/
readonly Received: RBXScriptSignal<() => void>;
}
/** The NoCollisionConstraint is an instance used to prevent collisions between two specific parts. Connected [Parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) will have no collision reaction between them, but can still have collisions with the rest of the world. Both parts can still receive touch events.
*
* Using a NoCollisionConstraint will allow you to create and share [Models](https://developer.roblox.com/en-us/api-reference/class/Model) with customized collision filtering. While you can still achieve collision filtering with [Collision Groups](https://developer.roblox.com/articles/Collision-Filtering), you are unable to export that information to a model without adding a script to set them when the game runs.
*
* It also provides a quicker way to disable specific problematic collisions. However, if you are trying to spot a large number of parts from colliding with another, it might be better to use [Collision Groups](https://developer.roblox.com/articles/Collision-Filtering).
*
* 
*
* The easiest way to add an NoCollisionConstraint is from the Create Constraint dropdown menu.
*
* 
*
* Similar to other constraints, this tool will act differently based on how many parts are selected when the tool is activated.
*
* No Parts Selected
* -----------------
*
* If no parts are selected when the NoCollisionConstraint tool is clicked, the next two parts that are clicked on will be connected. If the same part is clicked twice no link will be created.
*
* One Part Selected
* -----------------
*
* If one part is selected when the NoCollisionConstraint tool is clicked, the next part that is clicked on will be connected to the selected part.
*
* Two Parts Selected
* ------------------
*
* If two parts are selected when the NoCollisionConstraint tool is clicked, the two parts will be connected.
* You cannot create an NoCollisionConstraint with more than two parts selected.
*/
interface NoCollisionConstraint extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_NoCollisionConstraint: unique symbol;
/**
* This property determines whether the two constrained parts, [NoCollisionConstraint.Part0](https://developer.roblox.com/en-us/api-reference/property/NoCollisionConstraint/Part0) and [NoCollisionConstraint.Part1](https://developer.roblox.com/en-us/api-reference/property/NoCollisionConstraint/Part1), will collide with each other.
*/
Enabled: boolean;
/**
* The second [Part](https://developer.roblox.com/en-us/api-reference/class/BasePart) that the constraint connects.
*/
Part0: BasePart | undefined;
/**
* The first [Part](https://developer.roblox.com/en-us/api-reference/class/BasePart) that the constraint connects.
*/
Part1: BasePart | undefined;
}
interface OmniRecommendationsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OmniRecommendationsService: unique symbol;
}
interface OpenCloudApiV1 extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OpenCloudApiV1: unique symbol;
/**
* Tags: CustomLuaState
*/
CreateModel(this: OpenCloudApiV1, name: string): OpenCloudModel;
/**
* Tags: Yields
*/
CreateUserNotificationAsync(this: OpenCloudApiV1, user: string, userNotification: OpenCloudModel): OpenCloudModel;
}
interface OpenCloudService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OpenCloudService: unique symbol;
GetApiV1(this: OpenCloudService): OpenCloudApiV1;
/**
* Tags: Yields
*/
InvokeAsync(this: OpenCloudService, version: string, methodName: string, arguments: object): object;
}
interface OperationGraph extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OperationGraph: unique symbol;
}
/** A [PVInstance](https://developer.roblox.com/en-us/api-reference/class/PVInstance) (“Position Velocity Instance”) is an abstract class that cannot be created. It is the base for all objects that have a physical location in the world, specifically [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and [Models](https://developer.roblox.com/en-us/api-reference/class/Model). */
interface PVInstance extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PVInstance: unique symbol;
/**
* This function gets the pivot of a [PVInstance](https://developer.roblox.com/en-us/api-reference/class/PVInstance). This is often used with [PVInstance:PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo) to move a model.
*
* [Models](https://developer.roblox.com/en-us/api-reference/class/Model) and [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) are both [PVInstances](https://developer.roblox.com/en-us/api-reference/class/PVInstance) (“Position Velocity Instances”) and so both have this function.
*/
GetPivot(this: PVInstance): CFrame;
/**
* Transforms the [PVInstance](https://developer.roblox.com/en-us/api-reference/class/PVInstance) along with all of its descendant [PVInstances](https://developer.roblox.com/en-us/api-reference/class/PVInstance) such that the pivot is now located at the specified [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame). This is the primary function that should be used to move [Models](https://developer.roblox.com/en-us/api-reference/class/Model) via scripting.
*
* [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) are moved in this way by having their [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) transformed by the necessary offset. [Models](https://developer.roblox.com/en-us/api-reference/class/Model) are moved in this way by having their [Model.WorldPivot](https://developer.roblox.com/en-us/api-reference/property/Model/WorldPivot) transformed by the necessary offset.
*
* Note that for efficiency purposes, [Instance.Changed](https://developer.roblox.com/en-us/api-reference/event/Instance/Changed) events are not fired for [Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) and [Orientation](https://developer.roblox.com/en-us/api-reference/property/BasePart/Orientation) of [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) moved in this way; they are only fired for [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame).
*
* When calling [PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo) on [Models](https://developer.roblox.com/en-us/api-reference/class/Model), the offsets of the descendant parts and models are cached, such that subsequent calls to [PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo) on the same model do not accumulate floating point drift between the parts making up the model.
*
* [Models](https://developer.roblox.com/en-us/api-reference/class/Model) and [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) are both [PVInstances](https://developer.roblox.com/en-us/api-reference/class/PVInstance) (“Position Velocity Instances”) and so both have this function.
*/
PivotTo(this: PVInstance, targetCFrame: CFrame): void;
}
/** BasePart is an abstract base class for in-world objects that render and are physically simulated while in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace). There are several implementations of BasePart, the most common is [Part](https://developer.roblox.com/en-us/api-reference/class/Part), a simple 6-face rectangular prism. Others include [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation), [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart) and the singleton [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) object within the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace). Most of the time, when documentation refers to a part, most BasePart implementations will work and not just [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* There are many different objects that interact with BasePart:
*
* * They may be grouped within a [Model](https://developer.roblox.com/en-us/api-reference/class/Model), which allows several BasePart to be moved at the same time using [SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame).
* * A [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) applies a stretched image texture to the faces of a part, though the exact mapping depends on the type of part.
* * A [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) applies a tiled image texture to the faces of a part much like a [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal).
* * A [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) renders [GuiObjects](https://developer.roblox.com/en-us/api-reference/class/GuiObject) on the face of a part.
* * An [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) can be added to specify a CFrames relative to a parent BasePart. These are often used by physics [Constraint](https://developer.roblox.com/en-us/api-reference/class/Constraint) objects, such as [RopeConstraint](https://developer.roblox.com/en-us/api-reference/class/RopeConstraint) and [HingeConstraint](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint).
* * [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) emit particles uniformly in the volume of the BasePart to which they are parented.
* * Light objects like [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) emit light from the center of a BasePart.
* * When [played](https://developer.roblox.com/en-us/api-reference/function/Sound/Play), a [Sound](https://developer.roblox.com/en-us/api-reference/class/Sound) parented to a BasePart will be physically located at the part's position.
* * [BodyMover](https://developer.roblox.com/en-us/api-reference/class/BodyMover) objects like [BodyVelocity](https://developer.roblox.com/en-us/api-reference/class/BodyVelocity) exert forces on the BasePart to which they are parented.
* * As a sibling of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), they can be used as limbs of a character and also animated when joined using [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D). If not a sibling of a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), BasePart can still be animated using an [AnimationController](https://developer.roblox.com/en-us/api-reference/class/AnimationController).
* * In Studio, you can use most implementations of BaseParts with solid modelling.
* * If parented to a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) and given the name “Handle”, a BasePart can be held by characters.
* * You can make BasePart interactive by adding a [ClickDetector](https://developer.roblox.com/en-us/api-reference/class/ClickDetector)
* * You can use a mesh like a [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh) or [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) to change how a BasePart looks without change how it physically behaves.
*/
interface BasePart extends PVInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BasePart: unique symbol;
/**
* The Anchored property determines whether the part will be **immovable** by physics. When enabled, a part will never change position due to gravity, other parts collisions, overlapping other parts, or any other physics-related causes. A part that is not anchored is called **unanchored**. As a result, two anchored parts will never fire the [BasePart.Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched) event on each other. An anchored part may still be moved by changing its [BasePart.CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame) or [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position), and it still may have a nonzero [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity) and [BasePart.RotVelocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/RotVelocity). Finally, if an unanchored part is joined with an anchored part through an object like a `/Weld`, it too will act anchored. If such a joint breaks the part may be affected by physics again.
*
* It's a good idea to anchor parts that are part of your game's environment (and therefore shouldn't move). In fact, if you don't have a good reason to keep a part unanchored, you should anchor it. Unanchored parts can cause performance issues if there are many. In Roblox Studio, you can anchor/unanchor an entire model using the Anchor tool. Be sure to keep static environment models anchored, like in-world buttons, signs, and trees.
*
* Network ownership cannot be set on anchored parts. If a part's anchored status changes on the server, the network ownership of that part will be affected.
*/
Anchored: boolean;
/**
* The angular velocity vector of this [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) assembly. It's the rate of change of orientation in radians per second.
*
* Angular velocity is the same at every point of the assembly.
*
* Setting the velocity directly may lead to unrealistic motion. Using [Torque](https://developer.roblox.com/en-us/api-reference/class/Torque) or [AngularVelocity](https://developer.roblox.com/en-us/api-reference/class/AngularVelocity) constraint is preferred, or use [BasePart:ApplyImpulse](https://developer.roblox.com/en-us/api-reference/function/BasePart/ApplyImpulse) if you want instantaneous change in velocity.
*
* Tags: NotReplicated
*/
AssemblyAngularVelocity: Vector3;
/**
* A position calculated via the [mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/Mass) and [position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) of all the parts in the assembly.
*
* If the assembly has an anchored part, that part's [center of mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyCenterOfMass) will be the assemblies center of mass, and the assembly will have infinite mass.
*
* Knowing the center of mass can help the assembly maintain stability. A force applied to the center of mass will not cause [angular acceleration](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyAngularVelocity), only [linear](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyLinearVelocity). An assembly with a low center of mass will have a better time staying upright.
*
* Tags: NotReplicated
*/
readonly AssemblyCenterOfMass: Vector3;
/**
* The linear velocity vector of this [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) assembly. It's the rate of change in position of the assembly's [center of mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyCenterOfMass) in studs per second.
*
* If you want to know the velocity at a point other than the assembly's center of mass, use [BasePart:GetVelocityAtPosition](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetVelocityAtPosition).
*
* Setting the velocity directly may lead to unrealistic motion. Using a [VectorForce](https://developer.roblox.com/en-us/api-reference/class/VectorForce) constraint is preferred, or use [BasePart:ApplyImpulse](https://developer.roblox.com/en-us/api-reference/function/BasePart/ApplyImpulse) if you want instantaneous change in velocity.
*
* Tags: NotReplicated
*/
AssemblyLinearVelocity: Vector3;
/**
* The sum of the mass of all the [parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) in this part's assembly. Parts that are [Massless](https://developer.roblox.com/en-us/api-reference/property/BasePart/Massless) and are not the assembly's root part will not contribute to the AssemblyMass.
*
* If the assembly has an anchored part, the assembly's mass is considered infinite.
*
* Constraints and other physical interactions between unanchored assemblies with a large difference in mass may cause instabilities.
*
* Tags: NotReplicated
*/
readonly AssemblyMass: number;
/**
* This property indicates the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) automatically chosen to represent the [assembly's](https://developer.roblox.com/en-us/api-reference/class/Assembly) root part. It is the same part that's returned when developers call [GetRootPart()](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart).
*
* The root part can be changed by changing the [RootPriority](https://developer.roblox.com/en-us/api-reference/property/BasePart/RootPriority) of the parts in the assembly.
*
* See also
* --------
*
* * For more information on root parts, take a look at the [Understanding Root Parts](../../articles/understanding-root-parts) article.
*
* Tags: NotReplicated
*/
readonly AssemblyRootPart: BasePart | undefined;
/**
* The BackParamA property is relevant when a part's [BasePart.BackSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurface) is set to Motor or SteppingMotor and [BasePart.BackSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* There are no other usages for this property.
*
* Tags: Hidden
* @deprecated
*/
BackParamA: number;
/**
* The BackParamB property is relevant when a part's [BasePart.BackSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurface) is set to Motor or SteppingMotor and [BasePart.BackSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
BackParamB: number;
/**
* The BackSurface property determines the type of surface used for the +Z direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.BackSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
BackSurface: Enum.SurfaceType;
/**
* The BackSurfaceInput property determines the kind of input provided to a part's [BasePart.BackSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.BackParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackParamA) and [BasePart.BackParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/BackParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
BackSurfaceInput: Enum.InputType;
/**
* The BottomParamA property is relevant when a part's [BasePart.BottomSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurface) is set to Motor or SteppingMotor and [BasePart.BottomSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* There are no other usages for this property.
*
* Tags: Hidden
* @deprecated
*/
BottomParamA: number;
/**
* The BottomParamB property is relevant when a part's [BasePart.BottomSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurface) is set to Motor or SteppingMotor and [BasePart.BottomSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
BottomParamB: number;
/**
* The BottomSurface property determines the type of surface used for the -Y direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.BottomSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
BottomSurface: Enum.SurfaceType;
/**
* The BottomSurfaceInput property determines the kind of input provided to a part's [BasePart.BottomSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.BottomParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomParamA) and [BasePart.BottomParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/BottomParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
BottomSurfaceInput: Enum.InputType;
/**
* The BrickColor property determines the color of a part. If the part has a [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material), this also determines the color used when rendering the material texture. For more control over the color, the [BasePart.Color](https://developer.roblox.com/en-us/api-reference/property/BasePart/Color) property can be used (it is a Color3 variant of this property). If Color set, this property will use the closest BrickColor.
*
* Other visual properties of a part are determined by [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) and [BasePart.Reflectance](https://developer.roblox.com/en-us/api-reference/property/BasePart/Reflectance).
*
* Tags: NotReplicated
*/
BrickColor: BrickColor;
/**
* The CFrame property determines both the position and orientation of a part relative to the world. The part is rendered such that the CFrame is the center of the rendered 3D model (with one exception outlined below). For keeping track of positions relative to a part's CFrame, an `/Attachment` is useful. Most visual flair objects (such as particles and lights) will render at a part's CFrame.
*
* When setting CFrame, other joined parts are also moved relative to the part whose CFrame was set. This could be used for teleporting a player's character, however it is recommended to use [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) instead if you want to move an entire model. Unlike [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position), setting CFrame will always move the part to the exact given CFrame; in other words: **no overlap checking is done when setting CFrame.** If two collidable parts happen to overlap and one is not [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored), the physics solver will attempt to resolve the overlap.
*
* In online sessions, a part may be rendered differently than its CFrame may suggest (e.g., for tweening the different CFrames received from the server). Use [BasePart:GetRenderCFrame](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRenderCFrame) to get the apparent CFrame.
*/
CFrame: CFrame;
/**
* The CanCollide property determines whether a part will physically interact with other parts. When disabled, other parts can pass through the brick uninterrupted. Parts used for **decoration** usually have CanCollide disabled, as they need not be considered by the physics engine.
*
* If a part is not [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) and has CanCollide disabled, it may fall out of the world to be eventually destroyed by [Workspace.FallenPartsDestroyHeight](https://developer.roblox.com/en-us/api-reference/property/Workspace/FallenPartsDestroyHeight). Therefore, it is usually desirable to anchor such parts or join them to another part that is anchored so that they don't fall out of the level. You can also use an object like `/BodyPosition` or `/BodyForce` to prevent falling out of the level entirely.
*
* Even when CanCollide is disabled, parts may still fire the [BasePart.Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched) event (as well the other parts touching them). In addition, a part allow other parts to pass through even if CanCollide is enabled if their collision groups are not set to collide with each other. Part collision groups are managed by `/PhysicsService`.
*/
CanCollide: boolean;
/**
* **CanQuery** determines whether the part is considered during spatial query operations, namely [GetPartBoundsInBox](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartBoundsInBox), [GetPartBoundsInRadius](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartBoundsInRadius) and [GetPartsInPart](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartsInPart). These functions will never include parts whose CanQuery is false.
*
* Beyond this property, it is also possible to blacklist parts which are descendants of a given list of parts using an [OverlapParams](https://developer.roblox.com/en-us/api-reference/datatype/OverlapParams) object when calling the spatial query functions.
*/
CanQuery: boolean;
/**
* This property determines if the part will trigger [Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched)/[TouchEnded](https://developer.roblox.com/en-us/api-reference/event/BasePart/TouchEnded) events on other [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) with [TouchTransmitters](https://developer.roblox.com/en-us/api-reference/class/TouchTransmitter). By default, the value is set to `true`.
*
* A BasePart's Touched or TouchEnded event will only fire if otherPart has CanTouch set to `true`.
*
* When `false`, a touch event cannot be setup for the part. Attempting to do so will throw an error. If the property is set to `false` after a touch event is connected, the event will be disconnected and TouchTransmitter removed.
*
* The two images below demonstrate how the property behaves using a non-colliding part with a script telling it to turn green when touched. First, on the left, we drop parts that are CanTouch. On the right, we drop parts that are not CanTouch.
*
* 
*
* 
*
* Collision Groups
* ----------------
*
* This collision logic can be enabled and disabled for [Collision Groups](https://developer.roblox.com/en-us/articles/collision-filtering) using the [Workspace.TouchesUseCollisionGroups](https://developer.roblox.com/en-us/api-reference/property/Workspace/TouchesUseCollisionGroups) property. In this case, when TouchesUseCollisionGroups is `true` parts in different groups set to not collide will ignore collisions and touch events - thereby ignoring this property
*
* Performance
* -----------
*
* There is a small performance gain on parts that have both CanTouch and [CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) set to `false`, as these parts will never need to compute any kind of part to part collisions. However, they can still be hit by [Raycasts](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/Raycast) and [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) queries.
*/
CanTouch: boolean;
/**
* Determines whether or not a part casts a shadow.
*
* Note that this feature is not designed for performance enhancement. It should only be disabled on parts where you want to hide the shadows the part casts. Disabling this property for a given part may cause visual artifacts on the shadows cast upon that part.
*
* The following image shows a red part with CastShadow disabled and a blue part with CastShadow enabled. Note the tapering artifact on the shadow cast on the red part.
*
* 
*/
CastShadow: boolean;
/**
* The CenterOfMass property describes the position in which a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart)'s [center of mass](https://en.wikipedia.org/wiki/Center_of_mass) is located. Should a force be applied to the part toward this point, the part would not rotate as a result of this force. **CenterOfMass is currently not enabled.**
*
* Tags: NotReplicated
*/
readonly CenterOfMass: Vector3;
/**
* Tags: NotReplicated
*/
CollisionGroup: string;
/**
* The CollisionGroupId property describes the ID number of the part's collision group. Parts start off in the Default group whose ID is 0. Although this property can be directly changed, it is recommended to instead manipulate the collision group of a part using the **name** of the group with the [PhysicsService:SetPartCollisionGroup](https://developer.roblox.com/en-us/api-reference/function/PhysicsService/SetPartCollisionGroup) function. You can find the ID of a collision group by using [PhysicsService:GetCollisionGroupId](https://developer.roblox.com/en-us/api-reference/function/PhysicsService/GetCollisionGroupId).
*
* This value cannot be negative, and cannot exceed [PhysicsService:GetMaxCollisionGroups](https://developer.roblox.com/en-us/api-reference/function/PhysicsService/GetMaxCollisionGroups). Invalid IDs are clamped.
*
* Tags: NotReplicated
* @deprecated Use `CollisionGroup` instead
*/
CollisionGroupId: number;
/**
* The Color property determines the color of a part. If the part has a [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material), this also determines the color used when rendering the material texture. If this property is set, [BasePart.BrickColor](https://developer.roblox.com/en-us/api-reference/property/BasePart/BrickColor) will use the closest BrickColor to the Color3 value.
*
* Other visual properties of a part are determined by [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) and [BasePart.Reflectance](https://developer.roblox.com/en-us/api-reference/property/BasePart/Reflectance).
*
* Tags: NotReplicated
*/
Color: Color3;
/**
* Tags: NotReplicated
*/
readonly CurrentPhysicalProperties: PhysicalProperties;
/**
* CustomPhysicalProperties lets you customize various physical aspects of a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart), such as its's density, friction, and elasticity.
*
* If enabled, this property let's you configure these physical properties. If disabled, these physical properties are determined by the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) of the part. The page for [Material](https://developer.roblox.com/en-us/api-reference/enum/Material) contains list of the various part materials.
*/
CustomPhysicalProperties: PhysicalProperties | undefined;
/**
* The Elasticity of a part is now determined by either its `Material` or its `CustomPhysicalProperties`.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
Elasticity: number;
EnableFluidForces: boolean;
/**
* Tags: NotReplicated
*/
readonly ExtentsCFrame: CFrame;
/**
* Tags: NotReplicated
*/
readonly ExtentsSize: Vector3;
/**
* Used to control the Friction of the part, but now it no longer does anything. The Friction of a part is now determined by either its [Material](https://developer.roblox.com/api-reference/property/BasePart/Material "Material") or its [CustomPhysicalProperties](https://developer.roblox.com/api-reference/property/BasePart/CustomPhysicalProperties "CustomPhysicalProperties").
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
Friction: number;
/**
* The FrontParamA property is relevant when a part's [BasePart.FrontSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurface) is set to Motor or SteppingMotor and [BasePart.FrontSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
FrontParamA: number;
/**
* The FrontParamB property is relevant when a part's [BasePart.FrontSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurface) is set to Motor or SteppingMotor and [BasePart.FrontSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
FrontParamB: number;
/**
* The FrontSurface property determines the type of surface used for the -Z direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.FrontSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
FrontSurface: Enum.SurfaceType;
/**
* The FrontSurfaceInput property determines the kind of input provided to a part's [BasePart.FrontSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.FrontParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontParamA) and [BasePart.FrontParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/FrontParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
FrontSurfaceInput: Enum.InputType;
/**
* The LeftParamA property is relevant when a part's [BasePart.LeftSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurface) is set to Motor or SteppingMotor and [BasePart.LeftSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
LeftParamA: number;
/**
* The LeftParamB property is relevant when a part's [BasePart.LeftSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurface) is set to Motor or SteppingMotor and [BasePart.LeftSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
LeftParamB: number;
/**
* The LeftSurface property determines the type of surface used for the -X direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.LeftSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
LeftSurface: Enum.SurfaceType;
/**
* The LeftSurfaceInput property determines the kind of input provided to a part's [BasePart.LeftSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.LeftParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftParamA) and [BasePart.LeftParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/LeftParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
LeftSurfaceInput: Enum.InputType;
/**
* The LocalTransparencyModifier property is a multiplier to [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) that is only visible to the local client. It does not replicate from client to server. It is useful for when a part should not render for a specific client, such as how the player does not see their character's body parts when they zoom into first person mode.
*
* The property modifies the local part's transparency increases a part's transparency on a scale from 0 to 1 using the following formula:
*
* -- Calculate the part's client-side transparency. Values greater than 1 round down to 1.
* local clientTransparency = part.Transparency + (1 \* part.localTransparencyModifier)
*
* Take a look at the table below for an example of how this property affect's a part's client-side transparency:
*
* Transparency
*
* LocalTransparencyModifier
*
* Server-Side Transparency
*
* Client-Side Transparency
*
* Description
*
* 0.5
*
* 0
*
* 0.5
*
* 0.5
*
* A modifier value of 0.5 means that the part's client-side transparency is affected as follows: 0.5 + 1\*0 = 0.5. The part's client-side transparency equals its server-side transparency.
*
* 0.5
*
* 0.5
*
* 0.5
*
* 0.75
*
* A modifier value of 0.5 means that the part's client-side transparency is affected as follows: 0.5 + 1\*0.5 = 0.75
*
* 0.5
*
* 1
*
* 0.5
*
* 1
*
* A modifier value of 1 means that the part's client-side transparency is affected as follows: 0.5 + 1\*1 = >1. The client does not render the part.
*
* Tags: Hidden, NotReplicated
*/
LocalTransparencyModifier: number;
/**
* The Locked property determines whether a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) (or a [model](https://developer.roblox.com/en-us/api-reference/class/Model) it is contained within) may be selected in Roblox Studio by clicking on it. This property is most often enabled on parts within environment models that aren't being edited at the moment. Roblox Studio has a Lock/Unlock All tool that can toggle the Locked state of every part descendant in a model at once.
*/
Locked: boolean;
/**
* **Mass** is a read-only property that describes the product of a part's volume and density. It is returned by the [GetMass](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetMass) function.
*
* * The volume of a part is determined by its [Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) and its [Shape](https://developer.roblox.com/en-us/api-reference/property/Part/Shape), which varies depending on the kind of BasePart used, such as [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart).
* * The density of a part is determined by its [Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) or [CustomPhysicalProperties](https://developer.roblox.com/en-us/api-reference/property/BasePart/CustomPhysicalProperties), if specified.
*
* A common use of the Mass property is using it to calculate the magnitude of a gravity-counteracting force. Using a [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce), apply a upward force equal to the product of a part's Mass and [Workspace.Gravity](https://developer.roblox.com/en-us/api-reference/property/Workspace/Gravity). This will completely counteract the force of gravity on the part.
*
* Tags: NotReplicated
*/
readonly Mass: number;
/**
* If this property is enabled, the [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) will not contribute to the total mass or inertia of its rigid body as long as it is [welded](https://developer.roblox.com/en-us/api-reference/class/Weld) to another part that has mass.
*
* 
*
* If the part is its own root part according to [BasePart:GetRootPart](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetRootPart) then this will be ignored for that part, and it will still contribute mass and inertia to its rigid body like a normal part. Parts that are massless should never become an assembly root part unless all other parts in the assembly are also massless.
*
* This might be useful for things like optional accessories on vehicles that you don't want to affect the handling of the car or a massless render mesh welded to a simpler collision mesh. For instance, to create a massless [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart), you would use the follow code:
*
* local mesh = Instance.new("MeshPart")
* mesh.Parent = game.Workspace
* mesh.MeshId = "insert meshId here"
* mesh.Massless = true
*
* See also
* --------
*
* * `article/understanding root parts|Understanding Root Parts`, an article documenting what root parts are and how to use them
*/
Massless: boolean;
/**
* The Material property allows a builder to set a part's texture and default physical properties (in the case that [BasePart.CustomPhysicalProperties](https://developer.roblox.com/en-us/api-reference/property/BasePart/CustomPhysicalProperties) is unset). The default Plastic material has a very light texture, and the SmoothPlastic material has no texture at all. Some material textures like DiamondPlate and Granite have very visible textures. Each material's texture reflects sunlight differently, especially Foil.
*
* Setting this property then enabling [BasePart.CustomPhysicalProperties](https://developer.roblox.com/en-us/api-reference/property/BasePart/CustomPhysicalProperties) will use the default physical properties of a material. For instance, DiamondPlate is a very dense material while Wood is very light. A part's density determines whether it will float in terrain water.
*
* The Glass material changes rendering behavior on moderate graphics settings. It applies a bit of reflectiveness (similar to [BasePart.Reflectance](https://developer.roblox.com/en-us/api-reference/property/BasePart/Reflectance)) and perspective distortion. The effect is especially pronounced on sphere-shaped parts (set `/BasePart/Shape` to Ball). Semitransparent objects and Glass parts behind Glass are not visible.
*/
Material: Enum.Material;
/**
* Tags: NotReplicated
*/
MaterialVariant: string;
/**
* The Orientation property describes the part's rotation in degrees around the X, Y and Z axes using a Vector3. The rotations are applied in Y → X → Z order. This differs from proper [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), and is instead [Tait–Bryan angles](https://en.wikipedia.org/wiki/Euler_angles#Tait-Bryan_angles) which describe **yaw, pitch and roll**. It is also worth noting how this property differs from the `CFrame.Angles()` constructor, which applies rotations in a different order (Z → Y → X). For better control over the rotation of a part, it is recommended that [BasePart.CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame) is set instead.
*
* When setting this property any [Welds](https://developer.roblox.com/en-us/api-reference/class/Weld), [ManualWelds](https://developer.roblox.com/en-us/api-reference/class/ManualWeld), [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap), [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), and [Motor6Ds](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connected to this part will have the matching [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) property updated and to allow the part to move relative to any other parts it is joined to.
*
* WeldConstraints will also be temporarily disabled and re-enabled during the move.
*
* Tags: Hidden, NotReplicated
*/
Orientation: Vector3;
/**
* This property specifies the offset of the part's pivot from its [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame), that is `part:GetPivot()` is the same as `part.CFrame * part.PivotOffset`.
*
* This is convenient for setting the pivot to a location in **local** space, but setting a part's pivot to a location in **world** space can be done as follows:
*
* local part = workspace.BluePart
* local desiredPivotCFrameInWorldSpace = CFrame.new(0, 10, 0)
* part.PivotOffset = part.CFrame:ToObjectSpace(desiredPivotCFrameInWorldSpace)
*/
PivotOffset: CFrame;
/**
* The Position property describes the coordinates of a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) using a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3). It reflects the position of the part's [BasePart.CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame), however it can also be set.
*
* When setting this property any [Welds](https://developer.roblox.com/en-us/api-reference/class/Weld), [ManualWelds](https://developer.roblox.com/en-us/api-reference/class/ManualWeld), [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap), [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), and [Motor6Ds](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connected to this part will have the matching [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) property updated and to allow the part to move relative to any other parts it is joined to.
*
* WeldConstraints will also be temporarily disabled and re-enabled during the move.
*
* Tags: Hidden, NotReplicated
*/
Position: Vector3;
/**
* This returns the time in seconds since the part's physics got last updated on the local client (or the server). Returns 0 when the part has no physics (Anchored)
*
* Tags: Hidden, NotReplicated
*/
readonly ReceiveAge: number;
/**
* The Reflectance property determines how much a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) reflects the skybox. A value of 0 indicates the part is not reflective at all, and a value of 1 indicates the part should fully reflect.
*
* Reflectance is not affected by [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency), unless the part is fully transparent, in which case reflectance will not render at all. Reflectance may or may not be ignored depending on the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) of the part.
*/
Reflectance: number;
/**
* The ResizeIncrement property is a read-only property that describes the smallest change in size allowable by the [BasePart:Resize](https://developer.roblox.com/en-us/api-reference/function/BasePart/Resize) method. It differs between implementations of the `/BasePart` abstract class. For instance, `/Part` has this set to 1 and `/TrussPart` has this set to 2 (since individual truss sections are 2x2x2 in size).
*
* Tags: NotReplicated
*/
readonly ResizeIncrement: number;
/**
* The ResizeableFaces property (with an **e**, not ResizableFaces) describes using a Faces object the different faces on which a part may be resized. For most implementations of `/BasePart`, such as `/Part` and `/WedgePart`, this property includes all faces. However, `/TrussPart` will set its ResizeableFaces set to only two faces since those kinds of parts must have two [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) dimensions of length 2. This property is most commonly used with tools used for building and manipulating parts and has little use outside of that context. The `/Handles` class, which has the [Handles.Faces](https://developer.roblox.com/en-us/api-reference/property/Handles/Faces) property, can be used in conjunction with this property to display only the handles on faces that can be resized on a part.
*
* Tags: NotReplicated
*/
readonly ResizeableFaces: Faces;
/**
* The RightParamA property is relevant when a part's [BasePart.RightSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurface) is set to Motor or SteppingMotor and [BasePart.RightSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
RightParamA: number;
/**
* The RightParamB property is relevant when a part's [BasePart.RightSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurface) is set to Motor or SteppingMotor and [BasePart.RightSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
RightParamB: number;
/**
* The RightSurface property determines the type of surface used for the +X direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.RightSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
RightSurface: Enum.SurfaceType;
/**
* The RightSurfaceInput property determines the kind of input provided to a part's [BasePart.RightSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.RightParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightParamA) and [BasePart.RightParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/RightParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
RightSurfaceInput: Enum.InputType;
/**
* This property is the main rule in determining the root part of an assembly. It is an integer between -127 and 127 that takes precedence over all other rules for root part sort (including the weird rules based on part [size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size)). A part with a higher RootPriority will take priority over other [unanchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) parts with equal [Massless](https://developer.roblox.com/en-us/api-reference/property/BasePart/Massless) values and a lower RootPriority.
*
* 
*
* Use this to control which part of an assembly is the root part and keep the root part stable if size changes.
*
* See also
* --------
*
* * [Understanding Root Parts](https://developer.roblox.com/en-us/articles/understanding-root-parts), an article documenting what root parts are and how to use them
*/
RootPriority: number;
/**
* The RotVelocity of a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) describes how its [BasePart.Orientation](https://developer.roblox.com/en-us/api-reference/property/BasePart/Orientation) is presently changing. In other words, this property describes how the fast part is rotating. The part only rotates if it is not anchored.
*
* The unit of this property is **radians per second**.
*
* Using this in conjunction with [AlignOrientation](https://developer.roblox.com/en-us/api-reference/class/AlignOrientation) allows for aligned parts to have matching RotVelocity and Orientation values.
*
* Tags: Hidden
* @deprecated Use `AssemblyAngularVelocity` instead
*/
RotVelocity: Vector3;
/**
* The rotation of the part in degrees for the three axes.
*
* When setting this property any [Welds](https://developer.roblox.com/en-us/api-reference/class/Weld), [ManualWelds](https://developer.roblox.com/en-us/api-reference/class/ManualWeld), [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap), [Motor](https://developer.roblox.com/en-us/api-reference/class/Motor), and [Motor6Ds](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connected to this part will have the matching [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0)/[C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) property updated and to allow the part to move relative to any other parts it is joined to.
*
* WeldConstraints will also be temporarily disabled and re-enabled during the move.
*
* Tags: NotReplicated
*/
Rotation: Vector3;
/**
* The Size property determines the dimensions of a part. The individual dimensions can go as low as 0.05 and as high as 2048 (or 2^11). The size of the part is used in determining its mass, which is given by [BasePart:GetMass](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetMass). The `/BasePart/Shape` of a part can apply some restrictions on Size - namely, a Ball must have the same 3 dimensions. A part's Size is used by a variety of other objects:
*
* * `/ParticleEmitter` uses Size to determine the area from which particles are spawned.
* * `/BlockMesh` uses Size to partially determine the rendered rectangular prism.
* * `/SpecialMesh` uses Size for some certain [SpecialMesh.MeshType](https://developer.roblox.com/en-us/api-reference/property/SpecialMesh/MeshType)s to determine the size of the rendered mesh.
* * `/SurfaceLight` uses Size to determine the space to illuminate.
*
* Tags: NotReplicated
*/
Size: Vector3;
/**
* The ratio of the part's density to the density of water determined by the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material). Effects the part's behavior when in a water terrain cell. Essentially, SpecificGravity refers to how many times more dense a part is than water.
*
* Material
*
* SpecificGravity
*
* Plastic
*
* 0.7
*
* Wood
*
* 0.35
*
* Slate
*
* 2.7
*
* Concrete
*
* 2.4
*
* CorrodedMetal
*
* 7.85
*
* DiamondMetal
*
* 7.85
*
* Foil
*
* 7.6
*
* Grass
*
* 0.9
*
* Ice
*
* 0.91
*
* Marble
*
* 2.56
*
* Granite
*
* 2.7
*
* Brick
*
* 1.92
*
* Pebble
*
* 2.4
*
* Sand
*
* 1.6
*
* Fabric
*
* 0.7
*
* SmoothPlastic
*
* 0.7
*
* Metal
*
* 7.85
*
* WoodPlanks
*
* 0.35
*
* Cobblestone
*
* 2.7
*
* Tags: NotReplicated
* @deprecated
*/
readonly SpecificGravity: number;
/**
* The TopParamA property is relevant when a part's [BasePart.TopSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurface) is set to Motor or SteppingMotor and [BasePart.TopSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurfaceInput) is set to Sin. It determines the **amplitude** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamA * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
TopParamA: number;
/**
* The TopParamB property is relevant when a part's [BasePart.TopSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurface) is set to Motor or SteppingMotor and [BasePart.TopSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurfaceInput) is set to Constant or Sin. For Constant, it determines the constant rotational velocity of the motor. For Sin, it determines the **frequency** of the motor's rotational velocity, using the following formula:
*
* `MotorVelocity = ParamB * math.sin(workspace.DistributedGameTime * ParamB)`
*
* In no other cases is this property used.
*
* Tags: Hidden
* @deprecated
*/
TopParamB: number;
/**
* The TopSurface property determines the type of surface used for the +Y direction of a part. When two parts' faces are placed next to each other, they may create a joint between them. If set to Motor, the [BasePart.TopSurfaceInput](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurfaceInput) determines how a motor joint should behave.
*
* Most SurfaceTypes render a texture on the part face if the [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) is set to Plastic. Some SurfaceTypes - Hinge, Motor and SteppingMotor - will render a 3D adornment instead. If this property is selected in the Properties window, it will be highlighted in the game world similar to that of a `/SurfaceSelection`.
*/
TopSurface: Enum.SurfaceType;
/**
* The TopSurfaceInput property determines the kind of input provided to a part's [BasePart.TopSurface](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopSurface). This is only relevant for Motor or SteppingMotor SurfaceTypes. This property determines how [BasePart.TopParamA](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopParamA) and [BasePart.TopParamB](https://developer.roblox.com/en-us/api-reference/property/BasePart/TopParamB) are used. For brevity, these properties will be referred to as ParamA and ParamB, respectively.
*
* * By default, this is set to NoInput. This stops the motor altogether,
* * For Constant, the motor rotates at a constant velocity equal to `ParamB`.
* * For Sin, the motor rotates at a velocity equal to `ParamA * math.sin(workspace.DistributedGameTime * ParamB)`. See [Workspace.DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime).
*
* Tags: Hidden
* @deprecated
*/
TopSurfaceInput: Enum.InputType;
/**
* The Transparency property controls the visibility of a part on a scale of 0 to 1, where 0 is completely visible (opaque), and a value of 1 is completely invisible (not rendered at all).
*
* [BasePart.Reflectance](https://developer.roblox.com/en-us/api-reference/property/BasePart/Reflectance) can reduce the overall transparency of a brick if set to a value close to 1.
*
* While fully transparent parts are not rendered at all, partially transparent objects have some significant rendering costs. Having many translucent parts may slow down the game's performance.
*
* When transparent parts overlap, render order can act unpredictable - try to keep semi-transparent parts from overlapping to avoid this.
*
* The [BasePart.LocalTransparencyModifier](https://developer.roblox.com/en-us/api-reference/property/BasePart/LocalTransparencyModifier) is a multiplier to Transparency that is only visible to the local client.
*/
Transparency: number;
/**
* The Velocity of a part describes how its [BasePart.Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) is presently changing. The unit of this property is **studs per second**. For reference, the default Roblox character moves at 16 studs per second via [Humanoid.WalkSpeed](https://developer.roblox.com/en-us/api-reference/property/Humanoid/WalkSpeed). The acceleration due to gravity is found in [Workspace.Gravity](https://developer.roblox.com/en-us/api-reference/property/Workspace/Gravity) (by default, -196.2 studs per second).
*
* Setting the Velocity of an part that is [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) will cause it to act like a conveyor belt. Any object that touches the part will begin to move in accordance with the Velocity.
*
* Some `/BodyMover` objects will apply forces and thus change the Velocity of a part over time. The simplest of these is a `/BodyForce` which can be used to counteract the acceleration due to gravity on a single part (set the +Y axis of the [BodyForce.Force](https://developer.roblox.com/en-us/api-reference/property/BodyForce/Force) to the product of the mass ([BasePart:GetMass](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetMass)) and the gravity constant).
*
* Tags: Hidden
* @deprecated Use `AssemblyLinearVelocity` instead
*/
Velocity: Vector3;
AngularAccelerationToTorque(this: BasePart, angAcceleration: Vector3, angVelocity?: Vector3): Vector3;
/**
* Applies an instant angular force impulse to this [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) assembly, causing the assembly to spin.
*
* The resulting angular velocity from the impulse relies on the assembly's [mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyMass). So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where you want a force applied instantly, such as an explosion or collision.
*
* If the part is owned by the server, this function must be called on a server [Script](https://developer.roblox.com/en-us/api-reference/class/Script). If the part is owned by a client, this function must be called on a \`LocalScript\`\`.
*/
ApplyAngularImpulse(this: BasePart, impulse: Vector3): void;
/**
* This function applies an instant force impulse to this [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) assembly.
*
* The force is applied at the assembly's [center of mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyCenterOfMass), so the resulting movement will only be linear.
*
* The resulting velocity from the impulse relies on the assembly's [mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyMass). So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where you want a force applied instantly, such as an explosion or collision.
*
* If the part is owned by the server, this function must be called on a server [Script](https://developer.roblox.com/en-us/api-reference/class/Script). If the part is owned by a client, this function must be called on a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*/
ApplyImpulse(this: BasePart, impulse: Vector3): void;
/**
* This function pplies an instant force impulse to this [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) assembly, at the specified position in world space.
*
* If the position is not at the assembly's [center of mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyCenterOfMass), the impulse will cause a positional and rotational movement.
*
* The resulting velocity from the impulse relies on the assembly's [mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/AssemblyMass). So a higher impulse is required to move more massive assemblies. Impulses are useful for cases where developers want a force applied instantly, such as an explosion or collision.
*
* If the part is owned by the server, this function must be called on a server [Script](https://developer.roblox.com/en-us/api-reference/class/Script). If the part is owned by a client, this function must be called on a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*/
ApplyImpulseAtPosition(this: BasePart, impulse: Vector3, position: Vector3): void;
/**
* Breaks any surface connection with any adjacent part, including [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) and other [JointInstance](https://developer.roblox.com/en-us/api-reference/class/JointInstance).
* @deprecated
*/
BreakJoints(this: BasePart): void;
/**
* Returns whether the parts can collide with each other or not. This function takes into account the collision groups of the two parts.
*
* This function will error if the specified part is not a BasePart.
*/
CanCollideWith(this: BasePart, part: BasePart): boolean;
/**
* The CanSetNetworkOwnership function checks whether you can set a [part's](https://developer.roblox.com/en-us/api-reference/class/BasePart) network ownership.
*
* The function's return value verifies whether or not you can call [BasePart:SetNetworkOwner](https://developer.roblox.com/en-us/api-reference/function/BasePart/SetNetworkOwner) or [BasePart:SetNetworkOwnershipAuto](https://developer.roblox.com/en-us/api-reference/function/BasePart/SetNetworkOwnershipAuto) without encountering an error. It returns true if you can modify/read the network ownership, or returns false and the reason you can't, as a string.
*
* ##See Also
*
* * [Network ownership](https://developer.roblox.com/articles/Network-Ownership)
*/
CanSetNetworkOwnership(this: BasePart): LuaTuple<[boolean, string | undefined]>;
GetClosestPointOnSurface(this: BasePart, position: Vector3): Vector3;
/**
* Returns a table of parts connected to the the object by any kind of rigid joint.
*
* If _recursive_ is true this function will return all of the parts in the assembly rigidly connected to the BasePart.
*
* Rigid Joints
* ------------
*
* When a joint connects two parts together `(Part0 → Part1)`, a joint is **rigid** if the physics of `Part1` are completely locked down by `Part0`.
* This only applies to the following joint types:
*
* * \`Weld\`
* * \`Snap\`
* * \`ManualWeld\`
* * \`Motor\`
* * \`Motor6D\`
* * \`WeldConstraint\`
*/
GetConnectedParts(this: BasePart, recursive?: boolean): Array;
/**
* Return all Joints or Constraints that is connected to this Part.
*/
GetJoints(this: BasePart): Array;
/**
* **GetMass** returns the value of the read-only [Mass](https://developer.roblox.com/en-us/api-reference/property/BasePart/Mass) property.
*
* This function predates the Mass property. It remains supported for backward-compatibility; you should use the Mass property directly.
*/
GetMass(this: BasePart): number;
/**
* Returns the current player who is the network owner of this part, or nil in case of the server.
*/
GetNetworkOwner(this: BasePart): Player | undefined;
/**
* Returns true if the game engine automatically decides the network owner for this part.
*/
GetNetworkOwnershipAuto(this: BasePart): boolean;
GetNoCollisionConstraints(this: BasePart): Array;
/**
* This function used to be relevant when Roblox's lag-compensating interpolation of parts online was internal. The interpolation is now applied to the `CFrame` directly.
* @deprecated
*/
GetRenderCFrame(this: BasePart): CFrame;
/**
* Returns the base part of an assembly (a collection of parts connected together). When moving an assembly of parts using a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame). it is important to move this base part (this will move all other parts connected to it accordingly).
*
* Every Assembly has a root part. When a [JointInstance's](https://developer.roblox.com/en-us/api-reference/class/JointInstance) C0/C1 is modified the root part will stay where it was.
*
* How the root part is determined
* -------------------------------
*
* The root part is picked based on the surface area of the largest face of a part's object aligned bounding box (defined by Size). A Humanoid's `HumanoidRootPart` has a 10x multiplier and a [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) has a 20x multiplier. All else being equal it will sort based on the replicated internal ID of the part. Root selection is deterministic and has to be because we rely on it for physics replication, but externally it's effectively random. Basically it's impossible for you to determine which part will be root ahead of time.
*
* Caution
* -------
*
* You should avoid relying on a particular part being root and generally try to write code that works agnostic of this. For example: the newer [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) avoids this by forcing you to position the two parts correctly how you want relative to each other, and just locks that relative orientation in as soon as it is enabled. It doesn't matter which part is root. You move the parts how you want to and we make sure it stays that way.
*
* You should avoid relying on specifics of this implementation where possible.
*/
GetRootPart(this: BasePart): BasePart;
/**
* Returns a table of all parts that are physically interacting with this part. If the part itself has CanCollide set to false, then this function will return an empty table UNLESS it has a `TouchInterest` (AKA: Something is connected to its Touched event). Parts that are adjacent but not intersecting are not considered touching.
*/
GetTouchingParts(this: BasePart): Array;
GetVelocityAtPosition(this: BasePart, position: Vector3): Vector3;
/**
* Returns true if the object is connected to a part that will hold it in place (eg an [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) part), otherwise returns false.
*/
IsGrounded(this: BasePart): boolean;
/**
* **Deprecated**
*
* SurfaceType based joining is deprecated, do not use MakeJoints for new projects. [WeldConstraints](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) and [HingeConstraints](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) should be used instead
*
* Creates a joint on any side of the [Part](https://developer.roblox.com/en-us/api-reference/class/BasePart) that has a [SurfaceType](https://developer.roblox.com/en-us/api-reference/enum/SurfaceType) that can make a joint it will create a joint with any adjacent parts.
*
* Joints will be created between the sides and any planar touching surfaces, depending on the sides' surfaces.
*
* * Smooth surfaces will not create joints
* * Glue surfaces will create a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue) joint
* * Weld will create a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) joint with any surface except for Unjoinable
* * Studs, Inlet, or Universal will each create a [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap) joint with either of other the other two surfaces (e.g. Studs with Inlet and Universal)
* * Hinge and Motor surfaces create [Rotate](https://developer.roblox.com/en-us/api-reference/class/Rotate) and [RotateV](https://developer.roblox.com/en-us/api-reference/class/RotateV) joint instances
*
* Unlike [Model:MakeJoints](https://developer.roblox.com/en-us/api-reference/function/Model/MakeJoints), this function requires an array of parts as a parameter. This array is given as follows:
*
* part:MakeJoints({part1, part2, part3})
*
* Joints are broken if enough force is applied to them due to an [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion), unless a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) object is parented to the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or ancestor [Model](https://developer.roblox.com/en-us/api-reference/class/Model). For this reason, they are often used to make simple destructible buildings and other models.
* @deprecated
*/
MakeJoints(this: BasePart): void;
/**
* Changes the size of an object just like using the Studio resize tool.
*/
Resize(this: BasePart, normalId: CastsToEnum, deltaAmount: number): boolean;
/**
* Sets the given player as network owner for this and all connected parts.
*
* When playerInstance is nil, the server will be the owner instead of a player.
*
*
*
* See Also
* --------
*
* * [NetworkOwnership](https://developer.roblox.com/articles/Network-Ownership "NetworkOwnership")
*/
SetNetworkOwner(this: BasePart, playerInstance?: Player): void;
/**
* Lets the game engine dynamically decide who will handle the part's physics (one of the clients or the server).
*/
SetNetworkOwnershipAuto(this: BasePart): void;
TorqueToAngularAcceleration(this: BasePart, torque: Vector3, angVelocity?: Vector3): Vector3;
/**
* Tags: Yields
*/
IntersectAsync(this: BasePart, parts: Array, collisionfidelity?: CastsToEnum, renderFidelity?: CastsToEnum): Instance | undefined;
/**
* **SubtractAsync** creates new [UnionOperation](https://developer.roblox.com/en-us/api-reference/class/UnionOperation) which occupies the same space as the part minus the space(s) occupied by the parts in the given array. It does this by invoking the real-time CSG solver. Similar to [Clone](https://developer.roblox.com/en-us/api-reference/function/Instance/Clone), the returned object has no [Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) set.
*
* The following image depicts an example of a SubtractAsync operation: the yellow part on the left has SubtractAsync called with a table containing the two pink parts. The resulting UnionOperation is moved to the right, as it would otherwise overlap the original part and not be visible. Notice the missing concave pieces that match the spaces once occupied by the pink parts.
*
* local yellowPart = workspace.YellowPart
* local pinkParts = {workspace.PinkPart, workspace.PinkPart2}
* local union = yellowPart:SubtractAsync(pinkParts)
* union.Parent = workspace
*
* Tags: Yields
*/
SubtractAsync(
this: BasePart,
parts: Array,
collisionfidelity?: CastsToEnum,
): UnionOperation | undefined;
/**
* This is a server-only function that uses [CSG](https://developer.roblox.com/en-us/articles/3d-modeling-with-parts) to combine the geometry of the calling [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) with a table of other BaseParts.
* The following properties from the calling part will be applied to the resulting part:
*
* * Color
* * Material
* * Reflectance
* * Transparency
*
* * Anchored
* * CanCollide
* * Density
* * Friction
*
* * Elasticity
* * FrictionWeight
* * ElasticityWeight
*
* The resulting union instance will have a null parent and will be named “Union”. If the resulting union's [PartOperation.UsePartColor](https://developer.roblox.com/en-us/api-reference/property/PartOperation/UsePartColor) is false, it is rendered with face colors. Face colors of the result come from colors of its constituent parts. Its [UsePartColor](https://developer.roblox.com/en-us/api-reference/property/PartOperation/UsePartColor) property defaults to false and its `PartOperation/CollisionFidelity|CollisionFidelity` matches the provided enum.
*
* The original parts remain in the same state and location in the game's tree as before operation.
*
* The code snippet below demonstrates how to perform the operation as described above:
*
* local part = workspace.Part1
* local otherParts = {workspace.Part2, workspace.Part3, workspace.Part4}
*
* -- Perform union operation
* local newUnion = part:UnionAsync(otherParts)
*
* The image below visualizes parts before and after the operation. The green parts are combined with the grey part.
*
* 
*
* Note that if a [NegateOperation](https://developer.roblox.com/en-us/api-reference/class/NegateOperation) is provided, it will also be unioned additively. For subtraction, use [SubtractAsync()](https://developer.roblox.com/en-us/api-reference/function/BasePart/SubtractAsync).
*
* The original parts remain unchanged following a successful union operation. In most cases, you should destroy all of the original parts and parent the returned [UnionOperation](https://developer.roblox.com/en-us/api-reference/class/UnionOperation) to the same place as the calling [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* Potential Errors
* ----------------
*
* * There is a limit to how many parts can be generated. If a union operation would result in a part with more than 5000 triangles, it will fail and Studio will alert you to the error in the Output window.
* * A part made with solid modeling can only use **one** color and material. If you union two parts with different colors/materials, the result will use the characteristics of just one of the parts.
* * A unioned or negated part can only be scaled uniformly (all of the dimensions must be scaled at the same proportion). If you need to change the size of just one part in a solid model construction, it may be easier to un-union that part, resize it, and then redo the union process.
* * This function can only be called from the server. It cannot be called by the client.
* * All parts must be supported by CSG. Only \`BasePart|BaseParts\` are supported, not \`Terrain\` or meshes. If A union operation involving any non-supported part will fail and Studio will alert you to the error in the Output window.
* * The resulting union cannot be empty due to subtractions. If a union operation would result in an empty part, it will fail and Studio will alert you to the error in the Output window.
*
* Solid-Modeling Playground
* -------------------------
*
* Now that you understand basic in-game solid modeling, experience it within a sample place!
*
* [](https://www.roblox.com/games/2309627316/Rotating-Windows)
*
* #### Rotating Windows
*
* Blast pieces out of rotating windows or fuse new material onto them. Includes a helper module script that rebuilds mechanisms with constraints and attachments!
*
* See also
* --------
*
* * [In Game Solid Modeling](https://developer.roblox.com/en-us/articles/in-game-solid-modeling), create custom plugins for solid modeling techniques like unions, negations, and separations
* * [3D Modeling with Parts](https://developer.roblox.com/en-us/articles/3d-modeling-with-parts), how to combine and subtract parts to create complex solid shapes
* * [Making an Arch](https://developer.roblox.com/en-us/articles/making-an-arch), make an arch for your environment using the Negate tool
*
* Tags: Yields
*/
UnionAsync(
this: BasePart,
parts: Array,
collisionfidelity?: CastsToEnum,
): UnionOperation;
/**
* Fired when another part comes in contact with another object. This event only sends data to the client notifying it that two parts have collided, whereas [BasePart.Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched) sends data to the server.
* @deprecated
*/
readonly LocalSimulationTouched: RBXScriptSignal<(part: BasePart) => void>;
/**
* Fired if the part's appearance is affected by the [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt) class.
* @deprecated
*/
readonly OutfitChanged: RBXScriptSignal<() => void>;
/**
* .
* @deprecated Use `TouchEnded` instead
*/
readonly StoppedTouching: RBXScriptSignal<(otherPart: BasePart) => void>;
/**
* Fired when a [part](https://developer.roblox.com/en-us/api-reference/class/BasePart) stops touching another part. This event fires under similar conditions to those of [BasePart.Touched](https://developer.roblox.com/en-us/api-reference/event/BasePart/Touched).
*/
readonly TouchEnded: RBXScriptSignal<(otherPart: BasePart) => void>;
/**
* The Touched event fires when a part comes in contact with another part. For instance, if PartA bumps into PartB, then PartA.Touched fires with PartB, and PartB fires with PartA.
*
* This event only fires as a result of physics movement, so it will not fire if the CFrame property was changed such that the part overlaps another part. This also means that at least one of the parts involved must not be [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) at the time of the collision.
*
* Many types of parts are removed or destroyed as soon as they hit another part. This means that it is possible for the other part's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to be nil. Be sure to check that `otherPart.Parent` is not nil before using it, such as calling [Instance:FindFirstChild](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChild).
*/
readonly Touched: RBXScriptSignal<(otherPart: BasePart) => void>;
}
/** This is a corner piece which has the same properties as a [Part](https://developer.roblox.com/en-us/api-reference/class/Part). */
interface CornerWedgePart extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CornerWedgePart: unique symbol;
}
/** The FormFactorPart class is an abstract class. It inherits from the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) class and adds the [FormFactorPart.FormFactor](https://developer.roblox.com/en-us/api-reference/property/FormFactorPart/FormFactor) property to classes that inherit from it.
*
* The FormFactor property has been deprecated, so this class has been deprecated as well.
*/
interface FormFactorPart extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FormFactorPart: unique symbol;
/**
* This used to specify a grid constraint of the part's size. No longer does anything.
*
* Tags: NotReplicated
* @deprecated
*/
FormFactor: Enum.FormFactor;
}
/** What is a Part
* --------------
*
* The Part object is a physical object. When it is in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace), it will move and interact with other Parts. It can have bonds formed with other Parts, so that the two Parts stay in the same relative position.
*
* Parts are the basic building blocks of any Roblox place. Commonly known as **bricks**, you'll see these the most often of any other objects as almost every place is built out of these. It is possible to stretch a Part to very large sizes and use them for baseplates, or make them very small and use them to create cool looking [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool).
*
* How can I edit a Part
* ---------------------
*
* The Part object can be edited using the various studio tools. It is available via either the insert menu, or the _Object Insert menu_. It can also be created using the function:
*
* Instance.new("Part")
*
* How do I create different shaped Parts
* --------------------------------------
*
* Using the Mesh objects, such as [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh), [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh), or [CylinderMesh](https://developer.roblox.com/en-us/api-reference/class/CylinderMesh) objects you can change the shape of them. Using the [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) or [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture) objects, you can place pictures on top of the bricks.
*
* Changing Parts using scripts
* ----------------------------
*
* There are many scripting opportunities using the Part object. Many of the other scripting objects, such as [BodyForce](https://developer.roblox.com/en-us/api-reference/class/BodyForce) objects operate inside of a Part or other physics based objects. Editing the Part's properties through a script can result in a lot of fun opportunities.
*/
interface Part extends FormFactorPart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Part: unique symbol;
/**
* The Shape property sets the type of shape the object has.
*
* The [PartType](https://developer.roblox.com/en-us/api-reference/enum/PartType) enum controls the shape value, and has three possible shapes:
*
* Shape/Value
*
* Description
*
* Ball
*
* A spherical shape, like a basketball.
*
* Cylinder
*
* A rod-like shape, like a tin can.
*
* Block
*
* The default, brick shape.
*
* To obtain custom part shapes, you can use a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) instead of a [Part](https://developer.roblox.com/en-us/api-reference/class/Part).
*
* Tags: NotReplicated
*/
Shape: Enum.PartType;
}
/** The Platform object creates a brick that when touched by a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) will anchor their torso to the brick. This allows for the creation of vehicles that players can stand in and not be flung about the cabin/deck of the vehicle.
*
* The Platform is almost identical to the [Seat](https://developer.roblox.com/en-us/api-reference/class/Seat) object, except that instead of sitting down the player will be standing while locked in place. Good for ships.
*
* The Platform object is very useful for making people's characters staying in one spot while they move around, such as a ship or truck. When a player touches the Platform a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) constraint is created, so they are 'attached' to the Platform and can't move until that weld is broken. It can be removed by hitting the spacebar, when the player jumps to exit the Platform.
*/
interface Platform extends Part {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Platform: unique symbol;
/**
* Tags: Hidden
*/
readonly RemoteCreateMotor6D: RBXScriptSignal<(humanoid: Humanoid) => void>;
/**
* Tags: Hidden
*/
readonly RemoteDestroyMotor6D: RBXScriptSignal<() => void>;
}
/** A type of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that a player character can 'sit' in. When a character touches an enabled Seat object, it will be attached to the part by a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) and the default character scripts will play a sitting animation.
*
* How do Seats work?
* ------------------
*
* When a model containing a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) and a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) called 'HumanoidRootPart' (generally a player character) touches a seat, a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) is created between the seat and the part. The [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C0) and [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) properties are configured so that the character is welded 2 studs above the seat. This weld is named 'SeatWeld' and parented to the seat.
*
* When sitting the [Seat.Occupant](https://developer.roblox.com/en-us/api-reference/property/Seat/Occupant) property is set to the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) that is 'sitting' in the seat. Furthermore the [Humanoid.SeatPart](https://developer.roblox.com/en-us/api-reference/property/Humanoid/SeatPart) property of the humanoid is set to the seat.
*
* A character can also be forced to sit in a seat using the [Seat:Sit](https://developer.roblox.com/en-us/api-reference/function/Seat/Sit) function.
*
* There are two ways for a character to get out of a seat. When a player jumps, they are removed from the seat. However this can also be done manually by destroying the seat weld, for example:
*
* ```lua
* seat:FindFirstChild("SeatWeld"):Destroy()
* ```
*
* Note seats have a cooldown (currently 3 seconds) that is on a per-character per-seat basis. This means once a character has gotten out of a seat they cannot sit back on the same seat for 3 seconds. This cooldown behavior may change and should not be relied upon by developers.
*
* What can Seats be used for?
* ---------------------------
*
* Seats have a diverse range of uses, ranging from the obvious to the more unconventional.
*
* * Creating chairs or benches without the need for any programming
* * Allowing characters to 'sit' in moving objects such as vehicles without getting flung around
* * Creating interfaces that are controlled by the character in the seat using the [Seat.Occupant](https://developer.roblox.com/en-us/api-reference/property/Seat/Occupant) property
*/
interface Seat extends Part {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Seat: unique symbol;
/**
* Whether or not the seat is usable. If set to true, the seat will act as a normal part.
*/
Disabled: boolean;
/**
* The humanoid that is sitting in the seat
*
* Tags: NotReplicated
*/
readonly Occupant: Humanoid | undefined;
/**
* Forces the character with the specified [Humanoid](https://developer.roblox.com/api-reference/class/Humanoid "Humanoid") to sit in the Seat.
*/
Sit(this: Seat, humanoid: Humanoid): void;
/**
* Tags: Hidden
*/
readonly RemoteCreateSeatWeld: RBXScriptSignal<(humanoid: Humanoid) => void>;
/**
* Tags: Hidden
*/
readonly RemoteDestroySeatWeld: RBXScriptSignal<() => void>;
}
/** A SkateboardPlatform can be used to create a skateboard. When characters get on a skateboard, they are stuck to it until they press the escape key. Until then, the character uses skateboard animations and travels faster than a walking character. */
interface SkateboardPlatform extends Part {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SkateboardPlatform: unique symbol;
/**
* The SkateboardPlatform's active SkateboardController.
*
* Tags: NotReplicated
*/
readonly Controller: SkateboardController | undefined;
/**
* The `/Humanoid` that is controlling the SkateboardPlatform.
*
* Tags: NotReplicated
*/
readonly ControllingHumanoid: Humanoid | undefined;
/**
* The direction of movement, tied to the keys A and D. Must be 1 (right), 0 (straight), or -1 (left). Will refresh back to 0 unless constantly set.
*/
Steer: number;
/**
* If true, wheels won't roll without user input.
*/
StickyWheels: boolean;
/**
* The direction of movement, tied to the keys W and S. Must be an integer 1 (forward), 0 (null), or -1 (reverse). Will refresh back to 0 unless constantly set.
*/
Throttle: number;
/**
* Adds ''impulseWorld'' to the SkateboardPlatform's [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity).
*/
ApplySpecificImpulse(this: SkateboardPlatform, impulseWorld: Vector3): void;
/**
* Fired when the skateboard is equipped.
*/
readonly Equipped: RBXScriptSignal<(humanoid: Humanoid, skateboardController: SkateboardController) => void>;
/**
* Fired when the SkateboardPlatform's [SkateboardPlatform.ControllingHumanoid](https://developer.roblox.com/en-us/api-reference/property/SkateboardPlatform/ControllingHumanoid) changes the force being used on the SkateboardPlatform.
*/
readonly MoveStateChanged: RBXScriptSignal<(newState: Enum.MoveState, oldState: Enum.MoveState) => void>;
/**
* Tags: Hidden
*/
readonly RemoteCreateMotor6D: RBXScriptSignal<(humanoid: Humanoid) => void>;
/**
* Tags: Hidden
*/
readonly RemoteDestroyMotor6D: RBXScriptSignal<() => void>;
/**
* Fired whenever the skateboard is unequipped.
*/
readonly Unequipped: RBXScriptSignal<(humanoid: Humanoid) => void>;
}
/** SpawnLocations, or “spawns” determine where a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) respawns when they die. They can be configured to allow only certain players to use each spawn, using [Teams](https://developer.roblox.com/en-us/api-reference/class/Team). They also control how [ForceFields](https://developer.roblox.com/en-us/api-reference/class/ForceField) are set up for newly-spawned players.
*
* SpawnLocations can be used as checkpoints, such as in an obstacle course, using the [SpawnLocation.AllowTeamChangeOnTouch](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/AllowTeamChangeOnTouch) property, so that when a player touches it, they will change teams to the SpawnLocation's team. In this case, only the first [Team](https://developer.roblox.com/en-us/api-reference/class/Team) should have [Team.AutoAssignable](https://developer.roblox.com/en-us/api-reference/property/Team/AutoAssignable) set to true, else players will not start at the first checkpoint.
*
* Note if a SpawnLocation is added to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) in Studio with [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) set to false a Team will be created corresponding to [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor) if it does not already exist. This behavior does not occur when spawns are created in-game using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or if the properties of the SpawnLocation are changed after already being added. It is recommended that developers always set up their teams manually and not rely on this behavior.
*
* Spawning Rules
* --------------
*
* There are several rules that come into play for a given SpawnLocation when a player respawns:
*
* * When [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) is set to false only [Players](https://developer.roblox.com/en-us/api-reference/class/Player) with [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) matching [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor) will respawn above it
* * When [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) is set to true any Player can spawn above it regardless of [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor)
* * If multiple eligible spawns are available to a [Player](https://developer.roblox.com/en-us/api-reference/class/Player), a random one will be chosen
* * Players will spawn at different points on top of a SpawnLocation, but currently, they may still spawn on top of each other if they spawn right after one and other
*
* See also
* --------
*
* * If you'd like to configure how long it takes for a player to respawn, take a look at the [RespawnTime](https://developer.roblox.com/en-us/api-reference/property/Players/RespawnTime) property
*/
interface SpawnLocation extends Part {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SpawnLocation: unique symbol;
/**
* Allows a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) to join the team by touching the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation). When set to true, if a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) character comes into contact with the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation), the player's [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) will be set to [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor). [Player.Neutral](https://developer.roblox.com/en-us/api-reference/property/Player/Neutral) will also be set to [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) upon contact, meaning a player can also become neutral by touching a spawn location.
*
* This will not function when [SpawnLocation.Enabled](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Enabled) is set to false.
*
* Making Checkpoints
* ------------------
*
* This feature is often used to make checkpoints in obstacle courses or similar games. See [Using Player Spawns](https://developer.roblox.com/en-us/articles/how-to-use-spawn-objects-with-roblox-studio) for details.
*/
AllowTeamChangeOnTouch: boolean;
/**
* The length of time, in seconds, that a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) will be applied to a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) character spawning at this [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation). If Duration is zero, the [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField) is never created, and it will not trigger the [Instance.DescendantAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/DescendantAdded) or [Instance.ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded) events.
*
* This default value of this property is 10 seconds.
*
* The duration feature allows developers to easily give [Player](https://developer.roblox.com/en-us/api-reference/class/Player)s protection from 'spawn killing' which can be a frustrating experience for players. Note, [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField)s will only protect users from [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion)s and Weapons that use [Humanoid:TakeDamage](https://developer.roblox.com/en-us/api-reference/function/Humanoid/TakeDamage) to deal damage or otherwise check for a [ForceField](https://developer.roblox.com/en-us/api-reference/class/ForceField).
*/
Duration: number;
/**
* Sets whether or not the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) is enabled. When disabled players cannot spawn at the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) and the [SpawnLocation.AllowTeamChangeOnTouch](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/AllowTeamChangeOnTouch) functionality is disabled.
*
* This property provides the most convenient way of preventing [Player](https://developer.roblox.com/en-us/api-reference/class/Player)s from spawning at a spawn.
*
* Note, although team changing on touch using [SpawnLocation.AllowTeamChangeOnTouch](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/AllowTeamChangeOnTouch) is disabled when Enabled is set to false, other touched events using `BasePart.Touched` will still fire.
*/
Enabled: boolean;
/**
* Whether or not a spawn is affiliated with a specific team. This means that any [Player](https://developer.roblox.com/en-us/api-reference/class/Player), of any [Team](https://developer.roblox.com/en-us/api-reference/class/Team), can spawn on it if this property is set to true.
*
* If Neutral is set to false, only players whose [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) is equal to [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor) can use the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation).
*
* If [SpawnLocation.AllowTeamChangeOnTouch](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/AllowTeamChangeOnTouch) is true [Player.Neutral](https://developer.roblox.com/en-us/api-reference/property/Player/Neutral) will be set to this property upon contact with the spawn.
*/
Neutral: boolean;
/**
* The TeamColor property sets what team the [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) is affiliated to. If [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) property is false, only [Player](https://developer.roblox.com/en-us/api-reference/class/Player)s with the same [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) as the spawn's TeamColor will be able to spawn there.
*
* If [SpawnLocation.AllowTeamChangeOnTouch](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/AllowTeamChangeOnTouch) is true [Player.Neutral](https://developer.roblox.com/en-us/api-reference/property/Player/Neutral) will be set to this property upon contact with the spawn.
*/
TeamColor: BrickColor;
}
/** WedgeParts are great for building slopes because of their slanted surface. They can even be rotated onto their slant so that they can be used at an angle to make a triangular ramp. Due to their collision, WedgeParts can be good for quickly rotating bricks to a certain angle within Roblox Studio, making them a quick solution to using scripting methods such as CFrame to perform the same function. WedgeParts can be adjusted to any size a regular brick can so that they can be aligned with the rest of your building work. WedgeParts, when used next to each other at different angles, can also make great curved ramps without the need for CFrame too */
interface WedgePart extends FormFactorPart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WedgePart: unique symbol;
}
/** Terrain lets you create dynamically morphable environments with little to no lag. It is currently based on a 4×4×4 grid of cells, where each cell has a number between 0 and 1 representing how much the geometry should occupy the cell, and the material of the cell. The occupancy determines how the cell will morph together with surrounding cells, and the result is the illusion of having no grid constraint.
*
* For more info, see [Importing Terrain Data](https://developer.roblox.com/en-us/articles/importing-terrain-data) and [Scripting Terrain](https://developer.roblox.com/en-us/articles/scripting-with-terrain).
*/
interface Terrain extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Terrain: unique symbol;
/**
* Returns true if the current game is using the smooth terrain system. The legacy terrain engine has been removed, so this property will always be true.
*
* Tags: NotReplicated
* @deprecated
*/
readonly IsSmooth: boolean;
/**
* Displays the boundaries of the largest possible editable region.
*
* Tags: NotReplicated
*/
readonly MaxExtents: Region3int16;
/**
* The tint of the Terrain water.
*/
WaterColor: Color3;
/**
* Controls how opaque the Terrain's water reflections are.
*/
WaterReflectance: number;
/**
* The transparency of the Terrain water.
*/
WaterTransparency: number;
/**
* Sets the maximum height of the Terrain water waves in studs. This is currently constrained to between 0 and 1.
*/
WaterWaveSize: number;
/**
* Sets how many times the Terrain water waves will move up and down per minute. This is currently constrained to between 0 and 100.
*/
WaterWaveSpeed: number;
/**
* _(OBSOLETE)_ No longer does anything.
* @deprecated
*/
AutowedgeCell(this: Terrain, x: number, y: number, z: number): boolean;
/**
* _(OBSOLETE)_ No longer does anything.
* @deprecated
*/
AutowedgeCells(this: Terrain, region: Region3int16): void;
/**
* Returns the world position of the center of the terrain cell (x, y, z).
*/
CellCenterToWorld(this: Terrain, x: number, y: number, z: number): Vector3;
/**
* Returns the position of the lower-left-forward corner of the grid cell (x, y, z).
*/
CellCornerToWorld(this: Terrain, x: number, y: number, z: number): Vector3;
/**
* Clears the terrain.
*/
Clear(this: Terrain): void;
/**
* Stores a chunk of terrain into a [TerrainRegion](https://developer.roblox.com/en-us/api-reference/class/TerrainRegion) object so it can be loaded back later. Note: [TerrainRegion](https://developer.roblox.com/en-us/api-reference/class/TerrainRegion) data does not replicate between server and client.
*/
CopyRegion(this: Terrain, region: Region3int16): TerrainRegion;
/**
* Returns the number of non-empty cells in the Terrain.
*/
CountCells(this: Terrain): number;
/**
* Fills a ball of smooth terrain in a given space.
*/
FillBall(this: Terrain, center: Vector3, radius: number, material: CastsToEnum): void;
/**
* Fills a block of smooth terrain with a given location, rotation, size, and material.
*/
FillBlock(this: Terrain, cframe: CFrame, size: Vector3, material: CastsToEnum): void;
/**
* Fills a cylinder of smooth terrain in a given space. The space is defined using a CFrame, height, and radius.
*
* Usage
* -----
*
* workspace.Terrain:FillCylinder(CFrame.new(0, 50, 0), 5, 30, Enum.Material.Asphalt)
*/
FillCylinder(this: Terrain, cframe: CFrame, height: number, radius: number, material: CastsToEnum): void;
/**
* Fills a [Region3](https://developer.roblox.com/api-reference/datatype/Region3 "Region3") space with smooth terrain.
*/
FillRegion(this: Terrain, region: Region3, resolution: number, material: CastsToEnum): void;
/**
* **FillWedge** fills a wedge-shaped volume of Terrain with the given [Material](https://developer.roblox.com/en-us/api-reference/enum/Material) and the area's CFrame and Size. The orientation of the wedge is the same as an equivalent [WedgePart](https://developer.roblox.com/en-us/api-reference/class/WedgePart).
*
* 
*
* In the image above, a floating chunk of Terrain was created by calling this function as in the following code. A transparent, pink part with the Front surface marked with a Motor indicates the provided CFrame and Size.
*
* workspace.Terrain:FillWedge(CFrame.new(0, 50, 0), Vector3.new(20, 20, 20), Enum.Material.Asphalt)
*/
FillWedge(this: Terrain, cframe: CFrame, size: Vector3, material: CastsToEnum): void;
/**
* Returns the closest CellMaterial from the legacy terrain engine that matches the smooth terrain voxel specified. CellBlock will always be ''Solid'' and CellOrientation will always be ''NegZ''.
* @deprecated
*/
GetCell(this: Terrain, x: number, y: number, z: number): unknown;
/**
* Returns the current terrain material color for the specified terrain material.
*/
GetMaterialColor(this: Terrain, material: CastsToEnum): Color3;
/**
* Returns if the cell is a water cell. The WaterForce parameter will always be _None_ and the WaterDirection will always be _NegX_.
* @deprecated
*/
GetWaterCell(this: Terrain, x: number, y: number, z: number): unknown;
/**
* Applies a chunk of terrain to the Terrain object. Note: [TerrainRegion](https://developer.roblox.com/en-us/api-reference/class/TerrainRegion) data does not replicate between server and client.
*/
PasteRegion(this: Terrain, region: TerrainRegion, corner: Vector3int16, pasteEmptyCells: boolean): void;
ReadVoxelChannels(this: Terrain, region: Region3, resolution: number, channelIds: Array): object;
/**
* Returns a certain region of [smooth terrain](https://developer.roblox.com/articles/Intro-To-Terrain) in [table format](https://developer.roblox.com/articles/Scripting-With-Terrain#reading-and-writing-voxels). Both of the returned arrays have an additional `Size` property, a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3).
*
* Tags: CustomLuaState
*/
ReadVoxels(
this: Terrain,
region: Region3,
resolution: number,
): LuaTuple<[ReadVoxelsArray, ReadVoxelsArray]>;
/**
* ReplaceMaterial replaces terrain of a certain [Material](https://developer.roblox.com/en-us/api-reference/enum/Material) within a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) with another material. Essentially, it is a find-and-replace operation on [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) materials.
*
* Constraints
* -----------
*
* When calling this method, the `resolution` parameter must be exactly 4. Additionally, the Region3 must be aligned to the terrain materials grid, i.e. the components of the Region3's minimum and maximum points must be divisible by 4. Use `Region3:ExpandToGrid` to make a region compatible with this function.
*/
ReplaceMaterial(this: Terrain, region: Region3, resolution: number, sourceMaterial: CastsToEnum, targetMaterial: CastsToEnum): void;
/**
* Sets the occupancy of the specified terrain voxel to 1, and sets it's material to the closest smooth terrain material that matches the CellMaterial.
*
* CellBlock and CellOrientation have no effect.
* @deprecated
*/
SetCell(this: Terrain, x: number, y: number, z: number, material: CastsToEnum, block: CastsToEnum, orientation: CastsToEnum): void;
/**
* Sets the occupancy of all terrain voxels in the specified region to 1, and sets their materials to the closest smooth terrain material that matches the CellMaterial.
*
* CellBlock and CellOrientation have no effect.
* @deprecated
*/
SetCells(this: Terrain, region: Region3int16, material: CastsToEnum, block: CastsToEnum, orientation: CastsToEnum): void;
/**
* Sets current terrain material color for specified terrain material. Terrain material will shift its base color toward specified color.
*/
SetMaterialColor(this: Terrain, material: CastsToEnum, value: Color3): void;
/**
* Sets the specified terrain voxel's material to ''Water'' and sets its occupancy to 1. _WaterDirection_ and _WaterForce_ no longer have any effect.
*
* _Note:_ This API was intended for Roblox's old terrain system, which has since been removed from the engine.
* @deprecated
*/
SetWaterCell(this: Terrain, x: number, y: number, z: number, force: CastsToEnum, direction: CastsToEnum): void;
/**
* Returns the grid cell location that contains the point **position**.
*/
WorldToCell(this: Terrain, position: Vector3): Vector3;
/**
* Returns the grid cell location that contains the point position, preferring empty grid cells when position is on a grid edge.
*/
WorldToCellPreferEmpty(this: Terrain, position: Vector3): Vector3;
/**
* Returns the grid cell location that contains the point position, preferring non-empty grid cells when position is on a grid edge.
*/
WorldToCellPreferSolid(this: Terrain, position: Vector3): Vector3;
WriteVoxelChannels(this: Terrain, region: Region3, resolution: number, channels: object): void;
/**
* Sets a certain region of [smooth terrain](https://developer.roblox.com/articles/Intro-To-Terrain "Smooth terrain") using the [table format](https://developer.roblox.com/articles/Intro-To-Terrain#Reading_and_writing_voxels "Smooth terrain")
*
* Tags: CustomLuaState
*/
WriteVoxels(
this: Terrain,
region: Region3,
resolution: number,
materials: Array>>>,
occupancy: Array>>,
): void;
}
/** TriangleMeshPart is an abstract intermediate class from which [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart) and [PartOperation](https://developer.roblox.com/en-us/api-reference/class/PartOperation) inherit. It was created to consolidate the management of physical geometry properties between the two sub-classes. It implements the read-only [CollisionFidelity](https://developer.roblox.com/en-us/api-reference/property/TriangleMeshPart/CollisionFidelity). */
interface TriangleMeshPart extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TriangleMeshPart: unique symbol;
/**
* This property determines how the collision model of the [TriangleMeshPart](https://developer.roblox.com/en-us/api-reference/class/TriangleMeshPart) relates to the actual geometry of the mesh. In situations where the collision model of a mesh is unimportant or precision isn't necessary, it is a good idea to set CollisionFidelity to 'Box' to improve performance.
*
* This property cannot be read or manipulated by scripts during run time.
*
* How CollisionFidelity Works
* ---------------------------
*
* [CollisionFidelity](https://developer.roblox.com/en-us/api-reference/enum/CollisionFidelity) has three options, the results of which are demonstrated in the image below.
*
* 
*
* A visual representation of a [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart)s collision model can be viewed by enabling [PhysicsSettings.ShowDecompositionGeometry](https://developer.roblox.com/en-us/api-reference/property/PhysicsSettings/ShowDecompositionGeometry) in Roblox Studio's Settings.
*
* Tags: NotReplicated
*/
CollisionFidelity: Enum.CollisionFidelity;
/**
* Tags: NotReplicated
*/
FluidFidelity: Enum.FluidFidelity;
/**
* Tags: NotReplicated
*/
readonly MeshSize: Vector3;
}
/** MeshParts are a form of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that includes a physically simulated custom mesh. Unlike with other mesh classes, such as [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) and [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh), they are not parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) but rather behave as a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) in their own right.
*
* How do I use MeshParts
* ----------------------
*
* The mesh and texture of a MeshPart are determined by the [MeshPart.MeshId](https://developer.roblox.com/en-us/api-reference/property/MeshPart/MeshId) and [MeshPart.TextureID](https://developer.roblox.com/en-us/api-reference/property/MeshPart/TextureID) properties. For more information on how to use MeshParts please see [here](https://developer.roblox.com/en-us/articles/mesh-parts).
*
* SpecialMesh or MeshPart?
* ------------------------
*
* There are currently two ways of using a developer created mesh. They are using a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) with the `SpecialMesh/FileType` set to 'FileMesh', or by using a MeshPart. Although, on the whole, the MeshPart object has superseded the SpecialMesh there are some differences developers should be aware of.
*
* * [BasePart.Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) displays correctly on the mesh when using a MeshPart and not when using a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh)
* * MeshParts include the `MeshPart/CollisionFidelity` property, meaning the collision model of a MeshPart can be set to resemble the geometry of the mesh. The [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) object by contrast, uses the parent [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s collision model
* * The mesh of a MeshPart scales on all axis depending on the [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) property of the MeshPart, the mesh of a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) does not
* * The [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) object includes the [DataModelMesh.Offset](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Offset) and [DataModelMesh.Scale](https://developer.roblox.com/en-us/api-reference/property/DataModelMesh/Scale) properties whereas MeshParts do not
* * The `DataModelMesh/MeshId` property of a [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh) can be changed by a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) during runtime. The [MeshPart.MeshId](https://developer.roblox.com/en-us/api-reference/property/MeshPart/MeshId) property of a MeshPart can not
*
* In most, but not all cases, using a MeshPart is more suitable. As MeshParts are a relatively new feature however, developers should expect some of the above behaviour to change.
*/
interface MeshPart extends TriangleMeshPart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_MeshPart: unique symbol;
/**
* This property determines whether to render both faces or polygons in the mesh. It is only changeable in Studio. This is useful for meshes that are typically modeled as cards such as a leaf, hair and cloth.
*
* Example:
* _The tree leaves are modeled with single sided cards._
* 
*
* _With MeshPart.DoubleSided disabled some leaves are missing since they are back facing the camera._
* 
*
* _With MeshPart.DoubleSided enabled, both faces of the leaves are rendered._
* 
*/
DoubleSided: boolean;
/**
* Tags: Hidden
*/
readonly HasJointOffset: boolean;
/**
* Tags: Hidden
*/
readonly HasSkinnedMesh: boolean;
/**
* Tags: Hidden
*/
readonly JointOffset: Vector3;
/**
* The **MeshId** is the content ID of the mesh that is to be displayed on the [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart).
*
* Note that this property currently cannot be changed by scripts as the collision model of the mesh cannot be recomputed during runtime. Developers should not rely on this behavior as it may change in the future. Those looking for a custom mesh object that can be updated during runtime should use [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh).
*/
readonly MeshId: string;
/**
* This property determines the level of detail that solid-modeled and mesh parts will be shown in and can be set to the possible values of the [RenderFidelity](https://developer.roblox.com/en-us/api-reference/enum/RenderFidelity) enum.
*
* By default, solid-modeled and mesh parts will always be shown in precise fidelity, no matter how far they are from the game camera. This improves their appearance when viewed from any distance, but if a place has a large number of detailed solid-modeled or mesh parts, it may reduce overall game performance.
*
* Distance From Camera
*
* Render Fidelity
*
* Less than 250 studs
*
* Highest
*
* 250-500 studs
*
* Medium
*
* 500 or more studs
*
* Lowest
*
* See also
* --------
*
* * [Improving Performance](https://developer.roblox.com/en-us/articles/improving-performance), an article discussing tips for analyzing and improving game performance
*
* Tags: NotReplicated
*/
RenderFidelity: Enum.RenderFidelity;
/**
* The texture applied to the [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart). When this property is set to an empty string, no texture will be applied to the mesh.
*
* MeshPart.TextureID = "" -- no texture
*
* Note, although the [MeshPart.MeshId](https://developer.roblox.com/en-us/api-reference/property/MeshPart/MeshId) property cannot be changed during runtime, the texture can.
*
* How can I change the texture of a mesh?
* ---------------------------------------
*
* Using the TextureId property, the texture of a mesh can be changed without having to reupload the mesh. To do this, a new image will need to be uploaded to Roblox with the desired texture. The original texture image file can be obtained by exporting the mesh using the 'Export Selection' option in Roblox Studio. The image file will be saved alongside the exported .obj file.
*
* The new texture can then be re-uploaded to Roblox as a Decal and its content ID can be applied to the mesh using the TextureId property.
*
* How can I make a textured mesh?
* -------------------------------
*
* A mesh can only be textured if the mesh has been UV mapped. UV mapping refers to the practice of projecting a texture map onto a mesh. This cannot be done using Roblox Studio and has to be done using an external 3D modelling application such as [Blender](https://www.blender.org/).
*/
TextureID: string;
ApplyMesh(this: MeshPart, meshPart: MeshPart): void;
}
/** An abstract class that all parts based on [solid modeling](https://developer.roblox.com/en-us/articles/3d-modeling-with-parts) inherit from. */
interface PartOperation extends TriangleMeshPart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PartOperation: unique symbol;
RenderFidelity: Enum.RenderFidelity;
/**
* This property represents an angle in degrees for a threshold value between face normals on a [solid modeled](https://developer.roblox.com/en-us/articles/3d-modeling-with-parts) part. If the normal difference is less than the value, normals will be adjusted to smooth the difference. Usually a value between 30 and 70 degrees will produce a good result. 0 degrees leads to sharp edges. Values between 90 and 180 degrees are allowed but not encouraged, as it may cause a “shadowing” effect on unions with sharp edges.
*
* Note that smoothing will not affect the normals between different materials or different colors.
*
* 
*
* SmoothingAngle = 0
*
* 
*
* SmoothingAngle = 50
*/
SmoothingAngle: number;
/**
* The number of polygons in this solid model. This value will always be <= 5000.
*
* Tags: NotReplicated
*/
readonly TriangleCount: number;
/**
* Sets whether the PartOperation can be recolored using the BrickColor property. When true, the entire Union will be colored as per [BasePart.BrickColor](https://developer.roblox.com/en-us/api-reference/property/BasePart/BrickColor). When false, the parts in the Union will maintain their original colors before the Union operation was performed.
*/
UsePartColor: boolean;
SubstituteGeometry(this: PartOperation, source: Instance): void;
}
interface IntersectOperation extends PartOperation {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_IntersectOperation: unique symbol;
}
/** The NegateOperation creates a CSG part that can be removed from other part via solid modeling. To use it, select a part and click the **Negate** button in the **Model** tab.
*
* 
*
* This will convert the part to a “negative part” (it will turn red and translucent to indicate this). If this negative part is unioned with a normal part using the **Union** tool, the section of the parts which overlap will be cut out.
*
* This function can be used in conjunction with [UnionOperation](https://developer.roblox.com/en-us/api-reference/class/UnionOperation) to shape, resize, and create holes in solid models. Combined parts can also be separated, allowing developers to revert (undo) the result of a unioned model.
*
* Note that you can undo part negation by selecting the negated part and clicking **Negate** again.
*
* See also
* --------
*
* * [Solid modeling](https://developer.roblox.com/articles/3D-Modeling-with-Parts), an article that dives into solid modeling and how it lets you create complex models from simple blocks, spheres, wedges, and cylinders
* * [In Game Solid Modeling](https://developer.roblox.com/articles/in-game-solid-modeling), an article discussing how developers can perform solid modeling live in-game as well as in Studio
*/
interface NegateOperation extends PartOperation {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_NegateOperation: unique symbol;
}
/** The UnionOperation combines parts together into a single solid model. To use it, select the parts you want to combine and click the **Union** button in the **Model** tab. This will create a new part called **Union**.
*
* 
*
* This function can be used in conjunction with [NegateOperation](https://developer.roblox.com/en-us/api-reference/class/NegateOperation) to shape, resize, and create holes in solid models. Combined parts can also be separated, allowing developers to revert (undo) the result of a unioned model.
*
* You should only use **Union** on basic parts (block, sphere, wedge, or cylinder). Also, these parts should **not** have any children such as scripts, surface GUIs, etc. If a part with children is unioned, the children will be hidden from the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel).
*
* See also
* --------
*
* * [Solid modeling](https://developer.roblox.com/articles/3D-Modeling-with-Parts), an article that dives into solid modeling and how it lets you create complex models from simple blocks, spheres, wedges, and cylinders
* * [In Game Solid Modeling](https://developer.roblox.com/articles/in-game-solid-modeling), an article discussing how developers can perform solid modeling live in-game as well as in Studio
*/
interface UnionOperation extends PartOperation {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_UnionOperation: unique symbol;
}
/** Truss parts are the same as [Parts](https://developer.roblox.com/en-us/api-reference/class/Part), except that they have a different visual style, resize differently and characters are able to climb them. The smallest size it can be is 2x2x2 studs.
*
* 
*
* The [style](https://developer.roblox.com/en-us/api-reference/property/TrussPart/Style) of a truss beam can be set to change its appearance.
*/
interface TrussPart extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_TrussPart: unique symbol;
/**
* Sets what the truss looks like. There are currently three different styles.
*
* Tags: NotReplicated
*/
Style: Enum.Style;
}
/** The VehicleSeat objects welds a player to the seat when the player touches the seat. It then forwards the movement keys to any connected motor joints, allowing control of a vehicle.
*
* While VehicleSeats are great for making simple vehicles they do have some limitations. Movement control will only detect motors connected directly to the vehicle seat, or through another rigid connection. This means that if you have a wheel connected to a beam which is then welded to the seat it will work fine, however if you have the wheel connected to a part, which is connected by a hinge to the rest of the car, it will not work.
*/
interface VehicleSeat extends BasePart {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_VehicleSeat: unique symbol;
/**
* Displays how many hinges are detected by the VehicleSeat. Useful for debugging vehicle designs.
*
* Tags: NotReplicated
*/
readonly AreHingesDetected: number;
/**
* Toggles whether the [VehicleSeat](https://developer.roblox.com/en-us/api-reference/class/VehicleSeat) is active or not.
*
* If the seat is disabled then it will not automatically weld a character to it on collision and will not allow a character to control the connected vehicle.
*/
Disabled: boolean;
/**
* If true, a fancy speed bar will be displayed speed on screen that tells you what speed the Vehicle is moving at.
*/
HeadsUpDisplay: boolean;
/**
* The maximum speed that can be attained.
*/
MaxSpeed: number;
/**
* The humanoid that is sitting in the seat
*
* Tags: NotReplicated
*/
readonly Occupant: Humanoid | undefined;
/**
* The direction of movement, tied to the keys A and D. Must be one of 1 (right), 0 (straight), or -1 (left). Will refresh back to 0 unless constantly set.
*
* Tags: NotReplicated
*/
Steer: number;
/**
* Functions identically to [VehicleSeat.Steer](https://developer.roblox.com/en-us/api-reference/property/VehicleSeat/Steer), but the value is not an integer.
*/
SteerFloat: number;
/**
* The direction of movement, tied to the keys W and S. Must be an integer 1 (forward) 0 (null) or -1 (reverse). Will refresh back to 0 unless constantly set.
*
* Tags: NotReplicated
*/
Throttle: number;
/**
* Functions identically to [VehicleSeat.Throttle](https://developer.roblox.com/en-us/api-reference/property/VehicleSeat/Throttle), but the value is not an integer.
*/
ThrottleFloat: number;
/**
* How fast the vehicles will be able to attain [VehicleSeat.MaxSpeed](https://developer.roblox.com/en-us/api-reference/property/VehicleSeat/MaxSpeed). The greater the number, the faster it will reach the maximum speed.
*/
Torque: number;
/**
* The speed at which the vehicle will turn. Higher numbers can cause problems and are not necessarily better.
*/
TurnSpeed: number;
/**
* Forces the character with the specified [Humanoid](https://developer.roblox.com/api-reference/class/Humanoid "Humanoid") to sit in the VehicleSeat.
*/
Sit(this: VehicleSeat, humanoid: Humanoid): void;
/**
* Tags: Hidden
*/
readonly RemoteCreateSeatWeld: RBXScriptSignal<(humanoid: Humanoid) => void>;
/**
* Tags: Hidden
*/
readonly RemoteDestroySeatWeld: RBXScriptSignal<() => void>;
}
/** Models are container objects, meaning they group objects together. They are best used to hold collections of [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and have a number of functions that extend their functionality.
*
* Models are intended to represent **geometric** groupings. If your grouping has no geometric interpretation, for instance a collection of [Scripts](https://developer.roblox.com/en-us/api-reference/class/Script), use a [Folder](https://developer.roblox.com/en-us/api-reference/class/Folder) instead.
*
* Models whose constituent parts are joined together with joints (so that they can move around or be destroyed via physics simulation) usually have a [PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) set, as it specifies which part within the model the pivot and bounding box will “follow” as the model moves. Static models which stay in one place do not benefit from having a primary part set.
*
* Models have a wide range of applications, including Roblox player characters. They also have a number of unique behaviors that are important to keep in mind:
*
* * When a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) and a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) named **Head** are parented under a model, a name/health GUI will appear over the model; see [Character Name/Health Display](https://developer.roblox.com/articles/character-name-health-display) for details.
* * If a part's position on the **Y** axis hits the [Workspace.FallenPartsDestroyHeight](https://developer.roblox.com/en-us/api-reference/property/Workspace/FallenPartsDestroyHeight) value, and it was the last object inside of a [Model](https://developer.roblox.com/en-us/api-reference/class/Model), the model will be destroyed as well.
*/
interface Model extends PVInstance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Model: unique symbol;
ModelStreamingMode: Enum.ModelStreamingMode;
/**
* Points to the primary part of the [Model](https://developer.roblox.com/en-us/api-reference/class/Model). The primary part is the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that acts as the physical reference for the pivot of the model. That is, when parts within the model are moved due to physical simulation or other means, the pivot will move in sync with the primary part. If the primary part is **not** set, the pivot will remain at the same location in world space even if parts within the model are moved.
*
* Note that when setting this property, it must be a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that is a descendant of the model. If you try to set [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) that is **not** a descendant of the model, it will be set to that part but reset to `nil` during the next simulation step — this is legacy behavior to support scripts which assume they can temporarily set the primary part to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) which isn't a descendant of the model.
*
* The general rule for models is that:
*
* * Models whose parts are joined together via physical joints such as [WeldConstraints](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) or [Motor6Ds](https://developer.roblox.com/en-us/api-reference/class/Motor6D) should have a primary part assigned. For example, Roblox character models have their [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) set to the **HumanoidRootPart** by default.
* * Static (usually [Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored)) models which stay in one place unless a script explicitly moves them don't require a [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) and tend not to benefit from having one set.
*/
PrimaryPart: BasePart | undefined;
/**
* This property determines where the pivot of a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) which does **not** have a set [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) is located. If the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) **does** have a [PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart), the pivot of the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) is equal to the pivot of that primary part instead, and this [WorldPivot](https://developer.roblox.com/en-us/api-reference/property/Model/WorldPivot) property is ignored.
*
* For a newly created [Model](https://developer.roblox.com/en-us/api-reference/class/Model), its pivot will be treated as the center of the bounding box of its contents until the **first time** its [Model.WorldPivot](https://developer.roblox.com/en-us/api-reference/property/Model/WorldPivot) property is set. Once the world pivot is set for the first time, it is impossible to restore this initial behavior.
*
* Most commonly, moving the model with the Studio tools, or with a model movement function such as [PVInstance:PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo), [Model:MoveTo](https://developer.roblox.com/en-us/api-reference/function/Model/MoveTo), and [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) will set the world pivot and thus end this new model behavior.
*
* The purpose of this behavior is to allow Lua code to get a sensible pivot simply by creating a new model and parenting objects to it, avoiding the need to explicitly set [Model.WorldPivot](https://developer.roblox.com/en-us/api-reference/property/Model/WorldPivot) every time you create a model in code.
*
* local model = Instance.new("Model")
* workspace.BluePart.Parent = model
* workspace.RedPart.Parent = model
* model.Parent = workspace
*
* print(model:GetPivot()) -- Currently equal to the center of the bounding box containing "BluePart" and "RedPart"
*
* model:PivotTo(CFrame.new(0, 10, 0) -- This works without needing to explicitly set "model.WorldPivot"
*
* Tags: NotReplicated
*/
WorldPivot: CFrame;
AddPersistentPlayer(this: Model, playerInstance?: Player): void;
/**
* Breaks connections between `BaseParts`, including surface connections with any adjacent parts, [WeldConstraint](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint)s, and all [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld)s and other [JointInstance](https://developer.roblox.com/en-us/api-reference/class/JointInstance)s.
*
* When BreakJoints is used on a Player character [Model](https://developer.roblox.com/en-us/api-reference/class/Model), the character's [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) will die as it relies on the Neck joint.
*
* Note that although joints produced by surface connections with adjacent Parts can technically be recreated using [Model:MakeJoints](https://developer.roblox.com/en-us/api-reference/function/Model/MakeJoints), this will only recreate joints produced by surfaces. Developers should not rely on this as following the joints being broken parts may no longer be in contact with each other.
* @deprecated
*/
BreakJoints(this: Model): void;
/**
* This function returns a description of a volume that contains all [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) children within a [Model](https://developer.roblox.com/en-us/api-reference/class/Model). The volume's orientation is based on the orientation of the [PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart), and matches the selection box rendered in Studio when the model is selected. The description is provided in the form of a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) **orientation** and [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) **size**.
*
* Mirroring the behavior of [Terrain:FillBlock](https://developer.roblox.com/en-us/api-reference/function/Terrain/FillBlock), it returns a CFrame representing the center of that bounding box and a Vector3 representing its size.
*
* If there is no PrimaryPart for the model, the BoundingBox will be aligned to the world axes.
*
* Example
* -------
*
* Pictured below is a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) with a pink semitransparent [Part](https://developer.roblox.com/en-us/api-reference/class/Part) whose [CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame) and [Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size) have been set to the return values of this function called on the model.
*
* 
*
* Usage
* -----
*
* local model = workspace.Model
* local part = workspace.Part
* local orientation, size = model:GetBoundingBox()
* part.Size = size
* part.CFrame = orientation
*/
GetBoundingBox(this: Model): LuaTuple<[CFrame, Vector3]>;
/**
* Returns the size of the smallest bounding box that contains all of the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in the [Model](https://developer.roblox.com/en-us/api-reference/class/Model). If [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) exists then the bounding box will be aligned to that part. If a primary part has not been set then the function will chose a part in the model to align the bounding box to. As the the selection of this part is not deterministic it is recommended to set a [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) to get consistent results with this function.
*
* Note this function only returns the size of the smallest bounding box, and the developer must employ their own method to obtain the position of the bounding box.
*/
GetExtentsSize(this: Model): Vector3;
/**
* This value historically returned the CFrame of a central position in the model. It has been deprecated as it did not provide reliable results.
* @deprecated Use `GetPrimaryPartCFrame` instead
*/
GetModelCFrame(this: Model): CFrame;
/**
* The GetModelSize function returns the `Vector3` size of the [Model](https://developer.roblox.com/en-us/api-reference/class/Model).
* @deprecated Use `GetExtentsSize` instead
*/
GetModelSize(this: Model): Vector3;
GetPersistentPlayers(this: Model): Array;
/**
* This function has been superseded by [PVInstance:GetPivot](https://developer.roblox.com/en-us/api-reference/function/PVInstance/GetPivot) which acts as a replacement and does not change your code's behavior. Use [PVInstance:GetPivot](https://developer.roblox.com/en-us/api-reference/function/PVInstance/GetPivot) for new work and migrate your existing [Model:GetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/GetPrimaryPartCFrame) calls when convenient.
*
* Returns the `CFrame` of the [Model](https://developer.roblox.com/en-us/api-reference/class/Model)'s [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart).
*
* This function is equivalent to the following.
*
* ```lua
* Model.PrimaryPart.CFrame
* ```
*
* Note this function will throw an error if no primary part exists for the [Model](https://developer.roblox.com/en-us/api-reference/class/Model). If this behavior is not desired developers can do the following, which will be equal to nil if there is no primary part.
*
* ```lua
* local cFrame = Model.PrimaryPart and Model.PrimaryPart.CFrame
* ```
* @deprecated Use `GetPivot` instead
*/
GetPrimaryPartCFrame(this: Model): CFrame;
GetScale(this: Model): number;
/**
* **Deprecated**
*
* SurfaceType based joining is deprecated, do not use MakeJoints for new projects. [WeldConstraints](https://developer.roblox.com/en-us/api-reference/class/WeldConstraint) and [HingeConstraints](https://developer.roblox.com/en-us/api-reference/class/HingeConstraint) should be used instead
*
* Goes through all [Parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) in the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) and creates joints between the specified Parts and any planar touching surfaces, depending on the parts' surfaces.
*
* * Smooth surfaces will not create joints
* * Glue surfaces will create a [Glue](https://developer.roblox.com/en-us/api-reference/class/Glue) joint
* * Weld will create a [Weld](https://developer.roblox.com/en-us/api-reference/class/Weld) joint with any surface except for Unjoinable
* * Studs, Inlet, or Universal will each create a [Snap](https://developer.roblox.com/en-us/api-reference/class/Snap) joint with either of other the other two surfaces (e.g. Studs with Inlet and Universal)
* * Hinge and Motor surfaces create [Rotate](https://developer.roblox.com/en-us/api-reference/class/Rotate) and [RotateV](https://developer.roblox.com/en-us/api-reference/class/RotateV) joint instances
*
* This function will not work if the Part is not a descendant of [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace). Therefore developers must first ensure the Model is parented to Workspace before using MakeJoints.
* @deprecated
*/
MakeJoints(this: Model): void;
/**
* Moves the [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) to the given position. If a primary part has not been specified then the root part of the model will be used. Because the root part is not deterministic, it is recommended to always set a [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) when using MoveTo.
*
* If there are any obstructions where the model is to be moved to, such as [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) or other [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s, then the model will be moved up in the Y direction until there is nothing in the way. If this behavior is not desired, [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) should be used instead.
*
* Note that rotation is not preserved when moving a model with MoveTo. It is recommended to use either [Model:TranslateBy](https://developer.roblox.com/en-us/api-reference/function/Model/TranslateBy) or [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) if the current rotation of the model needs to be preserved.
*/
MoveTo(this: Model, position: Vector3): void;
RemovePersistentPlayer(this: Model, playerInstance?: Player): void;
/**
* Resets the rotation of the model's parts to the previously set identity rotation, which is done through the [Model:SetIdentityOrientation](https://developer.roblox.com/en-us/api-reference/function/Model/SetIdentityOrientation) method.
* @deprecated Use `SetPrimaryPartCFrame` instead
*/
ResetOrientationToIdentity(this: Model): void;
ScaleTo(this: Model, newScaleFactor: number): void;
/**
* Sets the identity rotation of the given model, allowing you to reset the rotation of the entire model later, through the use of the `ResetOrientationToIdentity` method.
* @deprecated Use `SetPrimaryPartCFrame` instead
*/
SetIdentityOrientation(this: Model): void;
/**
* This function has been superseded by [PVInstance:PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo) which acts as a more performant replacement and does not change your code's behavior. Use [PVInstance:PivotTo](https://developer.roblox.com/en-us/api-reference/function/PVInstance/PivotTo) for new work and migrate your existing [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) calls when convenient.
*
* Sets the [BasePart.CFrame](https://developer.roblox.com/en-us/api-reference/property/BasePart/CFrame) of the [Model](https://developer.roblox.com/en-us/api-reference/class/Model)'s [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart). All other parts in the model will also be moved and will maintain their orientation and offset respective to the [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart).
*
* Note, this function will throw an error if no [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) exists for the model. This can cause issues if, for example, the primary part was never set or has been destroyed. Therefore, it is recommended the developer check the [Model.PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) exists before using this function. For example:
*
* ```lua
* if model.PrimaryPart then
* model:SetPrimaryPartCFrame(cf)
* end
* ```
*
* A common use for this is for the 'teleportation' of player characters to different positions.
* @deprecated Use `PivotTo` instead
*/
SetPrimaryPartCFrame(this: Model, cframe: CFrame): void;
/**
* Shifts a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) by the given `Vector3` offset, preserving the [Model](https://developer.roblox.com/en-us/api-reference/class/Model)'s orientation. If another [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) already exists at the new position then the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) will overlap said object.
*
* The translation is applied in world space rather than object space, meaning even if the model's parts are orientated differently it will still move along the standard axis.
*/
TranslateBy(this: Model, delta: Vector3): void;
}
/** This is the Actor Class */
interface Actor extends Model {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Actor: unique symbol;
BindToMessage(this: Actor, topic: string, callback: Callback): RBXScriptConnection;
BindToMessageParallel(this: Actor, topic: string, callback: Callback): RBXScriptConnection;
SendMessage(this: Actor, topic: string, ...message: Array): void;
}
/** BackpackItem is an abstract class for backpack items such as HopperBins and Tools. */
interface BackpackItem extends Model {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BackpackItem: unique symbol;
/**
* The texture icon that is displayed for a tool in the [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s backpack.
*
* This property should be set to the content ID of an image uploaded to the Roblox website.
*
* If this property is left blank, the [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) GUI will display the name of the tool instead.
*/
TextureId: string;
}
/** Tools are objects that a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) object can equip. For players, they are stored in a [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) object parented to a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) object. In-game, players may have multiple tools which appear as icons at the bottom of the screen. Equipping a tool moves it from the Backpack and into a player's [character](https://developer.roblox.com/en-us/api-reference/class/Character) model in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace). By default, tools are held in the right hand and have a handle in them, which is a [Part](https://developer.roblox.com/en-us/api-reference/class/BasePart) named “Handle” inside (though one is not required if [Tool.RequiresHandle](https://developer.roblox.com/en-us/api-reference/property/Tool/RequiresHandle) is off). Tools that are to be provided to (re)spawning players ought to be stored in the [StarterPack](https://developer.roblox.com/en-us/api-reference/class/StarterPack).
*
* On desktop, pressing a number key (1, 2, 3…) will equip a tool. Equipped tools can be dropped into the Workspace by pressing Backspace. It's recommended that you turn [Tool.CanBeDropped](https://developer.roblox.com/en-us/api-reference/property/Tool/CanBeDropped) off so it is not possible to drop a tool, die, respawn and drop again to duplicate tools. On gamepads, LB and RB buttons will equip tools. You can disable activation via left click (or right trigger on gamepad) by setting [Tool.ManualActivationOnly](https://developer.roblox.com/en-us/api-reference/property/Tool/ManualActivationOnly) on. Doing so requires that you call Activate yourself through some sort of other user input.
*
* Tools are not the only way to capture user input. You can also use [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService), [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) or [Player:GetMouse](https://developer.roblox.com/en-us/api-reference/function/Player/GetMouse). If you need a Tool to have multiple actions, such as pressing a key while the Tool is equipped, you should use ContextActionService's [BindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindAction) and [UnbindAction](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/UnbindAction) in the [Equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped) and [Unequipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Unequipped) events, respectively. Use a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) send these actions to the server via a [RemoteFunction](https://developer.roblox.com/en-us/api-reference/class/RemoteFunction) inside the Tool.
*/
interface Tool extends BackpackItem {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Tool: unique symbol;
/**
* The CanBeDropped property controls whether the player can drop the [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool).
*
* If true, when the backspace button is pressed the tool will be parented to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and removed from the player's [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). If false, the when the backspace button is pressed the tool will go back to the player's Backpack and it will not be dropped.
*/
CanBeDropped: boolean;
/**
* The Enabled property relates to whether or not the [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) can be used. This is useful if you want to prevent a player from using a tool, but do not want to remove it from their [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack).
*
* When set to true, the tool can use the tool.
*
* When set to false, the tool is disabled and the player cannot use the tool. It prevents the tool from being activated or deactivated by `the Tool/Activate` and [Tool:Deactivate](https://developer.roblox.com/en-us/api-reference/function/Tool/Deactivate) functions. It also prevents the [Tool.Activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated) and [Tool.Deactivated](https://developer.roblox.com/en-us/api-reference/event/Tool/Deactivated) events from firing for the tool.
*/
Enabled: boolean;
/**
* The Grip property stores the [Tool's](https://developer.roblox.com/en-us/api-reference/class/Tool) Grip properties as a single [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame). This includes the `Grip/Up|Up`, `Grip/Right|Right`, `Grip/Forward|Forward`, and `Grip/Pos|Pos` properties.
*
* The grip properties are used to position how the player holds the tool.
*
* Unlike the grip properties that it stores, this property is not visible in a tool's `Properties` window in Studio. Regardless, it can be set and retrieved using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* 
*
* In order to change a tool's grip properties, you must either use a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a Studio plugin such as [this](https://developer.roblox.com/assets/blt87cc763d68414be8/Screen_Shot_2018-08-26_at_8.35.48_PM.png) one.
*/
Grip: CFrame;
/**
* The GripForward properties is one of the properties that specifies a Tool's orientation in a character's hand. This represents the R02, R12, and R22 values of the Grip [CFrame's](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) rotation matrix.
*
* Other tool properties that control how a player holds a tool include: `Grip/GripUp|Up`, `Grip/GripRight|Right`, and `Grip/GripPos|Pos` properties. All of these properties are stored in a single CFrame in the [Tool.Grip](https://developer.roblox.com/en-us/api-reference/property/Tool/Grip) property.
*
* In order to change a tool's grip properties, you must either use a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a Studio plugin such as [this](https://www.roblox.com/library/174577307/Tool-Grip-Editor-Plugin) one.
*
* Tags: Hidden, NotReplicated
*/
GripForward: Vector3;
/**
* The GripPos property controls the positional offset of a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) weld matrix. It is one of several properties used to position how the player holds the tool.
*
* Other tool properties that control how a player holds a tool include: `Grip/GripUp|Up`, `Grip/GripRight|Right`, and `Grip/GripForward|Forward` properties. All of these properties are stored in a single CFrame in the [Tool.Grip](https://developer.roblox.com/en-us/api-reference/property/Tool/Grip) property.
*
* In order to change a tool's grip properties, you must either use a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a plugin such as [this](https://www.roblox.com/library/174577307/Tool-Grip-Editor-Plugin) one.
*
* Tags: Hidden, NotReplicated
*/
GripPos: Vector3;
/**
* The GripRight property is one of the properties that specifies a [Tool's](https://developer.roblox.com/en-us/api-reference/class/Tool) orientation in a character's hand. This represents the R00, R10, and R20 values of the Grip [CFrame's](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) rotation matrix.
*
* Other tool properties that control how a player holds a tool include: `Grip/GripUp|Up`, `Grip/GripForward|Forward`, and `Grip/GripPos|Pos` properties. All of these properties are stored in a single CFrame in the [Tool.Grip](https://developer.roblox.com/en-us/api-reference/property/Tool/Grip) property.
*
* In order to change a tool's grip properties, you must either use a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a plugin such as [this](https://www.roblox.com/library/174577307/Tool-Grip-Editor-Plugin) one.
*
* Tags: Hidden, NotReplicated
*/
GripRight: Vector3;
/**
* The GripUp property is one of the properties that specifies a Tool's orientation in a character's hand. This represents the R01, R11, and R21 values of the Grip [CFrame's](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) rotation matrix.
*
* Other tool properties that control how a player holds a tool include: `Grip/GripRight|Right`, `Grip/GripForward|Forward`, and `Grip/GripPos|Pos` properties. All of these properties are stored in a single CFrame in the [Tool.Grip](https://developer.roblox.com/en-us/api-reference/property/Tool/Grip) property.
*
* In order to change a tool's grip properties, you must either use a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) or a plugin such as [this](https://www.roblox.com/library/174577307/Tool-Grip-Editor-Plugin) one.
*
* Tags: Hidden, NotReplicated
*/
GripUp: Vector3;
/**
* The ManualActivationOnly property controls whether the [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) can be activated without explicitly executing [Tool:Activate](https://developer.roblox.com/en-us/api-reference/function/Tool/Activate) in a script.
*
* When set to true, the tool will only fire [Tool.Activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated) when [Tool:Activate](https://developer.roblox.com/en-us/api-reference/function/Tool/Activate) is called. This also suppresses the [ContextActionService](https://developer.roblox.com/en-us/api-reference/class/ContextActionService)'s [ContextActionService:BindActivate](https://developer.roblox.com/en-us/api-reference/function/ContextActionService/BindActivate) function.
*
* When set to false, mouse clicks (when the tool is equipped) will also fire [Tool.Activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated).
*/
ManualActivationOnly: boolean;
/**
* The RequiresTool property determines whether a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) functions without a handle.
*
* A tool has a handle when it has a child part named “Handle”. Tools without handles are typically ones that do not require the player equipping them to hold anything to use them. For instance, handles may not be necessary for _fly_ or _build_ tools. Tools with handles are typically ones that require the player equipping them to hold an object to use them. For instance, handle are likely necessary for weapons such as guns and swords.
*
* When set to true, the tool will function and be [activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated) and [deactivated](https://developer.roblox.com/en-us/api-reference/event/Tool/Deactivated) without a handle.
*
* When set to false, the tool will not function without a handle.
*/
RequiresHandle: boolean;
/**
* The ToolTip property controls the message that will be displayed when the player's [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) hovers over the [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) in their [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack).
*
* Generally, the value of this property should describe the what the tool is or its use. For instance, for a shovel tool, you may choose to set the ToolTip to:
*
* tool.ToolTip = "Shovel"
*
* or
*
* tool.ToolTip = "Use to dig"
*
* or
*
* tool.ToolTip = "Shovel - Use to dig"
*/
ToolTip: string;
/**
* The Activate function simulates a click on a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). The Tool must be equipped for this function to work.
*
* Tools will normally trigger the [Tool.Activated](https://developer.roblox.com/en-us/api-reference/event/Tool/Activated) event when the player releases the left mouse button, while the tool is equipped.
*
* The below code, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), would create a tool in the [LocalPlayer's](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). It will simulate the tool being activated and print “Tool activated” when the player equips the tool.
*
* local tool = Instance.new("Tool")
* tool.RequiresHandle = false
* tool.Parent = game.Players.LocalPlayer.Backpack
*
* tool.Equipped:Connect(function()
* tool:Activate()
* end)
*
* function toolActivated()
* print("Tool activated")
* end
*
* tool.Activated:Connect(toolActivated)
*/
Activate(this: Tool): void;
/**
* The Deactivate function simulates the deactivation of a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool). The Tool must be equipped for this function to work.
*
* Tools will normally trigger the [Tool.Deactivated](https://developer.roblox.com/en-us/api-reference/event/Tool/Deactivated) event when the player releases the left mouse button, while the tool is equipped.
*
* The below code, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), would create a tool in the [LocalPlayer's](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). It will simulate the tool being deactivated and print “Tool deactivated” when the player equips the tool.
*
* local tool = Instance.new("Tool")
* tool.RequiresHandle = false
* tool.Parent = game.Players.LocalPlayer.Backpack
*
* tool.Equipped:Connect(function()
* tool:Deactivate()
* end)
*
* function toolDeactivated()
* print("Tool deactivated")
* end
*
* tool.Deactivated:Connect(toolDeactivated)
*/
Deactivate(this: Tool): void;
/**
* **Activated** is not called if the Ctrl key is pressed during a click.
*
* The Activated event fires when the player clicks while a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) is equipped.
*
* This function is used to perform an action when the player uses the tool. For instance, when the player clicks while a _Rocket Launcher_ tool is equipped, the activated event executes the code to create and launch a rocket.
*
* The below code, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), would create a tool in the [LocalPlayer's](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). It will print “Tool activated” when the player clicks while the created tool is equipped.
*
* local tool = Instance.new("Tool")
* tool.RequiresHandle = false
* tool.Parent = game.Players.LocalPlayer.Backpack
*
* function onActivation()
* print("Tool activated")
* end
*
* tool.Activated:Connect(onActivation)
*/
readonly Activated: RBXScriptSignal<() => void>;
/**
* The Deactivated event fires when the left mouse button is released while a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) is equipped.
*
* This function is used to perform an action when the player stops using a tool. For instance, a tool may make a player fly until they release their left mouse button.
*
* The below code, when placed in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), would create a tool in the [LocalPlayer's](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer) [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). It will print “Tool deactivated” when the player releases the left mouse button, while the tool is equipped.
*
* local tool = Instance.new("Tool")
* tool.RequiresHandle = false
* tool.Parent = game.Players.LocalPlayer.Backpack
*
* function toolDeactivated()
* print("Tool deactivated")
* end
*
* tool.Deactivated:Connect(toolDeactivated)
*/
readonly Deactivated: RBXScriptSignal<() => void>;
/**
* The Equipped event fires when a player when a player takes a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) out of their [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) to use. This event can be used to determine when a player stops using and puts a tool away.
*
* This event does not fire when [Tool.RequiresHandle](https://developer.roblox.com/en-us/api-reference/property/Tool/RequiresHandle) is enabled and no handle is present.
*
* The opposite of this event, [Tool.Unequipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Unequipped), can be used alongside this event to determine unequips a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) by putting in back in their backpack.
*/
readonly Equipped: RBXScriptSignal<(mouse: Mouse) => void>;
/**
* The Unequipped event fires when a player unequips a [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool) by putting in back in their [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack). This event can be used to determine when a player stops using and puts a tool away.
*
* This event does not fire when [Tool.RequiresHandle](https://developer.roblox.com/en-us/api-reference/property/Tool/RequiresHandle) is enabled and no handle is present.
*
* The opposite of this event, [Tool.Equipped](https://developer.roblox.com/en-us/api-reference/event/Tool/Equipped), can be used alongside this event to determine when a player takes a tool out of their backpack to use.
*
* The example shown below will print “A tool was unequipped” each time the tool is unequipped by the player. Please note that the below example assumes that you've already defined what “Tool” is.
*
* Tool.Unequipped:Connect(function()
* print("The tool was unequipped")
* end)
*/
readonly Unequipped: RBXScriptSignal<() => void>;
}
interface WorldRoot extends Model {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WorldRoot: unique symbol;
/**
* **ArePartsTouchingOthers** returns true if at least one of the given [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) are touching any other parts. Two parts are considered “touching” if they are within the distance threshold, `overlapIgnored`.
*
* If no parts are provided, false is returned.
*/
ArePartsTouchingOthers(this: WorldRoot, partList: Array, overlapIgnored?: number): boolean;
Blockcast(
this: WorldRoot,
cframe: CFrame,
size: Vector3,
direction: Vector3,
raycastParams?: RaycastParams,
): RaycastResult | undefined;
/**
* **Warning!**
* You should only use this function if you are sure that part movement is a bottleneck in your code, simply setting the CFrame property of the individual parts / welded models you want to move will be fast enough in the vast majority of cases.
*
* This function moves a table of parts to the location specified in a table of [CFrames](https://developer.roblox.com/en-us/api-reference/datatype/CFrame). This makes it a very fast way to move large numbers of parts, as you don't have to pay the cost of separate property sets for each individual part.
*
* The third argument of BulkMoveTo allows you to further speed up movement of the parts by specifying the [Position](https://developer.roblox.com/en-us/api-reference/property/BasePart/Position) and [Orientation](https://developer.roblox.com/en-us/api-reference/property/BasePart/Orientation). Changed events should not be fired on the parts. If you specify FireCFrameChanged as the BulkMoveMode then only CFrame .Changed will be fired, rather than changed firing for Position, Orientation, and CFrame like it normally does.
*/
BulkMoveTo(this: WorldRoot, partList: Array, cframeList: Array, eventMode?: CastsToEnum): void;
/**
* **FindPartOnRay** uses [raycasting](https://developer.roblox.com/articles/Raycasting) to find the first [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) cell intersecting with a given [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray). This function returns the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or terrain cell hit, the point of intersection, the surface normal at the point of intersection, and the associated [Material](https://developer.roblox.com/en-us/api-reference/enum/Material) hit.
*
* local character = game.Players.LocalPlayer.Character
* -- Get the head
* local head = character:FindFirstChild("Head")
* -- Build a ray in the direction the head is facing
* local origin = head.Position
* local lookDirection = head.CFrame.LookVector
* local ray = Ray.new(origin, lookDirection \* 500)
* -- Raycast, ignoring the player's character
* local hitPart, hitPosition = workspace:FindPartOnRay(ray, character)
* if hitPart then
* print("Hit part: " .. hitPart:GetFullName())
* else
* print("Did not hit part")
* end
*
* If the `ignoreDescendantsInstance` parameter is provided, the raycasting calculation will ignore the given object and all of its descendants. It behaves similar to the [Mouse.TargetFilter](https://developer.roblox.com/en-us/api-reference/property/Mouse/TargetFilter) property.
*
* The `terrainCellsAreCubes` and `ignoreWater` parameters determine whether [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) cells should be treated as cubes or not, and whether water should be ignored or not.
*
* In order to whitelist or ignore multiple objects and their descendants, use the [WorldRoot:FindPartOnRayWithWhitelist](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRayWithWhitelist) and [WorldRoot:FindPartOnRayWithIgnoreList](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRayWithIgnoreList) variants.
*
* Notes
* -----
*
* * Theoretically, a ray extends infinitely in one direction. However, the max length of the direction vector on Roblox is 5000 studs.
* * The length (magnitude) of the directional vector is important, as parts further away than its length will not be tested.
* * If the ray does not intersect anything, the return values will be `nil` and the point at the end of the ray, respectively.
* * Parts that are in a [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) that does not collide with the “Default” collision group are ignored implicitly.
*
* For a demonstration of how raycasting works in Roblox, see the [Intro to Raycasting](https://developer.roblox.com/articles/Raycasting) article.
* @deprecated Use `Raycast` instead
*/
FindPartOnRay(
this: WorldRoot,
ray: Ray,
ignoreDescendantsInstance?: Instance,
terrainCellsAreCubes?: boolean,
ignoreWater?: boolean,
): LuaTuple<[BasePart | undefined, Vector3, Vector3, Enum.Material]>;
/**
* This function is a variant of [WorldRoot:FindPartOnRay](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRay) with the addition of an ignore list. This lets you ignore certain parts or [Models](https://developer.roblox.com/en-us/api-reference/class/Model).
*
* Those looking to utilize a whitelist instead should use [WorldRoot:FindPartOnRayWithWhitelist](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRayWithWhitelist).
*
* Notes
* -----
*
* * Theoretically, a ray extends infinitely in one direction. However, the max length of the direction vector on Roblox is 5000 studs.
* * The length (magnitude) of the directional vector is important, as parts further away than its length will not be tested.
* * If the ray does not intersect anything, the return values will be `nil` and the point at the end of the ray, respectively.
* * Parts that are in a [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) that does not collide with the “Default” collision group are ignored implicitly.
* @deprecated Use `Raycast` instead
*/
FindPartOnRayWithIgnoreList(
this: WorldRoot,
ray: Ray,
ignoreDescendantsTable: Array,
terrainCellsAreCubes?: boolean,
ignoreWater?: boolean,
): LuaTuple<[BasePart | undefined, Vector3, Vector3, Enum.Material]>;
/**
* This function is a variant of [WorldRoot:FindPartOnRay](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRay) with the addition of a whitelist. This lets you detect only certain parts or [Models](https://developer.roblox.com/en-us/api-reference/class/Model) and is particularly useful when, for example, looking for points of intersection between a ray and a single part.
*
* local function getIntersection(part, ray)
* local whiteList = {part}
* local \_, position, normal = workspace:FindPartOnRayWithWhitelist(ray, whiteList)
* return position, normal
* end
*
* Those looking to utilize an ignore list instead should use [WorldRoot:FindPartOnRayWithIgnoreList](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/FindPartOnRayWithIgnoreList).
*
* Notes
* -----
*
* * If a `nil` value is given in the whitelist, instances after it will be disregarded.
* * Theoretically, a ray extends infinitely in one direction. However, the max length of the direction vector on Roblox is 5000 studs.
* * The length (magnitude) of the directional vector is important, as parts further away than its length will not be tested.
* * If the ray does not intersect anything, the return values will be `nil` and the point at the end of the ray, respectively.
* * Parts that are in a [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) that does not collide with the “Default” collision group are ignored implicitly.
* @deprecated Use `Raycast` instead
*/
FindPartOnRayWithWhitelist(
this: WorldRoot,
ray: Ray,
whitelistDescendantsTable: Array,
ignoreWater?: boolean,
): LuaTuple<[BasePart | undefined, Vector3, Vector3, Enum.Material]>;
/**
* Returns an array of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in the given [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3).
*
* This function takes an optional maxParts parameter (default 20) which limits the number of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that can be returned. Once this number has been reached, the search for [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s will stop. This means some [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s may not be returned even if they are within the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3)
*
* The optional ignoreDescendentsInstance parameter can be used to specify a specific instance for whom itself and all of its descendants should be ignored by this function. This can be useful when, for example, looking to see if any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are inside a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) other than the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) itself.
*
* local min = part.Position - (0.5 \* part.Size)
* local max = part.Position + (0.5 \* part.Size)
* local region = Region3.new(min, max)
* local parts = workspace:FindPartsInRegion3(region, part) -- ignore part
*
* Variants of this function exist with ignore-list and white-list functionality, `Workspace/FindPartsInRegion3WithIgnoreList` and `Workspace/FindPartsInRegion3WithWhiteList`.
*
* If no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are found, an empty array will be returned.
*
* How do Region3 checks work?
* ---------------------------
*
* Checking if a part overlaps a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is not a simple process. It actually is time consuming and complicated. Instead it checks if parts are roughly in the same area. When this function is called, it figures out which voxels contain the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). It then figures out which parts might be in those voxels. It does this by comparing the axis-aligned bounding box (sometimes called the AABB) of the part with the voxels. The axis-aligned bounding box can be seen in Roblox Studio when a part is selected.
*
* This means that the area that is inspected by the function may be larger than the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). For this reason it is recommended to make sure that the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is on the voxel grid. The best way to do this is by setting the coordinates of the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) to multiples of 4 (since voxels are 4 x 4 x 4 studs).
*
* This method is a fairly quick and easy way to see if parts are in a general area. If a game needs to know if parts are exactly in an area, then [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) should be used. There is a higher cost to using [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) since a part is needed in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the function takes more time to run.
* @deprecated Use `GetPartBoundsInBox` instead
*/
FindPartsInRegion3(
this: WorldRoot,
region: Region3,
ignoreDescendantsInstance?: Instance,
maxParts?: number,
): Array;
/**
* Returns an array of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in the given [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) that aren't in, or a descendant of an entry in, the given IgnoreList.
*
* This function takes an optional maxParts parameter (default 20) which limits the number of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that can be returned. Once this number has been reached, the search for [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s will stop. This means some [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s may not be returned even if they are within the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3)
*
* If no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are found, an empty array will be returned.
*
* This function is a variant of `Workspace/FindPartsInRegion3` with the addition of an ignore list. This allows the developer to exclude certain [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s or [Model](https://developer.roblox.com/en-us/api-reference/class/Model)s, for example characters, from the search. Those looking to find [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in a Region3 using a white list, should use `Workspace/FindPartsInRegion3WithWhitelist`.
*
* How do Region3 checks work?
* ---------------------------
*
* Checking if a part overlaps a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is not a simple process. It actually is time consuming and complicated. Instead it checks if parts are roughly in the same area. When this function is called, it figures out which voxels contain the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). It then figures out which parts might be in those voxels. It does this by comparing the axis-aligned bounding box (sometimes called the AABB) of the part with the voxels. The axis-aligned bounding box can be seen in Roblox Studio when a part is selected.
*
* This means that the area that is inspected by the function may be larger than the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). For this reason it is recommended to make sure that the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is on the voxel grid. The best way to do this is by setting the coordinates of the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) to multiples of 4 (since voxels are 4 x 4 x 4 studs).
*
* This method is a fairly quick and easy way to see if parts are in a general area. If a game needs to know if parts are exactly in an area, then [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) should be used. There is a higher cost to using [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) since a part is needed in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the function takes more time to run.
*
* Notes
* -----
*
* * If a nil value is given in the ignore list, instances after this value will not be ignored
* @deprecated Use `GetPartBoundsInBox` instead
*/
FindPartsInRegion3WithIgnoreList(
this: WorldRoot,
region: Region3,
ignoreDescendantsTable: Array,
maxParts?: number,
): Array;
/**
* Returns an array of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in the given [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) that are in, or descendant of an object in, a given white list.
*
* This function takes an optional maxParts parameter (default 20) which limits the number of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that can be returned. Once this number has been reached, the search for [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s will stop. This means some [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s may not be returned even if they are within the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3)
*
* If no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are found, an empty array will be returned.
*
* This function is a variant of `Workspace/FindPartsInRegion3` with the addition of a white list. Those looking to find [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in a Region3 using an ignore list, should use `Workspace/FindPartsInRegion3WithIgnoreList`.
*
* How do Region3 checks work?
* ---------------------------
*
* Checking if a part overlaps a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is not a simple process. It actually is time consuming and complicated. Instead it checks if parts are roughly in the same area. When this function is called, it figures out which voxels contain the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). It then figures out which parts might be in those voxels. It does this by comparing the axis-aligned bounding box (sometimes called the AABB) of the part with the voxels. The axis-aligned bounding box can be seen in Roblox Studio when a part is selected.
*
* This means that the area that is inspected by the function may be larger than the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). For this reason it is recommended to make sure that the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is on the voxel grid. The best way to do this is by setting the coordinates of the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) to multiples of 4 (since voxels are 4 x 4 x 4 studs).
*
* This method is a fairly quick and easy way to see if parts are in a general area. If a game needs to know if parts are exactly in an area, then [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) should be used. There is a higher cost to using [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) since a part is needed in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the function takes more time to run.
*
* Notes
* -----
*
* * If a nil value is given in the white list, instances after this value will be disregarded
* @deprecated Use `GetPartBoundsInBox` instead
*/
FindPartsInRegion3WithWhiteList(
this: WorldRoot,
region: Region3,
whitelistDescendantsTable: Array,
maxParts?: number,
): Array;
/**
* **GetPartBoundsInBox** returns an array of parts whose _bounding boxes_ overlap a box whose volume is described using the given center (CFrame) and size (Vector3).
*
* Beware that this spatial query function efficiently considers the volume of parts' bounding boxes rather than their actual occupied volume. This may be important when considering cylinders, spheres, unions, and [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart), which have non-block shapes. For cases where accuracy particularly matters, use [GetPartsInPart](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartsInPart) instead or further filter the results of this function yourself.
*
* This function uses an [OverlapParams](https://developer.roblox.com/en-us/api-reference/datatype/OverlapParams) object to describe reusable portions of the spatial query, such as an instance whitelist/blacklist, the maximum number of parts to query, and what [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) to use. When making repeated spatial queries using functions like this, you should construct just one of these objects and reuse it.
*
* This and other spatial query functions do not consider parts' [CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) or [CanTouch](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanTouch) properties. However, it will consider parts' collision group if specified by the given OverlapParams.
*/
GetPartBoundsInBox(this: WorldRoot, cframe: CFrame, size: Vector3, overlapParams?: OverlapParams): Array;
/**
* **GetPartBoundsInRadius** returns an array of parts whose _bounding boxes_ overlap a sphere whose volume is described using the given center (Vector3) and radius (number).
*
* Beware that this spatial query function efficiently considers the volume of parts' bounding boxes rather than their actual occupied volume. This may be important when considering cylinders, spheres, unions, and [MeshPart](https://developer.roblox.com/en-us/api-reference/class/MeshPart), which have non-block shapes. For cases where accuracy particularly matters, use [GetPartsInPart](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartsInPart) instead or further filter the results of this function yourself.
*
* This function uses an [OverlapParams](https://developer.roblox.com/en-us/api-reference/datatype/OverlapParams) object to describe reusable portions of the spatial query, such as an instance whitelist/blacklist, the maximum number of parts to query, and what [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) to use. When making repeated spatial queries using functions like this, you should construct just one of these objects and reuse it.
*
* This and other spatial query functions do not consider parts' [CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) or [CanTouch](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanTouch) properties. However, it will consider parts' collision group if specified by the given OverlapParams.
*/
GetPartBoundsInRadius(
this: WorldRoot,
position: Vector3,
radius: number,
overlapParams?: OverlapParams,
): Array;
/**
* **GetPartsInPart** returns an array of parts whose occupied space is shared with the given part, which must exist in the same WorldRoot ([Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace)) as the parts to be queried.
*
* Queried parts that are merely touching the given part are considered occupying the same space. This function can be used in place of [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts), and is generally a better choice in most cases.
*
* Beware that this spatial query function considers the exact volume occupied by the given part using a full geometric collision check. A concave/hollow part won't match queried parts within it unless they actually overlap/touch such a part. For simpler volumes, consider using [GetPartBoundsInBox](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartBoundsInBox) or [GetPartBoundsInRadius](https://developer.roblox.com/en-us/api-reference/function/WorldRoot/GetPartBoundsInRadius) instead, as they are faster at the cost of being less accurate.
*
* This function uses an [OverlapParams](https://developer.roblox.com/en-us/api-reference/datatype/OverlapParams) object to describe reusable portions of the spatial query, such as an instance whitelist/blacklist, the maximum number of parts to query, and what [collision group](https://developer.roblox.com/en-us/articles/collision-filtering) to use. When making repeated spatial queries using functions like this, you should construct just one of these objects and reuse it.
*
* This and other spatial query functions do not consider parts' [CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) or [CanTouch](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanTouch) properties. However, it will consider parts' collision group if specified by the given OverlapParams.
*/
GetPartsInPart(this: WorldRoot, part: BasePart, overlapParams?: OverlapParams): Array;
/**
* **IsRegion3Empty** returns a bool indicating whether there are no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s within the given [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3).
*
* The optional ignoreDescendentsInstance parameter can be used to specify a specific instance for whom itself and all of its descendants should be ignored by this function. This can be useful when, for example, looking to see if any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are inside a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) other than the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) itself.
*
* local min = part.Position - (0.5 \* part.Size)
* local max = part.Position + (0.5 \* part.Size)
* local region = Region3.new(min, max)
* local isPartEmpty = workspace:IsRegion3Empty(region, part) -- ignore part
*
* If more than one object and its descendants need to be excluded from the search, developers should use `Workspace/IsRegion3EmptyWithIgnoreList`.
*
* This function only returns if a region is empty or not. Developers looking to find [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in a region should use `Workspace/FindPartsInRegion3`.
*
* How do Region3 checks work?
* ---------------------------
*
* Checking if a part overlaps a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is not a simple process. It actually is time consuming and complicated. Instead it checks if parts are roughly in the same area. When this function is called, it figures out which voxels contain the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). It then figures out which parts might be in those voxels. It does this by comparing the axis-aligned bounding box (sometimes called the AABB) of the part with the voxels. The axis-aligned bounding box can be seen in Roblox Studio when a part is selected.
*
* This means that the area that is inspected by the function may be larger than the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). For this reason it is recommended to make sure that the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is on the voxel grid. The best way to do this is by setting the coordinates of the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) to multiples of 4 (since voxels are 4 x 4 x 4 studs).
*
* This method is a fairly quick and easy way to see if any parts are in a general area. If a game needs to know if parts are exactly in an area, then [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) should be used. There is a higher cost to using [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) since a part is needed in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the function takes more time to run.
* @deprecated Use `GetPartBoundsInBox` instead
*/
IsRegion3Empty(this: WorldRoot, region: Region3, ignoreDescendentsInstance?: Instance): boolean;
/**
* **IsRegion3EmptyWithIgnoreList** returns a bool indicating whether there are no [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s within in the given [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3), ignoring any [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that are descendants of the objects within the given ignore list.
*
* For example, the following code snippet will check to see if the Region is empty, ignoring the descendants of a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) named 'Scenery'.
*
* local region3 = Region3.new(Vector3.new(0, 0, 0), Vector3.new(10, 10, 10))
* local scenery = workspace:FindFirstChild("Scenery")
* local ignoreList = {scenery}
* local isEmpty = workspace:IsRegion3EmptyWithIgnoreList(region3, ignoreList)
*
* This function only returns if a region is empty or not. Developers looking to find [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s in a region should use `Workspace/FindPartsInRegion3WithIgnoreList`.
*
* This function is a variant of `Workspace/IsRegion3Empty` with the addition of an ignore list. In cases where a white list is required instead, developers should check to see if any parts are returned by `Workspace/FindPartsinRegion3WithWhitelist`.
*
* How do Region3 checks work?
* ---------------------------
*
* Checking if a part overlaps a [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is not a simple process. It actually is time consuming and complicated. Instead it checks if parts are roughly in the same area. When this function is called, it figures out which voxels contain the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). It then figures out which parts might be in those voxels. It does this by comparing the axis-aligned bounding box (sometimes called the AABB) of the part with the voxels. The axis-aligned bounding box can be seen in Roblox Studio when a part is selected.
*
* This means that the area that is inspected by the function may be larger than the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3). For this reason it is recommended to make sure that the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) is on the voxel grid. The best way to do this is by setting the coordinates of the [Region3](https://developer.roblox.com/en-us/api-reference/datatype/Region3) to multiples of 4 (since voxels are 4 x 4 x 4 studs).
*
* This method is a fairly quick and easy way to see if any parts are in a general area. If a game needs to know if parts are exactly in an area, then [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) should be used. There is a higher cost to using [BasePart:GetTouchingParts](https://developer.roblox.com/en-us/api-reference/function/BasePart/GetTouchingParts) since a part is needed in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) and the function takes more time to run.
*
* Notes
* -----
*
* * If a nil value is given in the ignore list, instances after this value will not be ignored
* @deprecated Use `GetPartBoundsInBox` instead
*/
IsRegion3EmptyWithIgnoreList(this: WorldRoot, region: Region3, ignoreDescendentsTable: Array): boolean;
/**
* Casts a ray using an origin, direction, and optional [RaycastParams](https://developer.roblox.com/en-us/api-reference/datatype/RaycastParams). If it finds an eligible [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) or [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) cell, a [RaycastResult](https://developer.roblox.com/en-us/api-reference/datatype/RaycastResult) is returned containing the results of the operation. If no [RaycastParams](https://developer.roblox.com/en-us/api-reference/datatype/RaycastParams) object is provided, the defaults are used (all parts are considered and [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) water is not ignored).
*
* Note that the length (magnitude) of the directional vector is important, as objects/terrain further away than its length will not be tested. If you're using a [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) to help create the ray components, consider using `CFrame.LookVector` as the directional vector and multiply it by the desired length as shown in the example below. The maximum length of the direction vector is 5,000 studs.
*
* For a demonstration of how raycasting works, see the [Intro to Raycasting](https://developer.roblox.com/en-us/articles/raycasting) article.
*
* This method does **not** use a [Ray](https://developer.roblox.com/en-us/api-reference/datatype/Ray) object, but its origin and direction components can be borrowed from `Ray.Origin` and `Ray.Direction`.
*/
Raycast(
this: WorldRoot,
origin: Vector3,
direction: Vector3,
raycastParams?: RaycastParams,
): RaycastResult | undefined;
Shapecast(this: WorldRoot, part: BasePart, direction: Vector3, params?: RaycastParams): RaycastResult;
Spherecast(
this: WorldRoot,
position: Vector3,
radius: number,
direction: Vector3,
raycastParams?: RaycastParams,
): RaycastResult | undefined;
}
/** The Workspace is the service in which any objects that are to be rendered in the 3D world exist. Objects not descending from Workspace will not be rendered or physically interact with the world.
*
* What does the Workspace do?
* ---------------------------
*
* The core job of the Workspace is to hold objects that exist in the 3D world, [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and [Attachments](https://developer.roblox.com/en-us/api-reference/class/Attachment). Whilst such objects are descendant of Workspace, they will be active. For BaseParts this means they will be rendered, and physically interact with other parts and the world. For [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment)s this means objects adorned to them, such as [ParticleEmitters](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter), [Beams](https://developer.roblox.com/en-us/api-reference/class/Beam) and [BillboardGuis](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) will render.
*
* Understanding this behavior is important, as it means objects can be removed from the Workspace when they are not needed. For example, map [Models](https://developer.roblox.com/en-us/api-reference/class/Model) can be removed from the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) when a different map is being played on. Objects that are not immediately needed in the Workspace are generally stored in [ReplicatedStorage](https://developer.roblox.com/en-us/api-reference/class/ReplicatedStorage) or [ServerStorage](https://developer.roblox.com/en-us/api-reference/class/ServerStorage).
*
* In its role as the holder of active 3D objects, Workspace includes a number of useful functions related to parts, their positions and joints between them.
*
* Accessing the Workspace
* -----------------------
*
* The Workspace can be accessed several ways, all of which are valid.
*
* workspace -- a global variable
* game.Workspace -- a property of the DataModel
* game:GetService("Workspace") -- Workspace is a service
*
* Notes
* -----
*
* * Objects that require adornment, such as [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s and [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui)s will be adorned to the _0, 0, 0_ position when adorned to the Workspace (parented to it without an adornee otherwise being set)
* * The [Model:MakeJoints](https://developer.roblox.com/en-us/api-reference/function/Model/MakeJoints) and [Model:BreakJoints](https://developer.roblox.com/en-us/api-reference/function/Model/BreakJoints) functions inherited from the [Model](https://developer.roblox.com/en-us/api-reference/class/Model) class are overridden by the Workspace's own [Workspace:MakeJoints](https://developer.roblox.com/en-us/api-reference/function/Workspace/MakeJoints) and [Workspace:BreakJoints](https://developer.roblox.com/en-us/api-reference/function/Workspace/BreakJoints) functions, which can only be used in plugins
* * It is impossible to delete the Workspace
* * The Workspace will also clean up [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that fall beneath [Workspace.FallenPartsDestroyHeight](https://developer.roblox.com/en-us/api-reference/property/Workspace/FallenPartsDestroyHeight)
* * A client's current [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object can be accessed using the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) property
* * The [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) object can be accessed using the [Workspace.Terrain](https://developer.roblox.com/en-us/api-reference/property/Workspace/Terrain) property
*/
interface Workspace extends WorldRoot {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Workspace: unique symbol;
/** Do not use `Workspace.BreakJoints`. Use a for-loop instead */
readonly BreakJoints: never;
/** Do not use `Workspace.MakeJoints`. Use a for-loop instead */
readonly MakeJoints: never;
AirDensity: number;
/**
* This [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) property determines whether assets created by other uses can be sold in the game.
*
* What are third party sales?
* ---------------------------
*
* When this value is false, as it is by default, only assets created by the place creator (be it a player or a group) and Roblox can be sold using [MarketplaceService](https://developer.roblox.com/en-us/api-reference/class/MarketplaceService).
*
* In most cases, games do not need to sell third party assets. However, some games such as trade hangouts require this feature and therefore it exists as an opt-in option.
*
* What third party products can I sell?
* -------------------------------------
*
* Note, [developer products](https://developer.roblox.com/en-us/articles/developer-products-–-in-game-purchases) can only be sold in the game they are associated with, regardless of what AllowThirdPartySales is set to. This property will function for [game passes](https://developer.roblox.com/en-us/articles/game-passes-–-abilities-and-bonuses) and [clothing](https://developer.roblox.com/en-us/articles/how-to-make-shirts-and-pants-for-roblox-characters) however.
*
* Tags: NotReplicated
*/
AllowThirdPartySales: boolean;
ClientAnimatorThrottling: Enum.ClientAnimatorThrottlingMode;
/**
* The [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object being used by the local player.
*
* How to use CurrentCamera
* ------------------------
*
* This property can be set. When it is set, all other [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) objects in the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) are destroyed, including the previous CurrentCamera. If this property is set to nil, or the CurrentCamera is otherwise destroyed, a new [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) will be created and assigned. Developers should avoid setting this property to nil or destroying the CurrentCamera however as it can have unintended consequences.
*
* When looking for a client's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object, developers should use this property rather than looking for a child of [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) named 'Camera'.
*
* What can be done with CurrentCamera
* -----------------------------------
*
* Accessing a client's current [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object brings a range of uses.
*
* * Manipulating the viewport using the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) functions
* * Objects parented to the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) will not replicate to the server, regardless of what [Workspace.FilteringEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/FilteringEnabled) is set to. Prior to [Workspace.FilteringEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/FilteringEnabled), this was the main way to render [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s on one client only.
*
* Below is an example of how this property can be used to access the [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) object and increase its [Camera.FieldOfView](https://developer.roblox.com/en-us/api-reference/property/Camera/FieldOfView).
*
* workspace.CurrentCamera.FieldOfView = 100
*
* Tags: NotReplicated
*/
CurrentCamera: Camera | undefined;
/**
* The amount of time, in seconds, that the game has been running.
*
* Despite the title, this value is currently not 'Distributed' across the client and the server. Instead, on the server it represents how long the server has been running. On the client, it represents how long the client has been connected to the server.
*
* Developers should not rely on the above behavior, and it is possible this property will be synchronized across clients and the server in the future.
*
* Those looking for the time since the program started running should use the 'time' function instead. See below for a comparison between DistributedGameTime and its alternatives.
*
* print(workspace.DistributedGameTime) --> Time the game started running
* print(os.time()) --> Time since epoch (1 January 1970, 00:00:00) UTC
* print(tick()) --> Time since epoch (1 January 1970, 00:00:00) system time
* print(time()) --> Time the game started running
* print(elapsedTime()) --> Time since Roblox started running
*
* Tags: NotReplicated
*/
DistributedGameTime: number;
/**
* This property determines the height at which falling [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart) (and their ancestor [Models](https://developer.roblox.com/en-us/api-reference/class/Model)) are destroyed.
*
* 
*
* What happens to falling parts?
* ------------------------------
*
* For performance reasons, Roblox automatically destroys (using [Instance:Destroy](https://developer.roblox.com/en-us/api-reference/function/Instance/Destroy)) parts that fall below this value. This is to prevent parts that have fallen off the map from continuing to fall forever.
*
* If a part destroyed due to this behavior is the last part in a model, then that \`model will also be destroyed. This applies to all model ancestors of the part.
*
* This property can be read by scripts, but can only be set by plugins, the command bar or the properties window in Roblox Studio.
*
* Notes
* -----
*
* * Developers should also use the [Debris](https://developer.roblox.com/en-us/api-reference/class/Debris) service to clean up parts that are no longer needed, but have not fallen off the map
* * This property is clamped between -50,000 and 50,000. This is because [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s do not simulate or render properly at a great distance from the origin due to floating point inaccuracies
*/
FallenPartsDestroyHeight: number;
GlobalWind: Vector3;
/**
* Determines the acceleration due to gravity applied to falling [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart). This value is measured in studs per second squared and by default is set to 196.2 studs/second2. By changing this value, developers can simulate the effects of lower or higher gravity in game.
*/
Gravity: number;
InterpolationThrottling: Enum.InterpolationThrottlingMode;
Retargeting: Enum.AnimatorRetargetingMode;
/**
* The **StreamingEnabled** property determines whether game content streaming is enabled for the place. This property is not scriptable and therefore must be set on the **Workspace** object in Studio.
*
* For a detailed explanation of game content streaming, best practices, and implementation notes, see [Game Content Streaming](https://developer.roblox.com/en-us/articles/content-streaming).
*
* See also
* --------
*
* * [Workspace.StreamingMinRadius](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingMinRadius)
* * [Workspace.StreamingTargetRadius](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingTargetRadius)
* * [Workspace.StreamingPauseMode](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingPauseMode)
*/
StreamingEnabled: boolean;
/**
* This property is a reference to the [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) object parented to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace).
*
* 
*
* This property, like [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera), ensures that developers to not inadvertently index a descendant of [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace) named 'Terrain' when looking for a game's [Terrain](https://developer.roblox.com/en-us/api-reference/class/Terrain) object. Without this property, developers would need to use the [Instance:FindFirstChildOfClass](https://developer.roblox.com/en-us/api-reference/function/Instance/FindFirstChildOfClass) function.
*
* workspace.Terrain.WaterColor = Color3.new(0, 1, 0) -- make the water green
*
* Tags: NotReplicated
*/
readonly Terrain: Terrain;
/**
* Returns the number of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s that are deemed physically active, due to being recently under the influence of physics.
*
* This function provides a measure of how many [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s are being influenced by, or recently under the influence of, physical forces.
*
* print(workspace:GetNumAwakeParts()) -- prints the number of 'awake' parts
*
* Sleeping vs Awake Parts
* -----------------------
*
* In order to ensure good performance, Roblox sets `BaseParts` in which physics are not being applied to a 'sleeping' state. [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s with [BasePart.Anchored](https://developer.roblox.com/en-us/api-reference/property/BasePart/Anchored) set to true, for example, will always be sleeping as physics does not apply to them. When a force is applied to an non anchored [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart), an 'awake' state will be applied. Whilst a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is awake the Roblox physics engine will perform continuous calculations to ensure physical forces interact correctly with the part. Once the [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) is no longer subject to physical forces, it will revert to a 'sleeping' state.
*/
GetNumAwakeParts(this: Workspace): number;
/**
* Returns an integer, between 0 and 100, representing the percentage of real-time that physics simulation is currently being throttled to.
*
* This function can be used to determine whether, and to what degree, physics throttling is occurring.
*
* What is physics throttling?
* ---------------------------
*
* Physics throttling occurs when the physics engine detects it cannot keep up with the game in realtime. When physics is being throttled, it will update less frequently causing [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s to appear to move slower.
*
* Without throttling, the physics simulation would fall further behind out of sync with the game. This can lead to lower frame rates and other undesirable behavior.
*
* Objects associated with [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s are exempt from physics throttling.
*
* See also [Workspace:SetPhysicsThrottleEnabled](https://developer.roblox.com/en-us/api-reference/function/Workspace/SetPhysicsThrottleEnabled).
*
* Demonstrating physics throttling
* --------------------------------
*
* Developers should always avoid creating places that overload the physics engine, as it leads to sub-par experience for players. Those wishing to simulate physics throttling for research purposes however, need only create a lot of [Part](https://developer.roblox.com/en-us/api-reference/class/Part)s very quickly.
*
* local i = 0
* while true do
* i = i + 1
* if i % 5 == 0 then
* wait()
* end
* local part = Instance.new("Part", workspace)
* end
*/
GetPhysicsThrottling(this: Workspace): number;
/**
* Returns the number of frames per second that physics is currently being simulated at.
*
* Using GetRealPhysicsFPS to combat exploiters
* --------------------------------------------
*
* A common use of this function is to detect if exploiters are increasing their local physics frame rate to move faster. This is generally done by comparing the result returned by a client's GetRealPhysicsFPS to a maximum that will not be breached in normal circumstances (usually 65 or 70). If this limit is breached, developers can use the [Player:Kick](https://developer.roblox.com/en-us/api-reference/function/Player/Kick) function to remove that [Player](https://developer.roblox.com/en-us/api-reference/class/Player) from the game. It is important to remember that, although this practice may be effective sometimes, client-side anti-exploiter measures are never 100% reliable.
*/
GetRealPhysicsFPS(this: Workspace): number;
/**
* **GetServerTimeNow** returns the epoch time on the server with microsecond precision. The time is adjusted for drift and smoothed monotonically (it is guaranteed to be non-decreasing). The server clock progresses no faster than 1.006× speed and no slower than 0.994× speed.
*
* This function is useful for creating synchronized experiences, as it has three properties necessary for doing so: it is a real-world time clock, is monotonic and has decent precision. Essentially, it is the client's best guess of what `os.clock` would return on the server.
*
* This function relies on the server, so calling it from a core script on a client that isn't connected will throw an error.
*
* See also
* --------
*
* * [DistributedGameTime](https://developer.roblox.com/en-us/api-reference/property/Workspace/DistributedGameTime), a game-time clock
* * [`os.clock`](https://developer.roblox.com/api-reference/lua-docs/os)
* * [DateTime](https://developer.roblox.com/en-us/api-reference/datatype/DateTime)
*/
GetServerTimeNow(this: Workspace): number;
/**
* This function creates joints between the specified [Parts](https://developer.roblox.com/en-us/api-reference/class/BasePart) and any touching parts depending on the parts' surfaces and the specified joint creation mode.
*
* This function creates joints between the specified Parts and any planar touching surfaces, depending on the parts' surfaces and the specified joint creation mode.
*
* * Glue, Studs, Inlets, Universal, Weld, and Smooth surfaces will all create Weld instances.
* * Spheres will not surface-weld to anything. The rounded sides of cylinders will not surface-weld, but the flat end sides will.
* * Hinge and Motor surfaces will still create [Rotate](https://developer.roblox.com/en-us/api-reference/class/Rotate) and [RotateP](https://developer.roblox.com/en-us/api-reference/class/RotateP) joint instances, regardless of part shape.
*
* The first parameter is an array of [BaseParts](https://developer.roblox.com/en-us/api-reference/class/BasePart). Joints will only be created between the parts in the array and not in the array. Joints will not be created between the parts in the array.
*
* The second parameter is a [JointCreationMode](https://developer.roblox.com/en-us/api-reference/enum/JointCreationMode) that determines how joints will be created. Passing in either enum value, [Enum.JointCreationMode.All](https://developer.roblox.com/en-us/api-reference/enum/JointCreationMode) or [Enum.JointCreationMode.Surface](https://developer.roblox.com/en-us/api-reference/enum/JointCreationMode), has the same behavior which equates to Join Always
*
* This function is used by the Roblox Studio Move tool when the user finishes moving a selection. In conjunction with [Plugin:GetJoinMode](https://developer.roblox.com/en-us/api-reference/function/Plugin/GetJoinMode) and [Workspace:UnjoinFromOutsiders](https://developer.roblox.com/en-us/api-reference/function/Workspace/UnjoinFromOutsiders) it can be used to retain join functionality when developing custom studio build tools. See the snippets below for an example.
*
* \-- finished moving a selection, make joints
* local function finishedMovingParts(parts)
* local joinMode = Plugin:GetJoinMode()
* workspace:JoinToOutsiders(parts, joinMode)
* end\-- started moving a selection, break joints
* local function startMovingParts(parts)
* workspace:UnjoinFromOutsiders(parts)
* end
*
* Developers interested in seeing how this function is used in the Roblox Studio should see the [Studio Tools GitHub repository](https://github.com/Roblox/Studio-Tools).
*/
JoinToOutsiders(this: Workspace, objects: Array, jointType: CastsToEnum): void;
/**
* Returns true if the game has the PGS Physics solver enabled.
*
* As `Workspace/PGSPhysicsSolverEnabled` cannot be accessed by scripts, the PGSIsEnabled function allows developers to tell which physics solver the game is using.
*
* print(workspace:PGSIsEnabled()) -- true = PGS solver enabled
* print(workspace:PGSIsEnabled()) -- false = Legacy solver enabled
*
* What is the PGS Solver?
* -----------------------
*
* The PGS Solver is Roblox's state of the art physics solver which offers a range of simulation capabilities not available in Roblox's legacy solver.
*
* Note, the PGS solver is currently the default physics solver used by Roblox. Developers should expect the legacy physics solver to be deprecated or removed at some point in the future.
*
* For more information on the PGS Solver, please see [this article](https://developer.roblox.com/articles/Building-with-PGS).
*/
PGSIsEnabled(this: Workspace): boolean;
/**
* Breaks all joints between the specified [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s and other [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s.
*
* This function requires an array of [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s. Note, joints will not be broken between these [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s (each other), only between these [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s and other [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart)s not in the array.
*
* This function is used by the Roblox Studio Move tool when the user starts moving a selection. In conjunction with [Plugin:GetJoinMode](https://developer.roblox.com/en-us/api-reference/function/Plugin/GetJoinMode) and [Workspace:JoinToOutsiders](https://developer.roblox.com/en-us/api-reference/function/Workspace/JoinToOutsiders) it can be used to retain join functionality when developing custom studio build tools. See the snippets below for an example.
*
* \-- finished moving a selection, make joints
* local function finishedMovingParts(parts)
* local joinMode = Plugin:GetJoinMode()
* workspace:JoinToOutsiders(parts, joinMode)
* end\-- started moving a selection, break joints
* local function startMovingParts(parts)
* workspace:UnjoinFromOutsiders(parts)
* end
*
* Developers interested in seeing how this function is used in the Roblox Studio should see the [Studio Tools GitHub repository](https://github.com/Roblox/Studio-Tools).
*/
UnjoinFromOutsiders(this: Workspace, objects: Array): void;
readonly PersistentLoaded: RBXScriptSignal<(player: Player) => void>;
}
/** The WorldModel provides some physics features to a [ViewportFrame](https://developer.roblox.com/en-us/api-reference/class/ViewportFrame).
*
* More specifically, you can make a WorldModel a child of a ViewportFrame, and then parent geometry to the WorldModel. This will then allow you to use [raycasts](https://developer.roblox.com/en-us/articles/raycasting) in the ViewportFrame through the WorldModel. Furthermore you can put [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) characters in the WorldModel and their joints will be set-up correctly, and you can animate them.
*/
interface WorldModel extends WorldRoot {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_WorldModel: unique symbol;
}
/** The purpose of the PackageLink object is to link a [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel) instance to a corresponding asset in the cloud. This improves flows for collaboration, version control and sharing for models. The PackageLink instance will be a child of the root of the entire package hierarchy.
*
* 
*
* In this case PackageLink designates [Model](https://developer.roblox.com/en-us/api-reference/class/Model) to be the root of the Package hierarchy.
*
* They not creatable through [scripts](https://developer.roblox.com/en-us/api-reference/class/Script). They can only be added through interaction with Studio and can only be parented to [Instances](https://developer.roblox.com/en-us/api-reference/class/Instance) that can be published independently of DataModel publish. The PackageLink instance will always be the first child shown in the tree view, regardless of sorting.
*/
interface PackageLink extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PackageLink: unique symbol;
readonly DefaultName: string;
/**
* The id of the asset this package corresponds to.
*
* Tags: NotReplicated
*/
readonly PackageId: string;
/**
* This property refers to a revision of a specific package
*
* Tags: NotReplicated
*/
readonly VersionNumber: number;
}
interface PackageUIService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PackageUIService: unique symbol;
}
/** An object which is essentially a table of pages, each of which is a sorted list of the key/value pairs.
* When each page contains a list of multiple items, this iterator function may be handy:
*
* function iterPageItems(pages)
* return coroutine.wrap(function()
* local pagenum = 1
* while true do
* for \_, item in ipairs(pages:GetCurrentPage()) do
* coroutine.yield(item, pagenum)
* end
* if pages.IsFinished then
* break
* end
* pages:AdvanceToNextPageAsync()
* pagenum = pagenum + 1
* end
* end)
* end
*
* Which can be used as
*
* for item, pageNo in iterPageItems(myPageObject) do
* -- look at item. Pages will advance automatically
* end
*/
interface Pages extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Pages: unique symbol;
/**
* Whether or not the current page is the last page available.
*
* Tags: NotReplicated
*/
readonly IsFinished: boolean;
/**
* Returns the items on the current page. The keys in the item are determined by the source of this object.
*/
GetCurrentPage(this: Pages): Array;
/**
* Iterates to the next page in the pages object, if possible.
*
* Tags: Yields
*/
AdvanceToNextPageAsync(this: Pages): void;
}
interface AudioPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_AudioPages: unique symbol;
}
interface CatalogPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_CatalogPages: unique symbol;
}
/** A special type of [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) object whose pages contain [DataStoreKey](https://developer.roblox.com/en-us/api-reference/class/DataStoreKey) instances. [Pages:GetCurrentPage](https://developer.roblox.com/en-us/api-reference/function/Pages/GetCurrentPage) can be used to retrieve an array of the [DataStoreKey](https://developer.roblox.com/en-us/api-reference/class/DataStoreKey) instances.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreKeyPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreKeyPages: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Cursor: string;
}
/** A special type of [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) object whose pages contain [DataStoreInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreInfo) instances. [Pages:GetCurrentPage](https://developer.roblox.com/en-us/api-reference/function/Pages/GetCurrentPage) can be used to retrieve an array of the [DataStoreInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreInfo) instances.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreListingPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreListingPages: unique symbol;
/**
* Tags: NotReplicated
*/
readonly Cursor: string;
}
/** A special type of [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) object whose pages contain key/value pairs from an [OrderedDataStore](https://developer.roblox.com/en-us/api-reference/class/OrderedDataStore). For this object, [GetCurrentPage()](https://developer.roblox.com/en-us/api-reference/function/Pages/GetCurrentPage) returns an array of tables, each containing keys named **key** and **value**; these reflect the key/value pair data. */
interface DataStorePages extends Pages<{ key: string; value: unknown }> {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStorePages: unique symbol;
}
/** A special type of [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) object whose pages contain [DataStoreObjectVersionInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreObjectVersionInfo) instances from a [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore). [Pages:GetCurrentPage](https://developer.roblox.com/en-us/api-reference/function/Pages/GetCurrentPage) can be used to retrieve an array of the [DataStoreObjectVersionInfo](https://developer.roblox.com/en-us/api-reference/class/DataStoreObjectVersionInfo) instances.
*
* See Also
* --------
*
* * [Data Stores](https://developer.roblox.com/en-us/articles/data-store), an in-depth guide on data structure, management, error handling, etc.
*/
interface DataStoreVersionPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DataStoreVersionPages: unique symbol;
}
/** FriendPages is a special version of the [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) returned by [Players:GetFriendsAsync](https://developer.roblox.com/en-us/api-reference/function/Players/GetFriendsAsync). The items contained within describe information about a player's friends, and have the following structure:
*
* Name
*
* Type
*
* Description
*
* `Id`
*
* int64
*
* The user ID of the friend
*
* `Username`
*
* string
*
* The current username of the friend
*
* `IsOnline`
*
* boolean
*
* Whether or not the user is presently online.
*
* See the code samples for an easy way to iterate over a player's friends.
*/
interface FriendPages
extends Pages<{ AvatarFinal: boolean; AvatarUri: string; Id: number; Username: string; IsOnline: boolean }> {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_FriendPages: unique symbol;
}
/** The InventoryPages class is used in the case of iterating over a specific category in a user's inventory. */
interface InventoryPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_InventoryPages: unique symbol;
}
interface EmotesPages extends InventoryPages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_EmotesPages: unique symbol;
}
interface OutfitPages
extends Pages<
ReadonlyArray<{
Id: number;
Name: string;
IsEditable: boolean;
}>
> {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_OutfitPages: unique symbol;
}
/** A generic version of the Pages class, which may contain variable data, depending on what method it was returned from.
* See the [Pages](https://developer.roblox.com/en-us/api-reference/class/Pages) class for more information.
*/
interface StandardPages extends Pages {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_StandardPages: unique symbol;
}
/** A ParticleEmitter allows for the creation of [particle systems](https://en.wikipedia.org/wiki/Particle_system). It is a special effect object that emits customizable 2D billboard particles into the world. On Roblox, a particle is a square 2D image, like a [BillboardGui](https://developer.roblox.com/en-us/api-reference/class/BillboardGui) or [SurfaceGui](https://developer.roblox.com/en-us/api-reference/class/SurfaceGui) with an [ImageLabel](https://developer.roblox.com/en-us/api-reference/class/ImageLabel).
*
* To emit and render particles, a ParticleEmitter must be parented to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) (such as a [Part](https://developer.roblox.com/en-us/api-reference/class/Part)) or an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) within such a part. Particles are emit automatically when the emitter is [Enabled](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Enabled) with a non-zero [Rate](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rate), or manually when the [Emit](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Emit) method is called. The starting positions of particles are determined by the [Shape](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Shape) and [ShapePartial](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/ShapePartial) properties as well as the parent [BasePart.Size](https://developer.roblox.com/en-us/api-reference/property/BasePart/Size). By default, particles spawn randomly in the **bounding box** of the parent part, although this can be configured to be on a specific surface by the emitter's [ShapeStyle](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/ShapeStyle) and [EmissionDirection](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/EmissionDirection). With a non-zero [Speed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Speed), particles are set in motion outwards and/or inwards, depending on the [ShapeInOut](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/ShapeInOut) property. The direction can be randomized with [SpreadAngle](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/SpreadAngle). By default, particles face the camera, but the [Orientation](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Orientation) can be modified to respect the particle velocity instead.
*
* During the [Lifetime](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Lifetime) of the particles, they can change appearance according to the [Color](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Color) and [Size](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Size). Their motion can change over time according to the [Drag](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Drag) and [Acceleration](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Acceleration) properties, and they can also move as their parent moves when they are [LockedToPart](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LockedToPart) or have a non-zero [VelocityInheritance](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/VelocityInheritance).
*
* Roblox provides several pre-made particle effect objects - [Fire](https://developer.roblox.com/en-us/api-reference/class/Fire), [Smoke](https://developer.roblox.com/en-us/api-reference/class/Smoke) and [Sparkles](https://developer.roblox.com/en-us/api-reference/class/Sparkles). They behave similarly to a ParticleEmitter, but they are not as customizable. They also lack the particle-controlling methods ([Emit](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Emit) and [Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear)). An [Explosion](https://developer.roblox.com/en-us/api-reference/class/Explosion) also creates particles, but provides little-to-no control with regards to how the effect looks.
*
* See also
* --------
*
* * To learn more about creating, using, and customizing particle emitters check out [this](https://developer.roblox.com/articles/Particle-Emitters) article
*/
interface ParticleEmitter extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ParticleEmitter: unique symbol;
/**
* The Acceleration property determines how particles [ParticleEmitter.Speed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Speed) changes over the particle's lifetime. It is defined using a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) to determine the acceleration on the global X/Y/Z axes. It is measured in studs per second squared. When changed, this property affects all particles emit by the emitter, both current and future particles.
*
* Pictured below are two default ParticleEmitters. The foreground (right) emitter has an Acceleration on the positive-X axis, causing the path of the particles to bend in that direction.
* 
*
* Acceleration will slow particles down if the vector points in the opposite [ParticleEmitter.EmissionDirection](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/EmissionDirection) in which particles are emitted. Otherwise, it will speed them up. You can use [ParticleEmitter.Drag](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Drag) to slow particles down no matter what direction they travel.
*
* Acceleration is most often used to apply a gravity effect to particles (try a value of (0, -3, 0) for this). You can also use small values on the X/Z axes to make it look like particles are being blown away by wind. If you emit a bubble particle downwards, you could use an acceleration of (0, 5, 0) to cause the bubbles to decelerate and then float back upwards.
*/
Acceleration: Vector3;
Brightness: number;
/**
* The Color property determines the color of all particles active in an emitter's system. The color is applied to the [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture) when rendering, and uses the texture alpha along with the [ParticleEmitter.Transparency](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Transparency). If a particle has a [ParticleEmitter.LightEmission](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightEmission) of greater than 0, darker colors will make particles appear more transparent. Below, two default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) are pictured, except the right emitter uses a Color from yellow to cyan.
*
* 
*
* Note that the default [ParticleEmitter.Lifetime](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Lifetime) is 5 to 10 seconds, so some particles next to each other have small variations in color due to the variations in individual particle lifetime.
*
* A particle's present color is determined by linearly interpolating on this ColorSequence using the particle's age and the particle's total lifetime. For example, if a particle spawned 2 seconds ago and has a 4 second lifetime, the color will be whatever is 50% of the way through the [ColorSequence](https://developer.roblox.com/en-us/api-reference/datatype/ColorSequence).
*
* Changing this property applies changes to all particles present in the system. This is because the color of a particle is determined using its present lifetime and this ColorSequence (the ColorSequence when the particle was emit is not stored on a per-particle basis).
*/
Color: ColorSequence;
/**
* The Drag property determines the rate in seconds at which individual particles will lose half their speed via exponential decay. Pictured below are two identical default ParticleEmitters, except that the right has a Drag value of 0.25.
*
* 
*
* Drag is applied by scaling the expected velocity (from [ParticleEmitter.Speed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Speed) and any velocity inherited from the parent from [ParticleEmitter.VelocityInheritance](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/VelocityInheritance)) by the following formula: `2 ^ (elapsedTime * -drag)`, where `elapsedTime` is the time since the particle was emit. Consequently, setting Drag to a negative value will cause particles' velocities to grow exponentially.
*
* Warning: if Drag is set to a sufficiently negative value, this can cause all particles emit by the emitter to completely disappear. Be careful when setting this property lower than -100.
*/
Drag: number;
/**
* The EmissionDirection property determines the face ([NormalId](https://developer.roblox.com/en-us/api-reference/enum/NormalId)) of the parent object towards which particles will be emit. By default, this is the top (+Y) direction. A negative [ParticleEmitter.Speed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Speed) will emit in the opposite direction. [ParticleEmitter.SpreadAngle](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/SpreadAngle) will further vary the emission direction. If a [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) is added to an [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment), which has a direction, the the Attachment itself can be rotated ([Attachment.Orientation](https://developer.roblox.com/en-us/api-reference/property/Attachment/Orientation)) instead of using this property. Below are pictured two ParticleEmitters which are otherwise the same, except the left has an EmissionDirection of Top (+Y, default) and the right uses Front (-Z).
*
* 
*/
EmissionDirection: Enum.NormalId;
/**
* The Enabled property determines whether a [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) should emit partciles according to its [ParticleEmitter.Rate](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rate). Setting Enabled to false will halt further particles from spawning; any existing particles will remain until they expire. This property is useful when you have a pre-made particle effect that you want to remain disabled until you need it to emit particles.
*
* If you want no particles to render, you should call [ParticleEmitter:Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear) to clear any existing particles. You can use [ParticleEmitter:Emit](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Emit) on disabled [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s and they will still emit and render particles.
*/
Enabled: boolean;
FlipbookFramerate: NumberRange;
FlipbookIncompatible: string;
FlipbookLayout: Enum.ParticleFlipbookLayout;
FlipbookMode: Enum.ParticleFlipbookMode;
FlipbookStartRandom: boolean;
/**
* The Lifetime property defines the maximum and minimum ages a newly emit particle will. When a particle is emit, a random lifetime is chosen uniformly. Lifetimes are stored on a per-particle basis, so if this value is changed, existing particles will stay “alive” until their randomly chosen lifetime is lived. The bounds for this property should be in the range \[0, 20\]. By default, [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s will have a lifetime of 5 to 10 seconds. A lifetime of 0 will prevent particles from being emit in the first place.
*
* it is important to pick a sensible Lifetime and [ParticleEmitter.Rate](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rate) so that you don't have too many particles being rendered at once. Long lifetimes and high emission rates are a quick way to cause performance issues. If you need many particles, pick a balance of lifetime and rate. To instantly remove any presently emit particles (perhaps ones with absurdly long lifetimes), you can call [ParticleEmitter:Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear).
*/
Lifetime: NumberRange;
/**
* The LightEmission property determines the blending of the [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture)'s colors with the colors behind them. It should be set on the range \[0, 1\]. A value of 0 uses normal blending modes, and a value of 1 will use additive blending. The value of the additive blending is determined by this property. When changed, this property instantly affects all particles owned by the emitter, both current and future particles.
*
* Pictured below are two default ParticleEmitters. The right one has its LightEmission set to 1, so the particles appear brighter due to the additive blending when they overlap.
* 
*
* When set to 1, only additive blending is used. As such, choosing a suitable [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture) is necessary. Below is an example texture that is suitable for such a ParticleEmitter.
* 
*
* This property should not be confused with [ParticleEmitter.LightInfluence](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightInfluence), which determines how particles are affected by environment light. This property does not cause particles to light the environment around them. To do that, consider using a [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight).
*/
LightEmission: number;
/**
* The LightInfluence property determines how much environment light affects the color of individual particles when they are rendered. It must be in the range \[0, 1\]; behavior of values outside of this range are not defined. At 0, particles are not influenced by light at all (they retain full brightness), and at 1 particles are fully influenced by light (in complete darkness, particles will be black).
*
* Pictured below are three default ParticleEmitters [at night](https://www.youtube.com/watch?v=bLIVeQgS_pI) with varing LightInfluence. There is a [PointLight](https://developer.roblox.com/en-us/api-reference/class/PointLight) with sufficient `PointLight/Brightness` and [PointLight.Range](https://developer.roblox.com/en-us/api-reference/property/PointLight/Range) to light the particles near to their parent parts. Take note of how each particle is affected by the lack of light close to the end of their lifetime.
*
* 
*
* By default, this value is 1 if inserted with Studio tools. If inserted using `Instance.new`, it is 0.
*/
LightInfluence: number;
/**
* The LockedToPart property determines if particles will “stick” to the emission source (the [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) or [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) to which the [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) is parented).
*
* Below is an animation of two [Parts](https://developer.roblox.com/en-us/api-reference/class/Part) being moved simultaneously in Studio. Inside each is a default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter); the background/left emitter has LockedToPart enabled so the column of particles moves as the part is moved. Contrast with the foreground/right emitter particles which stay in their world position.
* 
*
* Also consider using the [ParticleEmitter.VelocityInheritance](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/VelocityInheritance) property set to 1, which may be more appropriate for some effects.
*/
LockedToPart: boolean;
/**
* This property determines which orientation mode to use for an emitter's particle geometry:
*
* FaceCamera: standard camera facing billboard quad, default behavior.
* FaceCameraWorldUp: face the camera, but rotating only on the vertical world-up Y-axis.
* VelocityParallel: align particles parallel to the direction of their movement.
* VelocityPerpendicular: align particles perpendicular to the direction of their movement.
*/
Orientation: Enum.ParticleOrientation;
/**
* The Rate property determines how many particles are [ParticleEmitter:Emit](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Emit) emit per second while the [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) is [ParticleEmitter.Enabled](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Enabled). It is the inverse of frequency - a Rate of 5 means that a particle will be emit every `1/5 = 0.2` seconds. When changed, this property will have no affect on any already emit particles.
*
* it is important to pick a sensible [ParticleEmitter.Lifetime](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Lifetime) and Rate so that you don't have too many particles being rendered at once. Long lifetimes and high emission rates are a quick way to cause performance issues. If you need many particles, pick a balance of lifetime and rate. To instantly remove any presently emit particles (perhaps ones with absurdly long lifetimes), you can call [ParticleEmitter:Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear).
*/
Rate: number;
/**
* The RotSpeed property determines a random range of angular speeds that newly emit particles will have. A random angular speed is chosen upon emission, so changing this property will not affect already emit particles. This property, along with [ParticleEmitter.Rotation](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rotation) affect the angle of the rendered particle image. This property is a [NumberRange](https://developer.roblox.com/en-us/api-reference/datatype/NumberRange) measured in degrees per second.
*
* Below is an animation of two default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s. The right has a nonzero RotSpeed, so its particles rotate as they move through the world.
* 
*
* Using a spiral as a [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture) like the one below, you can create some quite interesting particle effects:
* 
*
* Particles with very high angular speeds can appear to rotate slower or not at all - this is because the angle of rotation is synchronized with the software render speed. In other words, if the particle is rotating at exactly 360 degrees every frame, there will be no apparent change in rotation.
*/
RotSpeed: NumberRange;
/**
* The Rotation property determines the angle at which new particles are emit. It is a [NumberRange](https://developer.roblox.com/en-us/api-reference/datatype/NumberRange) measured in degrees. Positive values are in the clockwise direction. This property is often set to \[0, 360\] to provide a completely random rotation to new particles. [ParticleEmitter.RotSpeed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/RotSpeed) also influences the rotation of a particle over its lifetime. Finally, this property is useful for correcting any [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture)s that aren't at the desired orientation.
*
* Pictured below are two default ParticleEmitters, except that the right has a Rotation of 22.5. Note how the particles on the left are straight up, and the right are tilted slightly.
*
* 
*
* Changes to this value only affect new particles; existing particles will maintain the rotation at which they were originally emitted.
*/
Rotation: NumberRange;
Shape: Enum.ParticleEmitterShape;
ShapeInOut: Enum.ParticleEmitterShapeInOut;
ShapePartial: number;
ShapeStyle: Enum.ParticleEmitterShapeStyle;
/**
* The Size property determines the world size in studs of all active particles over their individual lifetimes. This property represents the dimensions of the square [ParticleEmitter.Texture](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Texture) for each particle. It is a [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence) that works similar to [ParticleEmitter.Transparency](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Transparency) and [ParticleEmitter.Color](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Color).
*
* Below is an animation of two default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) where the right one has a Size of 0 to 2. Note how the particles grow over their lifetime.
* 
*
* A particle's present size is determined by linearly interpolating on this NumberSequence using the particle's age and the particle's total lifetime. For example, if a particle spawned 2 seconds ago and has a 4 second lifetime, the size will be whatever is 50% of the way through the [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence). For any [NumberSequenceKeypoint](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequenceKeypoint) with a nonzero envelop value, a random value in the envelop range is chosen for each keypoint for each particle when it spawns.
*
* Changing this property applies changes to all particles present in the system. This is because the size of a particle is determined using its present lifetime and this NumberSequence (the Size at the time the particle was emit is not stored on a per-particle basis).
*
* Design Note
* -----------
*
* When designing particle effects, size is probably the most important of all properties. Too large or too subtle can ruin a particle effect! The first thing you should do is decide how you want particles to enter and exit view - fade in/out, or grow/shrink from size 0? The choice is yours - start with a size NumberSequence from 0 to 3 or the reverse and go from there.
*/
Size: NumberSequence;
/**
* The Speed property determines the random range of velocities that newly emit particles may have. It is measured in studs per second using a [NumberRange](https://developer.roblox.com/en-us/api-reference/datatype/NumberRange). The velocity is chosen upon emission, and is applied in the [ParticleEmitter.EmissionDirection](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/EmissionDirection). Negative speed values will cause particles to travel in reverse.
*
* Below is an animation of two default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s; the left has the default Speed of 5. The right one has the Speed range set to \[20, 20\], so its particles emit at a constant speed of 20.
* 
*
* [ParticleEmitter.VelocityInheritance](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/VelocityInheritance), [ParticleEmitter.Acceleration](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Acceleration) and [ParticleEmitter.Drag](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Drag) will affect a particle's speed over its lifetime. Changing Speed will not affect already existing particles - they will retain whatever speed they have already.
*/
Speed: NumberRange;
/**
* The SpreadAngle property determines the random angles that a particle may be emit. On emission, a random angle is selected uniformly using the range defined by SpreadAngle. For example, if the [ParticleEmitter.EmissionDirection](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/EmissionDirection) is Top (+Y), then this [Vector2](https://developer.roblox.com/en-us/api-reference/datatype/Vector2) describes the size of the random angle spread on the X/Z axes, in degrees. The particle is given a velocity based on the [ParticleEmitter.Speed](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Speed) in the chosen direction.
*
* Below is an animation of two default ParticleEmitters. The foreground (closer) emitter has one of its SpreadAngle axes set to 90 degrees, so particles are emit randomly in an arc.
* 
*
* Setting one axis to 360 will cause particles to emit in all direction in a **circle**. Setting both to 360 will cause particles to emit in all directions in a **sphere**.
*/
SpreadAngle: Vector2;
Squash: NumberSequence;
/**
* The Texture property determines the image rendered on particle billboards. The rendered image is influenced by [ParticleEmitter.Color](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Color), [ParticleEmitter.Transparency](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Transparency), [ParticleEmitter.LightInfluence](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightInfluence), and [ParticleEmitter.LightEmission](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightEmission). Transparent textures work best for particles
*
* Pictured below are two default ParticleEmitters, but the right one uses the Robux icon as a texture.
*
* 
*
* Example Textures
* ----------------
*
* The following texture is a transparent PNG image that works well as a Texture for a [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter). Try uploading it as a decal to your account and using it in a ParticleEmitter's texture.
* 
*
* Below is an opaque gray-scale Texture that works nicely for particles with [ParticleEmitter.LightEmission](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LightEmission) set to 1.
* 
*/
Texture: string;
TimeScale: number;
/**
* The Transparency property determines the transparency of all active particles over their individual lifetimes. It works similar to [ParticleEmitter.Size](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Size) in how it affects particles over time. In terms of rendering, it works like the [BasePart.Transparency](https://developer.roblox.com/en-us/api-reference/property/BasePart/Transparency) of a part on a scale of 0 to 1, where 0 is completely visible (opaque), and a value of 1 is completely invisible (not rendered at all).
*
* Pictured below are two default [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter)s. The right emitter has a Transparency set to a [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence) that interpolates from 0 to 1.
* 
*
* A particle's present transparency is determined by linearly interpolating on this NumberSequence using the particle's age and the particle's total lifetime. For example, if a particle spawned 2 seconds ago and has a 4 second lifetime, the transparency will be whatever is 50% of the way through the [NumberSequence](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequence). For any [NumberSequenceKeypoint](https://developer.roblox.com/en-us/api-reference/datatype/NumberSequenceKeypoint) with a nonzero envelop value, a random value in the envelop range is chosen for each keypoint for each particle when it spawns.
*
* Changing this property applies changes to all particles present in the system. This is because the transparency of a particle is determined using its present lifetime and this `NumberSequence` (the Transparency at the time the particle was emit is not stored on a per-particle basis).
*/
Transparency: NumberSequence;
/**
* The VelocityInheritance property determines how much of the parent part's [BasePart.Velocity](https://developer.roblox.com/en-us/api-reference/property/BasePart/Velocity) is inherited by particles when they are emitted. A value of 0 means that no velocity is inherited, and a value of 1 means the particle will have the exact same speed as the parent [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart).
*
* Below is an animation of a [Part](https://developer.roblox.com/en-us/api-reference/class/Part) moving back and forth. As it changes direction, the VelocityInheritance will toggle between 0 and 1. Note that when it is 1, the particles move with the part.
* 
*
* When used in conjunction with [ParticleEmitter.Drag](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Drag), a particle emitter can make appear to be “shedding” particles from a moving part.
*/
VelocityInheritance: number;
/**
* This property determines how offset a particle can be fired from the local emitter direction of its parent. When a particle is created its offset is picked randomly between 0 and VelocitySpread. This value is measured in degrees.
*
* Tags: NotReplicated
* @deprecated Use `SpreadAngle` instead
*/
VelocitySpread: number;
WindAffectsDrag: boolean;
/**
* The ZOffset property determines the forward-backward (Z) render position of particles, in studs. they render at a modified [ParticleEmitter.Size](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Size) such that this property will not affect the screen size of particles. When changed, this property will affects all particles, both current and future particles. Note that this property accepts fractional values; it is not like [GuiObject.ZIndex](https://developer.roblox.com/en-us/api-reference/property/GuiObject/ZIndex) (an integer)
*
* Pictured below are three default ParticleEmitters with varying ZOffset values. The center is default, the left has +2 and the right has -2. Note how all the particles have the same apparent screen size.
* 
*
* A practical use of ZOffset is for `ParticleEmitters` placed in players' characters: use it to define if particles should appear in front of or behind the character (use a value of +/- 2).
*
* 
*
* Positive values will move particles closer to the camera, and negative values move particles away. Sufficiently negative values can cause particles to render inside or behind the parent part.
*/
ZOffset: number;
/**
* The Clear method will instantly destroy any existing particles that have been emit by the [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) via its natural emission (nonzero [ParticleEmitter.Rate](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rate) on an [ParticleEmitter.Enabled](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Enabled) emitter) or via [ParticleEmitter:Emit](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Emit). It is not possible to clear individual particles - all are deleted at once.
*
* Sometimes it is desirable to clear particles before teleporting a character so that there are no lingering effects that might follow due to [ParticleEmitter.LockedToPart](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/LockedToPart).
*/
Clear(this: ParticleEmitter): void;
/**
* The Emit method will cause the [ParticleEmitter](https://developer.roblox.com/en-us/api-reference/class/ParticleEmitter) to emit the given number of particles similar to how [ParticleEmitter.Rate](https://developer.roblox.com/en-us/api-reference/property/ParticleEmitter/Rate) does on `ParticleEmitter/Enalbed` emitters. Be warned - this always emits exactly the number of particles even if Roblox' graphics settings are lower. Emitting too many particles can cause performance issues on lower-end hardware.
*
* To clear any emit particles, use [ParticleEmitter:Clear](https://developer.roblox.com/en-us/api-reference/function/ParticleEmitter/Clear).
*/
Emit(this: ParticleEmitter, particleCount?: number): void;
/**
* Tags: Hidden
*/
readonly OnClearRequested: RBXScriptSignal<() => void>;
/**
* Tags: Hidden
*/
readonly OnEmitRequested: RBXScriptSignal<(particleCount: number) => void>;
}
interface PatchBundlerFileWatch extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PatchBundlerFileWatch: unique symbol;
}
interface PatchMapping extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PatchMapping: unique symbol;
FlattenTree: boolean;
PatchId: string;
TargetPath: string;
}
/** **Path** objects store the result of paths created by [PathfindingService:CreatePath()](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/CreatePath).
*
* Once a path object is created, you can call [Path:ComputeAsync()](https://developer.roblox.com/en-us/api-reference/function/Path/ComputeAsync) with a starting point and ending point. This will attempt to compute a valid path for a character to move along, based on default or custom parameters passed to [CreatePath()](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/CreatePath). If [ComputeAsync()](https://developer.roblox.com/en-us/api-reference/function/Path/ComputeAsync) successfully finds a path, the [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object will have a [Path.Status](https://developer.roblox.com/en-us/api-reference/property/Path/Status) value of `Enum.PathStatus.Success`. Otherwise the status will be `Enum.PathStatus.NoPath` which can occur if there are obstacles between the two points (and no way around) or if the points are inside of solid objects.
*
* In addition to [ComputeAsync()](https://developer.roblox.com/en-us/api-reference/function/Path/ComputeAsync), [Path](https://developer.roblox.com/en-us/api-reference/class/Path) objects have the [GetWaypoints()](https://developer.roblox.com/en-us/api-reference/function/Path/GetWaypoints) method which returns a list of waypoints representing the points a character should follow in sequence to get from the beginning to the end of the path.
*
* Finally, [Path](https://developer.roblox.com/en-us/api-reference/class/Path) objects can be **connected** to the [Path.Blocked](https://developer.roblox.com/en-us/api-reference/event/Path/Blocked) event. This event will fire if, at any time during the path's existence, the path is blocked. Note that this can occur **behind** a character moving along the path, not just in front of it.
*
* See the [Pathfinding](https://developer.roblox.com/en-us/articles/pathfinding) guide for details and examples on using pathfinding in Roblox.
*/
interface Path extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Path: unique symbol;
/**
* The success of the generated [Path](https://developer.roblox.com/en-us/api-reference/class/Path).
*
* Tags: NotReplicated
*/
readonly Status: Enum.PathStatus;
/**
* This function returns a table of [Path](https://developer.roblox.com/en-us/api-reference/class/Path) instances.
* @deprecated Use `GetWaypoints` instead
*/
GetPointCoordinates(this: Path): unknown;
/**
* This function returns an array of all the [PathWaypoints](https://developer.roblox.com/en-us/api-reference/datatype/PathWaypoint) in a [Path](https://developer.roblox.com/en-us/api-reference/class/Path), as computed by [Path:ComputeAsync](https://developer.roblox.com/en-us/api-reference/function/Path/ComputeAsync).
*
* Each waypoint in the array specifies a [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) position and [action](https://developer.roblox.com/en-us/api-reference/enum/PathWaypointAction) to take when this PathWaypoint is reached. The array is arranged in the order of waypoints from the path start to path end.
*
* If a path could not be computed, this function will return an empty array.
*/
GetWaypoints(this: Path): Array;
/**
* This function checks if a path is blocked starting at the waypoint indicated by **start**.
*
* It returns the first waypoint of occlusion if blocked, -1 if not. it returns an error if **start** is less than 0 or greater than the number of waypoints in the [Path](https://developer.roblox.com/en-us/api-reference/class/Path).
*
* Tags: Yields
*/
CheckOcclusionAsync(this: Path, start: number): number;
/**
* This function computes a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) from a start position to an end position. This function is not automatically called when a path is created and must be invoked each time the path needs to be updated.
*
* Once the Path is computed, it will have a series of waypoints that, when followed, can lead a character along the path. These points are gathered with the [Path:GetWaypoints](https://developer.roblox.com/en-us/api-reference/function/Path/GetWaypoints) function.
*
* See also
* --------
*
* * [Pathfinding](https://developer.roblox.com/en-us/articles/pathfinding), provides an in-depth pathfinding walkthrough
*
* Tags: Yields
*/
ComputeAsync(this: Path, start: Vector3, finish: Vector3): void;
readonly Blocked: RBXScriptSignal<(blockedWaypointIdx: number) => void>;
readonly Unblocked: RBXScriptSignal<(unblockedWaypointIdx: number) => void>;
}
interface PathfindingLink extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PathfindingLink: unique symbol;
Attachment0: Attachment | undefined;
Attachment1: Attachment | undefined;
IsBidirectional: boolean;
Label: string;
}
/** For a more detailed overview of the [PathfindingService](https://developer.roblox.com/en-us/api-reference/class/PathfindingService) and [PathfindingModifiers](https://developer.roblox.com/en-us/api-reference/class/PathfindingModifier), see the [Pathfinding](https://developer.roblox.com/en-us/articles/pathfinding) article.
*
* Pathfinding modifiers can be used to represent space that has a higher or lower cost to be traversed. When added as a child to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part), it takes that Part's volume to annotate areas of the navmesh that are inside and on top of it.
*
* You can include pathfinding modifiers in the [PathfindingService:CreatePath](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/CreatePath) parameters and compute smarter paths across various materials or around defined regions.
*
* Note that when adding a [PathfindingModifier](https://developer.roblox.com/en-us/api-reference/class/PathfindingModifier) to a part, **either**:
*
* 1. The part is [collidable](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) and we are interested in modifying pathfinding costs of paths on top of this part, which we call **area**.
* 2. The part is [non-collidable](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) (and usually invisible in game) and we are interested in modifying pathfinding costs of paths inside the part, which we call **volume**.
*/
interface PathfindingModifier extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PathfindingModifier: unique symbol;
/**
* **Beta Feature**
*
* This class is currently a part of the PathfindingModifier beta feature. Eligible developers must enable the feature within Studio and functionality may change.
*
* For a more detailed overview of the [PathfindingService](https://developer.roblox.com/en-us/api-reference/class/PathfindingService) and PathfindingModifiers, you can take a look at the [Pathfinding](https://developer.roblox.com/articles/Pathfinding) article.
*
* The name of the navigation area inside or on top of the [Part's](https://developer.roblox.com/en-us/api-reference/class/Part) volume.
*/
Label: string;
/**
* Determines if the parts enclosed by the modifier are traversable, even if they would normally be collided with. See [Ignoring Obstacles](https://developer.roblox.com/articles/Pathfinding#ignoring-obstacles) for details.
*/
PassThrough: boolean;
}
/** **PathfindingService** is used to find paths between two points. These paths make sure that characters can move between the points without running into walls or other obstacles. Paths can be used for both player-controlled characters and non-player characters.
*
* This service has one function, [CreatePath()](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/CreatePath), which creates a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object based on various parameters.
*
* See the [Pathfinding](https://developer.roblox.com/en-us/articles/pathfinding) guide for details and examples on using pathfinding in Roblox.
*
* Navigation Mesh
* ---------------
*
* **PathfindingService** generates a “navigation mesh” over all parts in a place while the game is running. Any path that is created with the service will stay within the mesh. If the geometry of the place changes — for example, if a part is created or a part moves — the navigation mesh will be recalculated.
*
* To see the navigation mesh for a place:
*
* 1. Open the place in Studio.
* 2. Navigate to **File** → **Settings…**.
* 3. In the **Studio** tab, under **Visualization**, toggle on the **Show Navigation Mesh** setting. The mesh will then show up in the 3D view.
*
* The purple areas show where a character can walk, while the non-colored areas are considered blocked. Studio also displays arrows on top of the mesh which show where a character would have to **jump** to reach one part of the mesh from another.
*
* 
*/
interface PathfindingService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PathfindingService: unique symbol;
/**
* This function worked with the legacy pathfinding system. The pathfinding system currently uses a navigation grid and the EmptyCutoff is unused.
*
* When the [PathfindingService](https://developer.roblox.com/en-us/api-reference/class/PathfindingService) computes a path using [PathfindingService:ComputeRawPathAsync](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/ComputeRawPathAsync) or [PathfindingService:ComputeRawPathAsync](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/ComputeRawPathAsync) it uses the voxel representation of the world. A voxel is one cube in a grid overlayed on the world. In this case the voxels being used are 4x4x4. This property sets the percent of a voxel has to be occupied to be considered empty. Defaults to 0.16. .
*
* Tags: NotReplicated
* @deprecated
*/
EmptyCutoff: number;
/**
* Creates a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object based on various agent parameters (see below).
*
* Agent parameters
* ----------------
*
* Key
*
* Type
*
* Default
*
* Description
*
* **AgentRadius**
*
* integer
*
* 2
*
* Determines the minimum amount of horizontal space required for empty space to be considered traversable.
*
* **AgentHeight**
*
* integer
*
* 5
*
* Determines the minimum amount of vertical space required for empty space to be considered traversable.
*
* **AgentCanJump**
*
* boolean
*
* true
*
* Determines whether off-mesh links for jumping are allowed.
*
* **WaypointSpacing**
*
* number
*
* 4
*
* Determines the spacing between intermediate waypoints in path.
*
* **Costs**
*
* table
*
* {}
*
* Table of materials or defined [PathfindingModifiers](https://developer.roblox.com/en-us/api-reference/class/PathfindingModifier) and their "cost" for traversal. Useful for making the agent prefer certain materials/regions over others.
*
* Pathfinding Costs
* -----------------
*
* By default, all walkable (navmesh) areas have a pathfinding cost of 1.0 (jumps have a cost of 4.0), which is exactly how pathfinding worked before the introduction of [PathfindingModifiers](https://developer.roblox.com/en-us/api-reference/class/PathfindingModifier).
*
* Since not all characters have the same movement abilities or constraints, it is desirable to provide a way to customize them. For example, a regular car always wants to avoid water, while an amphibian vehicle might not have such restriction.
*
* To assign different pathfinding costs to different named areas/volumes and/or materials, for a particular AI character (including the player character in the Click to Move mode), just add an optional parameter `Costs` of type dictionary to CreatePath(.). It maps Pathfinding Modifier areas/volumes and materials to their pathfinding costs. For example:
*
* local path = PathfindingService:CreatePath{
* AgentRadius = agentRadius,
* AgentHeight = agentHeight,
* AgentCanJump = agentCanJump,
*
* -- New parameter --
* Costs = {
* Grass = 10
* }
* }
*
* See the [Pathfinding](https://developer.roblox.com/en-us/articles/pathfinding) guide for details and examples on using pathfinding in Roblox.
*/
CreatePath(this: PathfindingService, agentParameters?: AgentParameters): Path;
/**
* This function computes and returns a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) between two [Vector3s](https://developer.roblox.com/en-us/api-reference/datatype/Vector3). If the given MaxDistance is greater than 512, an error will be thrown. (MaxDistance is too large).
*
* Tags: Yields
* @deprecated Use `FindPathAsync` instead
*/
ComputeRawPathAsync(this: PathfindingService, start: Vector3, finish: Vector3, maxDistance: number): Instance | undefined;
/**
* This function computes and returns a smooth [Path](https://developer.roblox.com/en-us/api-reference/class/Path) between two [Vector3s](https://developer.roblox.com/en-us/api-reference/datatype/Vector3). This function fulfills the same purpose as [PathfindingService:ComputeRawPathAsync](https://developer.roblox.com/en-us/api-reference/function/PathfindingService/ComputeRawPathAsync), but creates a much smoother path for an NPC to follow in comparison.
*
* Tags: Yields
* @deprecated Use `FindPathAsync` instead
*/
ComputeSmoothPathAsync(this: PathfindingService, start: Vector3, finish: Vector3, maxDistance: number): Instance | undefined;
/**
* This function is used to find a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) between two provided points. This path uses the navigation grid created by [PathfindingService](https://developer.roblox.com/en-us/api-reference/class/PathfindingService) and makes sure that the path can be followed by a regular-sized Roblox character.
*
* This function returns a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object which contains the coordinates of the path. If no path is found between the two points, this function will still return a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object, but that object's [Path.Status](https://developer.roblox.com/en-us/api-reference/property/Path/Status) will be `Enum.PathStatus.NoPath`.
*
* To get the waypoints of a [Path](https://developer.roblox.com/en-us/api-reference/class/Path) object, you can use the [Path:GetWaypoints](https://developer.roblox.com/en-us/api-reference/function/Path/GetWaypoints) function.
*
* Tags: Yields
*/
FindPathAsync(this: PathfindingService, start: Vector3, finish: Vector3): Path;
}
interface PausedState extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PausedState: unique symbol;
}
interface PausedStateBreakpoint extends PausedState {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PausedStateBreakpoint: unique symbol;
}
interface PausedStateException extends PausedState {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PausedStateException: unique symbol;
}
/** PhysicsService is a game service that has functions for working with **collision groups**, which define a set of parts that may or may not collide with parts assigned to other collision groups. Assign a part to a collision group using [SetPartCollisionGroup](https://developer.roblox.com/en-us/api-reference/function/PhysicsService/SetPartCollisionGroup). Collision groups and their relationships are saved to and loaded from file.
*
* Network Replication
* -------------------
*
* Creating, deleting and modifying collision relationships between collision groups is limited to server-side [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s. However, client-side [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s may only set individual parts' associated collision group.
*/
interface PhysicsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PhysicsService: unique symbol;
/**
* Returns whether the specified part is in the specified collision group.
*
* This function will throw a runtime error in the following circumstances:
*
* * The specified group does not exist.
* * The specified part is not a BasePart.
* @deprecated Use `CollisionGroup` instead
*/
CollisionGroupContainsPart(this: PhysicsService, name: string, part: BasePart): boolean;
/**
* Sets the collision status between two groups.
*
* This function will throw an error if either of the groups do not exist.
*/
CollisionGroupSetCollidable(this: PhysicsService, name1: string, name2: string, collidable: boolean): void;
/**
* Returns whether the two specified collision groups will collide.
*
* This function will throw an error if either of the groups do not exist.
*/
CollisionGroupsAreCollidable(this: PhysicsService, name1: string, name2: string): boolean;
/**
* Creates a new collision group with the given name, and returns the id of the created group.
* @deprecated Use `RegisterCollisionGroup` instead
*/
CreateCollisionGroup(this: PhysicsService, name: string): number;
/**
* The GetCollisionGroupId function returns the id of the collision group with the specified name.
*
* This function will throw an error if no group with the given name exists.
* @deprecated Use `CollisionGroup` instead
*/
GetCollisionGroupId(this: PhysicsService, name: string): number;
/**
* Returns the name of the collision group with the corresponding id. This function will return nil if the group with the corresponding id has not been named.
*
* This function will throw an error if the id is not in the range of 0 <= id < maxCollisionGroups
* @deprecated Use `CollisionGroup` instead
*/
GetCollisionGroupName(this: PhysicsService, name: number): string;
/**
* Returns a table with info on all of the place's collision groups. Each value in this table is itself a table and contains 3 members:
*
* Member
*
* Type
*
* Description
*
* **id**
*
* integer
*
* The ID of the group
*
* **mask**
*
* integer
*
* The mask of the group (for internal use)
*
* **name**
*
* string
*
* The name of the group
* @deprecated Use `GetRegisteredCollisionGroups` instead
*/
GetCollisionGroups(this: PhysicsService): Array;
/**
* Returns the maximum number of collision groups the engine supports. This value is currently 32.
*/
GetMaxCollisionGroups(this: PhysicsService): number;
GetRegisteredCollisionGroups(this: PhysicsService): Array;
IsCollisionGroupRegistered(this: PhysicsService, name: string): boolean;
RegisterCollisionGroup(this: PhysicsService, name: string): void;
/**
* Removes the collision group with the given name. If an invalid name is provided the function will not do anything, although if the reserved name “Default” is provided then the function will throw an error.
*
* If there are any parts in the collision group when it is removed, these parts will still maintain the same collision group id. The physical behavior of parts in a removed group is undefined, so it is recommended to move any parts in a removed group to another group (such as the Default group).
*
* This function will throw a runtime error in the following circumstances:
*
* * The name “Default” is provided.
* * The function is called from a client.
* @deprecated Use `UnregisterCollisionGroup` instead
*/
RemoveCollisionGroup(this: PhysicsService, name: string): void;
/**
* Renames the specified collision group. The first argument of this function is the name of the group to rename, the second argument is the new name for the group. If the specified group does not exist, then this function will not do anything.
*
* The naming conventions for the new name follow the same rules as if the group was being created with \`PhysicsService/CreateCollisionGroup\`. The new name cannot be “Default”, and it cannot contain the special characters “/” or “^”.
*
* This function will throw a runtime error in the following circumstances:
*
* * Invalid or empty name provided for either argument.
* * The function is called from a client.
*/
RenameCollisionGroup(this: PhysicsService, from: string, to: string): void;
/**
* The SetPartCollisionGroup function sets the collision group of the specified part to the group with the specified name.
*
* This function is equivalent to setting the [BasePart.CollisionGroupId](https://developer.roblox.com/en-us/api-reference/property/BasePart/CollisionGroupId), although this function is the recommended method of configuring a part's collision group.
*
* Note that for a part to respect its collision filter setting it must have its [BasePart.CanCollide](https://developer.roblox.com/en-us/api-reference/property/BasePart/CanCollide) property set to true.
*
* This function will throw a runtime error in the following circumstances:
*
* * The part parameter is not a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) instance.
* * The specified group does not exist.
* @deprecated Use `CollisionGroup` instead
*/
SetPartCollisionGroup(this: PhysicsService, part: BasePart, name: string): void;
UnregisterCollisionGroup(this: PhysicsService, name: string): void;
}
interface PlaceStatsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlaceStatsService: unique symbol;
}
interface PlacesService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlacesService: unique symbol;
}
interface PlatformFriendsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlatformFriendsService: unique symbol;
}
/** A Player object a client that is currently connected. These objects are added to the [Players](https://developer.roblox.com/en-us/api-reference/class/Players) service when a new player connects, then removed when they eventually disconnect from the server.
*
* The [Instance.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) property reflects the player's username. When saving information about a player, you should use their [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) since it is possible that a player can change their username.
*
* There are several similar methods in the [Players](https://developer.roblox.com/en-us/api-reference/class/Players) for working with Player objects. Use these over their respective [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance) methods:
*
* * You can get a table of current Player objects using [Players:GetPlayers](https://developer.roblox.com/en-us/api-reference/function/Players/GetPlayers); again, use this instead of [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren).
* * To detect the addition of Player objects, it is recommended to use the [Players.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded) event (instead of [Instance.ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded) on the [Players](https://developer.roblox.com/en-us/api-reference/class/Players) service).
* * Similarly, you can detect the removal of Player objects using [Players.PlayerRemoving](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerRemoving), which fires just **before** the Player is removed (instead of [Instance.ChildRemoved](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildRemoved) which fires after). This is important if you are saving information about the player that might be removed or cleaned up on-removal.
*/
interface Player extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Player: unique symbol;
readonly Name: string;
/**
* The AccountAge is a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property that describes how long ago a player's account was registered in days. It is set using the [Player:SetAccountAge](https://developer.roblox.com/en-us/api-reference/function/Player/SetAccountAge) function, which cannot be accessed by scripts.
*
* This property is useful for conditionally showing new Roblox players content such as tutorials.
*
* Tags: NotReplicated
*/
readonly AccountAge: number;
/**
* The AutoJumpEnabled property determines whether the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) of a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) using a mobile device will automatically jump when they hit an obstacle. This can make levels more navigable while on a mobile device.
*
* When the player joins the game, the [StarterPlayer.AutoJumpEnabled](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/AutoJumpEnabled) value determines the initial state of this property. Then, this property determines the value of the [Humanoid.AutoJumpEnabled](https://developer.roblox.com/en-us/api-reference/property/Humanoid/AutoJumpEnabled) property of the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character)s [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) on spawn. In other words, it is possible to set the auto-jump behavior on a per-character, per-player and per-game basis using these three properties.
*/
AutoJumpEnabled: boolean;
/**
* The CameraMaxZoomDistance [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets the maximum distance in studs the camera can be from the character with the default cameras.
*
* In other words, it controls the maximum distance the player's camera is allowed to zoom out.
*
* The default value of this property is set by [StarterPlayer.CameraMaxZoomDistance](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CameraMaxZoomDistance). If this value is set to a lower value than [Player.CameraMinZoomDistance](https://developer.roblox.com/en-us/api-reference/property/Player/CameraMinZoomDistance), it will be increased to CameraMinZoomDistance.
*/
CameraMaxZoomDistance: number;
/**
* The CameraMinZoonDistance [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets the minimum distance in studs the camera can be from the character with the default cameras.
*
* In other words, it controls the minimum distance the player's camera is allowed to zoom in.
*
* The default value of this property is set by [StarterPlayer.CameraMinZoomDistance](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/CameraMinZoomDistance). If this value is set to a higher value than [Player.CameraMaxZoomDistance](https://developer.roblox.com/en-us/api-reference/property/Player/CameraMaxZoomDistance) it will be decreased to CameraMaxZoomDistance.
*/
CameraMinZoomDistance: number;
/**
* The CameraMode [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets what mode that the player's camera is in. By default, the camera mode is set to third person.
*
* The camera has two modes:
*
* 1. First person
* 2. Third person
*
* The [CameraMode](https://developer.roblox.com/en-us/api-reference/enum/CameraMode) Enum is used to set CameraMode in Player, and determines when first and third person cameras should be used.
*
* First-person
* ------------
*
* In first-person mode, the player's camera is zoomed all the way in. Unless there is a visible GUI present with the [GuiButton.Modal](https://developer.roblox.com/en-us/api-reference/property/GuiButton/Modal) property set to _true_, the mouse will be locked and the user's camera will turn as the mouse moves.
* 
*
* Third-person
* ------------
*
* In third-person mode, the character can be seen in the camera. While in third-person mode on Roblox:
*
* * You may right-click and drag to rotate your camera, or use the arrow keys at the bottom right-hand corner of the screen.
* * When you move your mouse, your camera does not change (unless you move the mouse to the end of the screen).
* * When you press any of the arrow keys, the user's character will face in the corresponding arrow key's direction.
* * You can zoom in and out freely.
*
* Third-person is the default camera setting.
* 
*
* Note
* ----
*
* * This item should be used in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) to work as expected online.
*/
CameraMode: Enum.CameraMode;
/**
* The CanLoadCharacterAppearance [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property determines whether the character's appearance will be loaded when the player spawns. The default value of this property is set by `StarterPlayer/LoadPlayerAppearance`.
*
* If _true_, the character will load the appearance of the player corresponding to the player's [Player.CharacterAppearanceId](https://developer.roblox.com/en-us/api-reference/property/Player/CharacterAppearanceId).
*
* If _false_, the player will spawn with a default appearance - a grey character model without any hats, shirts, pants, etc.
*
* Attempting to set the property after the character has spawned will not change the character, you must call [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter) to load the new appearance.
*/
CanLoadCharacterAppearance: boolean;
/**
* The Character property contains a reference to a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) containing a [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid), body parts, scripts and other objects required for simulating the player's avatar in-game. The model is parented to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace), but may be moved. It is automatically loaded when [Players.CharacterAutoLoads](https://developer.roblox.com/en-us/api-reference/property/Players/CharacterAutoLoads) is true, but can be manually loaded otherwise using [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter).
*
* Initially, this property is nil then set when the player's character first spawns. Use the [Player.CharacterAdded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAdded) event to detect when a player's character properly loads, and the [Player.CharacterRemoving](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterRemoving) event to detect when the character is about to despawn. Avoid using [Instance:GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal) on this property.
*
* Notes
* -----
*
* LocalScripts that are cloned from [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) or [StarterPack](https://developer.roblox.com/en-us/api-reference/class/StarterPack) into a player's [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) or [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) are often run before the old Character model is deleted. Player.Character still refers to a model, but that model's parent is nil and it is has been destroyed. Because of this, if the Character already exists, you should check to make sure that the Character's parent is not nil before using it.
*
* So if you're writing a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) under the [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui) or [StarterPack](https://developer.roblox.com/en-us/api-reference/class/StarterPack) that requires access to the player's character, use this:
*
* local Players = game:GetService("Players")
* local player = Players.LocalPlayer
* local character = player.Character
* if not character or not character.Parent then
* character = player.CharacterAdded:wait()
* end
*/
Character: Model | undefined;
/**
* The CharacterAppearance property indicates the URL of the asset containing the character's appearance, clothing, and gear.
*
* It is automatically set by Roblox to load your avatar's appearance when you join a game.
*
* Attempting to set the property after the character has spawned will not change the character, you must call [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter) to load the new appearance.
*
* Tags: NotBrowsable
* @deprecated Use `CharacterAppearanceId` instead
*/
CharacterAppearance: string;
/**
* This property determines the user ID of the account whose character appearance is used for a player's `character. By default, this property is the` Player`'s` Player/UserId\`, which uses the player's avatar as they have created it on the Roblox website.
*
* Changing this property to the user ID of another account will cause the player to spawn with that account's appearance (hats, shirt, pants, etc).
*
* Games can also toggle whether or not a player's character appearance is loaded in game by changing the [StarterPlayer.LoadCharacterAppearance](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/LoadCharacterAppearance) property.
*/
CharacterAppearanceId: number;
/**
* This property was once used by an ancient data persistence method to indicate the total amount of data currently being stored in the [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) cache on the current place.
*
* Notes
* -----
*
* * Booleans and numbers cost 1 data complexity unit.
* * Strings cost their length divided by 100 in data complexity units.
* * Instances cost their DataCost in data complexity units.
* * Saving the default value (0 for numbers, false for booleans, “” for strings and nil for Instances) removes the key from the DataComplexity count.
* * If, when using the SaveBoolean, SaveString, SaveNumber or SaveInstance functions, the DataComplexity for the player goes over the limit (currently 45000 units, defined by DataComplexityLimit), the function throws an error, the value is not saved, and any previous value of the key that was being saved to is deleted.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly DataComplexity: number;
/**
* This property was once used by an ancient data persistence method to indicate when the player's data is available to load. Becomes true when data is available.
*
* Tags: Hidden, NotReplicated
* @deprecated
*/
readonly DataReady: boolean;
/**
* The DevCameraOcclusionMode [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets how the default camera handles objects between the camera and the player. Set by default by [StarterPlayer.DevCameraOcclusionMode](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/DevCameraOcclusionMode).
*
* The default value is _Zoom_ (0): The camera will zoom in until there is nothing between the player and camera.
*
* See [DevCameraOcclusionMode](https://developer.roblox.com/en-us/api-reference/enum/DevCameraOcclusionMode) for the different occlusion modes available. Sets how the default camera handles objects between the camera and the player.
*/
DevCameraOcclusionMode: Enum.DevCameraOcclusionMode;
/**
* The DevComputerCameraMode property determines the manner in which a player moves their camera when using a mouse-and-keyboard device device. See [DevComputerCameraMovementMode](https://developer.roblox.com/en-us/api-reference/enum/DevComputerCameraMovementMode) for a description of each camera control mode available. This property cannot be set using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) (it must be set on the server using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* The default value of this property is determined by [StarterPlayer.DevComputerCameraMovementMode](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/DevComputerCameraMovementMode).
*
* Note
* ----
*
* * The word “Computer” in this property name refers to non-[TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled), non-[GamepadEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/GamepadEnabled) devices.
* * When set to **UserChoice**, a player can choose between any control mode (except **Scriptable**) in the Roblox game settings. In general, it is a good idea to allow players to choose their control mode to maximize accessibility.
* * It is possible to create a custom control scheme by setting this property to **Scriptable**.
* * This property does not affect players using a touch enabled device. See [Player.DevTouchCameraMode](https://developer.roblox.com/en-us/api-reference/property/Player/DevTouchCameraMode) instead.
*/
DevComputerCameraMode: Enum.DevComputerCameraMovementMode;
/**
* The DevComputerMovementMode property determines the manner in which a player moves their character when using a mouse-and-keyboard device device. See [DevComputerMovementMode](https://developer.roblox.com/en-us/api-reference/enum/DevComputerMovementMode) for a description of each movement control mode available. This property cannot be set using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) (it must be set on the server using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* The default value of this property is determined by [StarterPlayer.DevComputerMovementMode](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/DevComputerMovementMode).
*
* Note
* ----
*
* * The word “Computer” in this property name refers to non-[TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) devices.
* * When set to **UserChoice**, a player can choose between any control mode (except **Scriptable**) in the Roblox game settings. In general, it is a good idea to allow players to choose their control mode to maximize accessibility.
* * It is possible to create a custom control scheme by setting this property to **Scriptable**.
* * This property does not affect players using a touch enabled device. See [Player.DevTouchMovementMode](https://developer.roblox.com/en-us/api-reference/property/Player/DevTouchMovementMode) instead.
*/
DevComputerMovementMode: Enum.DevComputerMovementMode;
/**
* This property determines if a player is able to toggle **[mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) lock** by pressing **Shift**. A player can disable the mouse lock switch in Roblox's game settings. By default, this property is set to the value of [StarterPlayer.EnableMouseLockOption](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/EnableMouseLockOption). This can be set server-side during run-time by using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script). It can not be set client-side.
*
* What is Mouse Lock?
* -------------------
*
* When mouse lock is enabled, the player's cursor is locked to the center of the screen. Moving the mouse will orbit the camera around the player's [character](https://developer.roblox.com/en-us/api-reference/property/Player/Character), and character will face the same direction as the [camera](https://developer.roblox.com/en-us/api-reference/class/Camera). It also offsets the camera view just over the right shoulder of the player's character.
*
* Below, the camera is moved left and right first by holding right-click. Then, mouse lock is enabled which changes the mouse to a target reticule, and offsets the camera. The camera is again moved left and right (without holding right click).
*/
DevEnableMouseLock: boolean;
/**
* The DevTouchCameraMode property determines the manner in which a player moves their camera when using a [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) device. See [DevTouchCameraMovementMode](https://developer.roblox.com/en-us/api-reference/enum/DevTouchCameraMovementMode) for a description of each camera control mode available. This property cannot be set using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) (it must be set on the server using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* The default value of this property is determined by [StarterPlayer.DevTouchCameraMovementMode](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/DevTouchCameraMovementMode).
*
* Note
* ----
*
* * When set to **UserChoice**, a player can choose between any control mode (except **Scriptable**) in the Roblox game settings. In general, it is a good idea to allow players to choose their control mode to maximize accessibility.
* * It is possible to create a custom control scheme by setting this property to **Scriptable**.
* * This property does not affect players who are not using a touch enabled device. See `Player/DevComputerCameraMovementMode` instead.
*/
DevTouchCameraMode: Enum.DevTouchCameraMovementMode;
/**
* The DevTouchMovementMode property determines the manner in which a player moves their character when using a [TouchEnabled](https://developer.roblox.com/en-us/api-reference/property/UserInputService/TouchEnabled) device. See [DevTouchMovementMode](https://developer.roblox.com/en-us/api-reference/enum/DevTouchMovementMode) for a description of each movement control mode available. This property cannot be set using a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) (it must be set on the server using a [Script](https://developer.roblox.com/en-us/api-reference/class/Script)).
*
* The default value of this property is determined by [StarterPlayer.DevTouchMovementMode](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/DevTouchMovementMode).
*
* Note
* ----
*
* * When set to **UserChoice**, a player can choose between any control mode (except **Scriptable**) in the Roblox game settings. In general, it is a good idea to allow players to choose their control mode to maximize accessibility.
* * It is possible to create a custom control scheme by setting this property to **Scriptable**.
* * This property does not affect players who are not using a touch enabled device. See [Player.DevComputerMovementMode](https://developer.roblox.com/en-us/api-reference/property/Player/DevComputerMovementMode) instead.
*/
DevTouchMovementMode: Enum.DevTouchMovementMode;
/**
* The `DisplayName` is a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property that contains the display name of the authenticated user associated with the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) object. Unlike usernames, display names are non-unique names a player displays to others. If the Roblox user has not chosen one, the property will read the same as the `Name` property.
*
* Notes
* -----
*
* * Since display names are non-unique, it's possible for two players in a single instance to have identical names. If you need a globally unique identifier for a player, use `Player.UserId` (which is static) or `Player.Name` (which is the current Username) instead.
* * Characters generated with `LoadCharacter` or by the Roblox engine will have their Humanoid's `DisplayName` property assigned to the Player's `DisplayName` property.
* * Display names may have unicode characters in the string. See [UTF8](https://developer.roblox.com/api-reference/lua-docs/utf8) for more information on how to work with strings with unicode characters.
*/
DisplayName: string;
/**
* The FollowUserId is a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property that contains the [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) of the user that a player followed into the game. If the player did not follow anyone into the game, this property will be 0. This property is useful for alerting players who have been followed by another player into the game.
*
* You can get the name of the player followed using this user ID and the [Players:GetNameFromUserIdAsync](https://developer.roblox.com/en-us/api-reference/function/Players/GetNameFromUserIdAsync) function.
*
* Tags: NotReplicated
*/
readonly FollowUserId: number;
/**
* The **GameplayPaused** property indicates if the player is currently in a pause state in a place with [StreamingEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingEnabled) activated. It is set on the client but replicated to the server.
*
* To determine the pause status, you can utilize this property as outlined [here](https://developer.roblox.com/en-us/articles/content-streaming#customizing-pause-screen).
*
* See Also
* --------
*
* * [Workspace.StreamingEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingEnabled) which controls whether content streaming is enabled
* * [Workspace.StreamingPauseMode](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingPauseMode) which controls the streaming physics pause mode
*/
readonly GameplayPaused: boolean;
HasVerifiedBadge: boolean;
/**
* The HealthDisplayDistance [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets the distance in studs at which this player will see other [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)'s health bars. If set to 0, the health bars will not be displayed. This property is set to [StarterPlayer.HealthDisplayDistance](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/HealthDisplayDistance) by default.
*
* Note
* ----
*
* If a Humanoid's health bar is visible, you can set the display type using [Humanoid.DisplayDistanceType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/DisplayDistanceType).
*/
HealthDisplayDistance: number;
/**
* The LocaleId [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property shows the locale id that the local player has set for their Roblox account. It holds a string with the two letter code (for example, “en-us”) for the locale.
*
* This can be used to determine the geographic demographic of your game's player base.
*
* This property allows access to the player's locale from the server. It is similar to [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService)'s [LocalizationService.RobloxLocaleId](https://developer.roblox.com/en-us/api-reference/property/LocalizationService/RobloxLocaleId) property.
*
* Tags: Hidden, NotReplicated
*/
readonly LocaleId: string;
/**
* The MembershipType [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property can be used to determine the membership type of the player. It holds a [MembershipType](https://developer.roblox.com/en-us/api-reference/enum/MembershipType) enum of the account's membership type.
*
* This property can only be read from to determine membership (it cannot be set to another membership type). The property can only be changed via [CoreScript](https://developer.roblox.com/en-us/api-reference/class/CoreScript)s using [Player:SetMembershipType](https://developer.roblox.com/en-us/api-reference/function/Player/SetMembershipType) - which are not accessible.
*
* Tags: NotReplicated
*/
readonly MembershipType: Enum.MembershipType;
/**
* The NameDisplayDistance [StarterPlayer](https://developer.roblox.com/en-us/api-reference/class/StarterPlayer) property sets the distance in studs at which this player will see other [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)'s names. If the property is set to 0, names are hidden. This property is set to [StarterPlayer.NameDisplayDistance](https://developer.roblox.com/en-us/api-reference/property/StarterPlayer/NameDisplayDistance) by default.
*
* Note
* ----
*
* If a Humanoid's health bar is visible, you can set the display type using [Humanoid.DisplayDistanceType](https://developer.roblox.com/en-us/api-reference/property/Humanoid/DisplayDistanceType).
*/
NameDisplayDistance: number;
/**
* The Neutral property determines whether the player is on a specific team.
*
* * When _true_, the player is not on a specific team. This also means that the [Player.Team](https://developer.roblox.com/en-us/api-reference/property/Player/Team) property will be nil and the [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) will be white.
* * When _false_, the player is on a specific team. The [Player.Team](https://developer.roblox.com/en-us/api-reference/property/Player/Team) property will correspond to the [Team](https://developer.roblox.com/en-us/api-reference/class/Team) that the player is on, as will the [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor).
*/
Neutral: boolean;
/**
* The ReplicationFocus [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property sets the part to focus replication around a Player. Different Roblox systems that communicate over the network (such as physics, streaming, etc) replicate at different rates depending on how close objects are to the replication focus.
*
* When this property is nil, it reverts to its default behavior which is to treat the local player's character's [PrimaryPart](https://developer.roblox.com/en-us/api-reference/property/Model/PrimaryPart) as the replication focus.
*
* This property should only be set on the server with a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), not a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript). Note that this property does not change or update network ownership of parts.
*/
ReplicationFocus: BasePart | undefined;
/**
* If set, the player will respawn at the given [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation). This property can only be set through Lua and must contain a reference to a valid [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation), which must meet the following criteria:
*
* * Descendant of [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace)
* * [SpawnLocation.TeamColor](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/TeamColor) is set to the [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor) or [SpawnLocation.Neutral](https://developer.roblox.com/en-us/api-reference/property/SpawnLocation/Neutral) is set to true
*
* If RespawnLocation is not set to a valid [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) then the default spawning logic will apply. For more information on this see the page for [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation).
*
* Alternatives to RespawnLocation
* -------------------------------
*
* * A [Player](https://developer.roblox.com/en-us/api-reference/class/Player) will spawn from [SpawnLocations](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation) belonging to their team. In some cases it may be simpler to change the [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) [Player.Team](https://developer.roblox.com/en-us/api-reference/property/Player/Team) instead. This method also allows the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) to respawn from multiple [SpawnLocations](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation).
* * Developers may wish to implement their own custom spawn logic, using [Model:SetPrimaryPartCFrame](https://developer.roblox.com/en-us/api-reference/function/Model/SetPrimaryPartCFrame) to move the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) manually.
*/
RespawnLocation: SpawnLocation | undefined;
/**
* The Team property is a reference to a [Team](https://developer.roblox.com/en-us/api-reference/class/Team) object within the [Teams](https://developer.roblox.com/en-us/api-reference/class/Teams) service. It determines the team the player is on; if the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) isn't on a team or has an invalid [Player.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Player/TeamColor), this property is nil. When this property is set, the player has joined the [Team](https://developer.roblox.com/en-us/api-reference/class/Team) and the [Team.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Team/PlayerAdded) event fires on the associated team. Similarly, [Team.PlayerRemoved](https://developer.roblox.com/en-us/api-reference/event/Team/PlayerRemoved) fires when the property is unset from a certain [Team](https://developer.roblox.com/en-us/api-reference/class/Team).
*
* Tags: NotReplicated
*/
Team: Team | undefined;
/**
* The TeamColor property determines which team a Player is associated with according to that Team's [Team.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Team/TeamColor). Changing this property will change [Player.Team](https://developer.roblox.com/en-us/api-reference/property/Player/Team) according to whichever team has the same [BrickColor](https://developer.roblox.com/en-us/api-reference/datatype/BrickColor) for their [Team.TeamColor](https://developer.roblox.com/en-us/api-reference/property/Team/TeamColor). If no Team object has the associated TeamColor, the player will not be associated with a team.
*
* It's often a better idea to set [Player.Team](https://developer.roblox.com/en-us/api-reference/property/Player/Team) to the respective [Team](https://developer.roblox.com/en-us/api-reference/class/Team) instead of using this property. Setting this property often leads to repetition of the same BrickColor value for a certain teams across many scripts; this is something you want to avoid when adhering to the [don't-repeat-yourself](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself) principle.
*/
TeamColor: BrickColor;
/**
* The UserId is a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) property that contains a read-only integer that **uniquely and consistently** identifies every user account on Roblox. Unlike the [Instance.Name](https://developer.roblox.com/en-us/api-reference/property/Instance/Name) of a Player, which may change according the user's present username, this value will never change for the same account.
*
* This property is essential when saving/loading player data using [GlobalDataStores](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore). Use a player's UserId as the data store key so that each player has a unique key.
*/
readonly UserId: number;
/**
* The ClearCharacterAppearance function removes all [Accessory](https://developer.roblox.com/en-us/api-reference/class/Accessory), [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt), [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants), [CharacterMesh](https://developer.roblox.com/en-us/api-reference/class/CharacterMesh), and [BodyColors](https://developer.roblox.com/en-us/api-reference/class/BodyColors) from the given player's [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character). In addition, it also removes the T-Shirt [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal) on the player's torso. The character's body part colors and face will remain unchanged. This method does nothing if the player does not have a Character.
*
* Note
* ----
*
* It does not remove [t-shirts](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic), head meshes, or faces.
*/
ClearCharacterAppearance(this: Player): void;
/**
* The DistanceFromCharacter [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function returns the distance between the character's head and the given [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) point. It returns 0 if the player has no [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character).
*
* This is useful when determining the distance between a player and another object or location in game.
*
* Note
* ----
*
* If you would like to determine the distance between two non-player instances or positions, you can use the following:
*
* local distance = (position1 - position2).magnitude
*/
DistanceFromCharacter(this: Player, point: Vector3): number;
/**
* This function returns a dictionary containing information on how the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) joined the game.
*
* The dictionary contains the fields below. Please note, whether these fields exists depends on the circumstances under which the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) joined the game.
*
* Key
*
* Value Type
*
* Description
*
* SourceGameId
*
* int64
*
* The [DataModel.GameId](https://developer.roblox.com/en-us/api-reference/property/DataModel/GameId) of the game the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) was teleported from.
*
* SourcePlaceId
*
* int64
*
* The [DataModel.PlaceId](https://developer.roblox.com/en-us/api-reference/property/DataModel/PlaceId) of the place the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) was teleported from. Only present if the player was teleported to the current place.
*
* Members
*
* array
*
* An array containing the [UserIds](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) teleported alongside the [Player](https://developer.roblox.com/en-us/api-reference/class/Player). Only present if the player was teleported in using [TeleportService:TeleportPartyAsync](https://developer.roblox.com/en-us/api-reference/function/TeleportService/TeleportPartyAsync).
*
* TeleportData
*
* variant
*
* Reflects the _teleportData_ parameter specified in the original teleport function. This is useful in order to share information when teleporting a player from one place to another. It is only present if _teleportData_ was specified and the teleport function was called from the server.
*
* GetJoinData and TeleportData
* ----------------------------
*
* If the teleport the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) arrived in the current place due to was initiated on a server (as opposed to a client) the [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) _teleportData_ is included in the dictionary returned by this function.
*
* This function can only be used to fetch _teleportData_ on the server, to retrieve it on the client use [TeleportService:GetLocalPlayerTeleportData](https://developer.roblox.com/en-us/api-reference/function/TeleportService/GetLocalPlayerTeleportData).
*
* In contrast to [TeleportService:GetLocalPlayerTeleportData](https://developer.roblox.com/en-us/api-reference/function/TeleportService/GetLocalPlayerTeleportData), this function provides a number of security checks to the _teleportData_:
*
* * It is guaranteed to have been sent by a Roblox server in the last 48 hours
* * It is guaranteed to have been sent with this [Player](https://developer.roblox.com/en-us/api-reference/class/Player)
* * The SourcePlaceId returned is guaranteed to be the place the data was sent from. This means you can verify the TeleportData came from an approved place
*
* However, as this data is transmitted by the client, it not 100% secure. Although the user cannot modify this data it is possible for them to view it or insert data from a previous teleport.
*
* Despite this, it is still appropriate for the secure transmission of [immutable data](https://en.wikipedia.org/wiki/Immutable_object) (data that can not be changed). For example, if the user has completed a level that cannot be uncompleted. Such data can be securely transmitted using this function avoiding the need to use up and wait for [DataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) requests when teleporting.
*
* You should not use this function for data that can be changed. For example, the amount of in-game currency the user currently has. This is because GetJoinData cannot guarantee a malicious user is not transmitting data from a previous session. For data like this, you should rely on [GlobalDataStores](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore).
*
* As with all cases, you should implement proper server validation to ensure your game is secure. For more information see this article on [Game Security](https://developer.roblox.com/en-us/articles/game-security).
*/
GetJoinData(this: Player): PlayerJoinInfo;
/**
* The GetMouse [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function returns the [Mouse](https://developer.roblox.com/en-us/api-reference/class/Mouse) being used by the client. The player's mouse instance can be used to track user mouse input including left and right mouse button clicks and movement and location.
*
* The [UserInputService](https://developer.roblox.com/en-us/api-reference/class/UserInputService) service provides additional functions and events to track user input - especially for devices that do not use a mouse.
*
* Notes
* -----
*
* * This item **must** be used in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) to work as expected online.
* * Following an update in July 2014, the mouse's icon can now be set with this method.
*/
GetMouse(this: Player): PlayerMouse;
/**
* **GetNetworkPing** returns the engine-calculated latency of the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) in seconds. “Ping” is a measurement of the time taken for data to be sent from the client to the server, then back again. For client-side [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s, this function may only be called on the [LocalPlayer](https://developer.roblox.com/en-us/api-reference/property/Players/LocalPlayer). This function is useful in identifying and debugging issues that occur in high-latency scenarios. It can also be used in masking latency, such as adjusting the speed of throwing animations for projectiles.
*/
GetNetworkPing(this: Player): number;
/**
* The HasAppearanceLoaded [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function returns whether or not the appearance of the player's [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) has loaded.
*
* A player's appearance includes items such as the player's [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt), [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants), and [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory).
*
* This is useful when determining whether a player's appearance has loaded after they first join the game, which can be tracked using the [Players.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded) event.
*/
HasAppearanceLoaded(this: Player): boolean;
IsVerified(this: Player): boolean;
/**
* The Kick [Player](https://developer.roblox.com/en-us/api-reference/class/Player) method allows a game to gracefully disconnect a client from the game and optionally provide a message to the disconnected player. This is useful for moderating abusive players. When used in conjunction with a [DataStore](https://developer.roblox.com/en-us/api-reference/class/DataStore), it is possible to create ban lists with expiration dates. Only allow specific whitelisted users whom you trust to trigger this method on other players.
*
* When used from a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), only the local player's client can be kicked.
*
* ##Example
* When calling this method on a Player with no arguments, they will be disconnected from the server and receive the default message: This game has shut down.
*
* 
*
* Calling this method on a player but providing a string as the first argument will replace this message with the contents of the string.
*
* 
*/
Kick(this: Player, message?: string): void;
/**
* This function returns a boolean value that was previously saved to the player with [Player:SaveBoolean](https://developer.roblox.com/en-us/api-reference/function/Player/SaveBoolean) with the same key. Returns false if the key doesn't exist, not nil.
* @deprecated
*/
LoadBoolean(this: Player, key: string): boolean;
/**
* The LoadCharacterAppearance [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function places the given instance either in the player's [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character), head, or [StarterGear](https://developer.roblox.com/en-us/api-reference/class/StarterGear) based on the instance's class.
*
* This is useful when giving a player's character an asset from the Roblox catalog, such as a hat or piece of gear.
*
* It is similar to [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter), except it does not reload the entire character instance, StarterGear, or [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui).
*
* Notes
* -----
*
* * [Accessories](https://developer.roblox.com/en-us/api-reference/class/Accessory), [Shirt](https://developer.roblox.com/en-us/api-reference/class/Shirt)s, [ShirtGraphic](https://developer.roblox.com/en-us/api-reference/class/ShirtGraphic)s, [CharacterMesh](https://developer.roblox.com/en-us/api-reference/class/CharacterMesh)es, `BodyColor`s, and [Accoutrement](https://developer.roblox.com/en-us/api-reference/class/Accoutrement)s are parented to the player's character.
* * [Decal](https://developer.roblox.com/en-us/api-reference/class/Decal)s, [FileMesh](https://developer.roblox.com/en-us/api-reference/class/FileMesh)es, [SpecialMesh](https://developer.roblox.com/en-us/api-reference/class/SpecialMesh)es, [BlockMesh](https://developer.roblox.com/en-us/api-reference/class/BlockMesh)es, [CylinderMesh](https://developer.roblox.com/en-us/api-reference/class/CylinderMesh)es, and [Texture](https://developer.roblox.com/en-us/api-reference/class/Texture)s are parented to the character's head.
* * [Tool](https://developer.roblox.com/en-us/api-reference/class/Tool)s and [HopperBin](https://developer.roblox.com/en-us/api-reference/class/HopperBin)s are parented to the player's StarterGear.
* * All other classes are ignored.
* @deprecated
*/
LoadCharacterAppearance(this: Player, assetInstance: Instance): void;
/**
* This function returns an instance that was previously saved to the player with [Player:SaveInstance](https://developer.roblox.com/en-us/api-reference/function/Player/SaveInstance) with the same key. Returns nil if the key doesn't exist.
* @deprecated
*/
LoadInstance(this: Player, key: string): Instance | undefined;
/**
* This function was once used by an ancient data persistence method to return a number value that was previously saved to the player with [Player:SaveNumber](https://developer.roblox.com/en-us/api-reference/function/Player/SaveNumber) with the same key. Returns 0 if the key doesn't exist, not nil.
* @deprecated
*/
LoadNumber(this: Player, key: string): number;
/**
* This function returns a string value that was previously saved to the player with [Player:SaveString](https://developer.roblox.com/en-us/api-reference/function/Player/SaveString) with the same key. Returns an empty string (“”) if the key doesn't exist, not nil…
* @deprecated
*/
LoadString(this: Player, key: string): string;
/**
* The Move [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function causes the player's character to walk in the given direction until stopped, or interrupted by the player (by using their controls).
*
* This is useful when scripting NPC [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid)s that move around a map - but are not controlled by an actual player's input.
*
* Note that the function's second argument indicates whether the provided [Vector3](https://developer.roblox.com/en-us/api-reference/datatype/Vector3) should move the player relative to world coordinates (_false_) or the player's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) (_true_).
*/
Move(this: Player, walkDirection: Vector3, relativeToCamera?: boolean): void;
/**
* This function is used to save a boolean value that can be loaded again at a later time using [Player:LoadBoolean](https://developer.roblox.com/en-us/api-reference/function/Player/LoadBoolean).
* @deprecated
*/
SaveBoolean(this: Player, key: string, value: boolean): void;
/**
* This function was once used by an ancient data persistence method to save an instance which can be loaded again at a later time using [Player:LoadInstance](https://developer.roblox.com/en-us/api-reference/function/Player/LoadInstance)…
* @deprecated
*/
SaveInstance(this: Player, key: string, value: Instance): void;
/**
* This function was once used by an ancient data persistence method to save a number value that can be loaded again at a later time using [Player:LoadNumber](https://developer.roblox.com/en-us/api-reference/function/Player/LoadNumber).
* @deprecated
*/
SaveNumber(this: Player, key: string, value: number): void;
/**
* This function was once used by an ancient data persistence method to save a string value that can be loaded again at a later time using [Player:LoadString](https://developer.roblox.com/en-us/api-reference/function/Player/LoadString).
* @deprecated
*/
SaveString(this: Player, key: string, value: string): void;
/**
* This function returns a dictionary array of online friends, limited by the `maxFriends` value.
*
* In the returned array, some fields are only present for certain location types. For example, **PlaceId** won't be present when **LocationType** is 0 (Mobile Website).
*
* Name
*
* Type
*
* Description
*
* **VisitorId**
*
* number
*
* The [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) of the friend.
*
* **UserName**
*
* string
*
* The username of the friend.
*
* **DisplayName**
*
* string
*
* The [display name](https://developer.roblox.com/en-us/api-reference/property/Player/DisplayName) of the friend.
*
* **LastOnline**
*
* string
*
* When the friend was last online.
*
* **IsOnline**
*
* boolean
*
* If the friend is currently online.
*
* **LastLocation**
*
* string
*
* The name of the friend's current location.
*
* **PlaceId**
*
* number
*
* The place ID of the friend's last location.
*
* **GameId**
*
* string
*
* The [DataModel.JobId](https://developer.roblox.com/en-us/api-reference/property/DataModel/JobId) of the friend's last location.
*
* **LocationType**
*
* number
*
* The location type of the friend's last location:
*
* **0**
*
* Mobile Website
*
* **1**
*
* Mobile InGame
*
* **2**
*
* Webpage
*
* **3**
*
* Studio
*
* **4**
*
* InGame
*
* **5**
*
* Xbox
*
* **6**
*
* Team Create
*
* Tags: Yields
*/
GetFriendsOnline(this: Player, maxFriends?: number): Array;
/**
* The GetRankInGroup [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function returns the player's rank in the group as an integer between 0 and 255, where 0 is a non-member and 255 is the group's owner.
*
* Note
* ----
*
* Using this in a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), as opposed to a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), will not get you the most up-to-date information. If a player leaves a group while they are in the game, GetRankInGroup will still think they're in that group until they leave. However, this does not happen when used with a LocalScript.
*
* This is because the method caches results, so multiple calls of GetRankInGroup on the same player with the same group ID will yield the same result as when the method was first called with the given group ID. The caching behavior is on a per-peer basis: a server does not share the same cache as a client.
*
* Tags: Yields
*/
GetRankInGroup(this: Player, groupId: number): number;
/**
* The GetRoleInGroup [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function returns the player's role in the group as a string, or _Guest_ if the player isn't part of the group.
*
* Note
* ----
*
* Using this in a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), as opposed to a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), will not get you the most up-to-date information. If a player leaves a group while they are in the game, GetRoleInGroup will still think they're in that group until they leave. However, this does not happen when used with a LocalScript.
*
* This is because the method caches results, so multiple calls of GetRoleInGroup on the same player with the same group ID will yield the same result as when the method was first called with the given group ID. The caching behavior is on a per-peer basis: a server does not share the same cache as a client.
*
* Tags: Yields
*/
GetRoleInGroup(this: Player, groupId: number): string;
/**
* This function was once used to return whether a player is best friends with the specified user, but the best friend feature has since been removed.
*
* Tags: Yields
* @deprecated
*/
IsBestFriendsWith(this: Player, userId: number): boolean;
/**
* This function sends a request to the Roblox website asking whether a player is a friend of another user, given the [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) of that user. This function caches results so multiple calls of the function on the same player with the same `userId` may not yield the most up-to-date result. This does not happen when used in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript).
*
* Tags: Yields
*/
IsFriendsWith(this: Player, userId: number): boolean;
/**
* The IsInGroup [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function sends a request to the Roblox website asking whether a player is a member of a group, given the ID of that group.
*
* Note
* ----
*
* Using this in a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), as opposed to a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), will not get you the most up-to-date information. If a player leaves a group while they are in the game, IsInGroup will still think they're in that group until they leave. However, this does not happen when used with a LocalScript.
*
* This is because the method caches results, so multiple calls of IsInGroup on the same player with the same group ID will yield the same result as when the method was first called with the given group ID. The caching behavior is on a per-peer basis: a server does not share the same cache as a client.
*
* Tags: Yields
*/
IsInGroup(this: Player, groupId: number): boolean;
/**
* The LoadCharacter [Player](https://developer.roblox.com/en-us/api-reference/class/Player) function creates a new character for the player, removing the old one. It also clears the player's [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) and [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui).
*
* This is useful in cases where you want to reload the character without killing the player, such as when you want to load a new character appearance after changing the player's [Player.CharacterAppearance](https://developer.roblox.com/en-us/api-reference/property/Player/CharacterAppearance).
*
* Notes
* -----
*
* The function is similar to [Player:LoadCharacterBlocking](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacterBlocking), but the request is processed asynchronously instead of synchronously. This means other tasks will be able to continue while the character is being loaded, including the rendering of the game and any other tasks. Also, this function can be used in script, while LoadCharacterBlocking cannot.
*
* After calling LoadCharacter for an individual player, it is not recommended to call it again for the same player until after that player's [Player.CharacterAppearanceLoaded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAppearanceLoaded) event has fired.
*
* Character Loading Event order
* -----------------------------
*
* Calling the `Player:LoadCharacter()` with an R15 Avatar fires events in the following order (Note: R6 ordering is different):
*
* 1. Player.Character sets
* 2. Player.CharacterAdded fires
* 3. Player.Changed fires with a value of “Character”
* 4. Character appearance initializes
* 5. Player.CharacterAppearanceLoaded fires
* 6. Character.Parent sets to the DataModel
* 7. The Character rig builds, and the Character scales
* 8. Character moves to the spawn location
* 9. LoadCharacter returns
*
* Tags: Yields
*/
LoadCharacter(this: Player): void;
/**
* This function spawns an avatar so it has everything equipped in the passed in [HumanoidDescription](https://developer.roblox.com/en-us/api-reference/class/HumanoidDescription).
*
* After calling LoadCharacterWithHumanoidDescription for an individual player, it is not recommended to call the function again for the same player until after that player's [Player.CharacterAppearanceLoaded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAppearanceLoaded) event has fired.
*
* See also
* --------
*
* * [Humanoid Description System](https://developer.roblox.com/en-us/articles/humanoiddescription-system), an article which explains the humanoid description system in greater detail and provides several scripting examples
*
* Tags: Yields
*/
LoadCharacterWithHumanoidDescription(this: Player, humanoidDescription: HumanoidDescription): void;
/**
* For games where [StreamingEnabled](https://developer.roblox.com/en-us/api-reference/property/Workspace/StreamingEnabled) is set to **true**, requests that the server stream to the player regions (parts and terrain) around the specified **X**, **Y**, **Z** location in the game world. It is useful if the game knows that the player's [CFrame](https://developer.roblox.com/en-us/api-reference/datatype/CFrame) will be set to the specified location in the near future. Without providing the location with this call, the player may not have streamed in content for the destination, resulting in a streaming pause or other undesirable behavior.
*
* The effect of this call will be temporary and there are no guarantees of what will be streamed in around the specified location. Client memory limits and network conditions may impact what will be available on the client.
*
* ##### Usage Precaution
*
* Requesting streaming around an area is **not a guarantee** that the content will be present when the request completes, as streaming is affected by the client's network bandwidth, memory limitations, and other factors.
*
* For more details, see the [Game Content Streaming](https://developer.roblox.com/en-us/articles/content-streaming) article.
*
* Tags: Yields
*/
RequestStreamAroundAsync(this: Player, position: Vector3, timeOut?: number): void;
/**
* This function is used to pause the script until the player's data is available to manipulate, or until a certain amount of time has elapsed without fetching the player's data
*
* Tags: Yields
* @deprecated
*/
WaitForDataReady(this: Player): boolean;
/**
* The **CharacterAdded** event fires when a player's character spawns (or respawns). This event fires soon after setting [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) to a non-`nil` value or calling [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter), which is before the character is parented to the [Workspace](https://developer.roblox.com/en-us/api-reference/class/Workspace).
*
* This can be used alongside the [Player.CharacterRemoving](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterRemoving) event, which fires right before a player's character is about to be removed, typically after death. As such, both of these events can potentially fire many times as players die then respawn in a place. If you want to detect when a player joins or leaves the game, use the [Players.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded) and [Players.PlayerRemoving](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerRemoving) events instead.
*
* Note that the [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) and its default body parts (head, torso, and limbs) will exist when this event fires, but clothing items like [Hats](https://developer.roblox.com/en-us/api-reference/class/Hat) and [Shirts](https://developer.roblox.com/en-us/api-reference/class/Shirt), and [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants) may take a few seconds to be added to the character. Connect [Instance.ChildAdded](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildAdded) on the added character to detect these, or wait for the [Player.CharacterAppearanceLoaded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAppearanceLoaded) event to be sure the character has everything equipped.
*/
readonly CharacterAdded: RBXScriptSignal<(character: Model) => void>;
/**
* This event fires when the the full appearance of a [Player](https://developer.roblox.com/en-us/api-reference/class/Player)'s [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) has been inserted.
*
* [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character)'s generally have a range of objects modifying their appearance including [Accoutrements](https://developer.roblox.com/en-us/api-reference/class/Accoutrement), [Shirts](https://developer.roblox.com/en-us/api-reference/class/Shirt), [Pants](https://developer.roblox.com/en-us/api-reference/class/Pants) and [CharacterMeshes](https://developer.roblox.com/en-us/api-reference/class/CharacterMesh). This event will fire when all such objects have been inserted into the [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character).
*
* One use for this event, is to remove and save aspects of a [Characters](https://developer.roblox.com/en-us/api-reference/property/Player/Character) appearance to be used later. See below for an example of this.
*/
readonly CharacterAppearanceLoaded: RBXScriptSignal<(character: Model) => void>;
/**
* The CharacterRemoving event fires right before a player's character is removed, such as when the player is respawning.
*
* This event can be used alongside the [Player.CharacterAdded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAdded) event, which fires when a player's character spawns or respawns. For instance, if you would like print a message every time a player spawns and dies:
*
* local Players = game:GetService("Players")
*
* local function onCharacterSpawned(player)
* print(player.Name .. " is spawning")
* end
*
* local function onCharacterDespawned(player)
* print(player.Name .. " is despawning")
* end
*
* local function onPlayerAdded(player)
* player.CharacterAdded:Connect(function ()
* onCharacterDespawned(player)
* end)
* player.CharacterRemoving:Connect(function ()
* onCharacterDespawned(player)
* end)
* end
*
* Players.PlayerAdded:Connect(onPlayerAdded)
*
* This event is only concerned with the [Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) of a [Player](https://developer.roblox.com/en-us/api-reference/class/Player). If you instead need to track when a player joins/leaves the game, use the events [Players.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded) and [Players.PlayerRemoving](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerRemoving).
*/
readonly CharacterRemoving: RBXScriptSignal<(character: Model) => void>;
/**
* The Chatted event fires when a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) types a message and presses enter in Roblox's provided chat bar. This is done using some Lua bindings by the default chat script. You can prevent players from chatting by using [StarterGui:SetCoreGuiEnabled](https://developer.roblox.com/en-us/api-reference/function/StarterGui/SetCoreGuiEnabled) and disabling the Chat [CoreGuiType](https://developer.roblox.com/en-us/api-reference/enum/CoreGuiType).
*
* Chat Commands
* -------------
*
* Using this event and some string manipulation functions like `string.sub` and `string.lower`, it is possible to create chat commands, even with arguments like player names. Usually, commands are prefixed such as `/heal PlayerName`. To check for a prefix in a string, use `string.sub` on the message to check a substring of the message: `string.sub(message, 1, 6) == "/heal "` (note the inclusion of the space) . Then, extract the rest of the command using `string.sub` again: `string.sub(message, 7)` will be equal to the player name. Check if that player exists, and if so, perform the command's action (in this example, healing them). Check the code samples for examples of chat commands.
*
* Filtering
* ---------
*
* The message text fired with this event is **unfiltered**. If you are displaying player input like chat to other players in any form, it must be filtered using [Chat:FilterStringAsync](https://developer.roblox.com/en-us/api-reference/function/Chat/FilterStringAsync). Keep this in mind when creating your own chat systems; if your game does not properly filter chat it may have moderation action taken against it.
*/
readonly Chatted: RBXScriptSignal<(message: string, recipient?: Player) => void>;
/**
* This event is usually fired two minutes after the game engine classifies the [player](https://developer.roblox.com/en-us/api-reference/class/Player) as idle. Time is the amount of seconds since this point.
*
* This can be used to track when a player has been idled for approximately two minutes - which can be useful for implementing away from keyboard (AFK) features into a game.
*
* When the game engine classifies a player as idle, this event is called after two minutes. After every check, if the player is still idled, the event will continue to fire until the check reveals the player is no longer idle.
*
* This event is used by Roblox to automatically disconnect players that have been idle for at least 20 minutes. If you would like to track when this disconnect occurs, considering using [Players.PlayerRemoving](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerRemoving) alongside this event.
*/
readonly Idled: RBXScriptSignal<(time: number) => void>;
/**
* Fired when the TeleportState of a player changes. This event is useful for detecting whether a teleportation was successful.
*
* What is the TeleportState?
* --------------------------
*
* When a teleportation request is made using [TeleportService](https://developer.roblox.com/en-us/api-reference/class/TeleportService), there are a series of stages before the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) is teleported. The current stage is represented by the [TeleportState](https://developer.roblox.com/en-us/api-reference/enum/TeleportState) value which is given by OnTeleport. See below for a practical example of this.
*/
readonly OnTeleport: RBXScriptSignal<(teleportState: Enum.TeleportState, placeId: number, spawnName: string) => void>;
}
/** [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts) is a container object located inside [Player](https://developer.roblox.com/en-us/api-reference/class/Player) objects within the [Players](https://developer.roblox.com/en-us/api-reference/class/Players) game service. It is created automatically when a player joins the game. Its main purpose is to contain [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s copied from the [StarterPlayerScripts](https://developer.roblox.com/en-us/api-reference/class/StarterPlayerScripts) container within the [StarterPlayer](https://developer.roblox.com/en-us/api-reference/class/StarterPlayer) game service, which happens once upon creation. Descendant `LocalScripts` of [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts) will run code on the client of the [Player](https://developer.roblox.com/en-us/api-reference/class/Player).
*
* Unlike the [Backpack](https://developer.roblox.com/en-us/api-reference/class/Backpack) and [PlayerGui](https://developer.roblox.com/en-us/api-reference/class/PlayerGui) containers, the [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts) container is not accessible to the server. Server [Script](https://developer.roblox.com/en-us/api-reference/class/Script) objects will not run when parented to [PlayerScripts](https://developer.roblox.com/en-us/api-reference/class/PlayerScripts).
*/
interface PlayerScripts extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlayerScripts: unique symbol;
/**
* Unregisters all ComputerCameraMovementMode enums from the game settings menu.
*/
ClearComputerCameraMovementModes(this: PlayerScripts): void;
/**
* Unregisters all ComputerMovementMode enums from the game settings menu.
*/
ClearComputerMovementModes(this: PlayerScripts): void;
/**
* Unregisters all TouchCameraMovementMode enums from the game settings menu.
*/
ClearTouchCameraMovementModes(this: PlayerScripts): void;
/**
* Unregisters all TouchMovementMode enums from the game settings menu.
*/
ClearTouchMovementModes(this: PlayerScripts): void;
/**
* Registers that a computer camera movement mode is available to be selected from the game menu.
*/
RegisterComputerCameraMovementMode(this: PlayerScripts, cameraMovementMode: CastsToEnum): void;
/**
* Registers that a computer movement mode is available to be selected from the game menu.
*/
RegisterComputerMovementMode(this: PlayerScripts, movementMode: CastsToEnum): void;
/**
* Registers that a touch camera movement mode is available to be selected from the game menu.
*/
RegisterTouchCameraMovementMode(this: PlayerScripts, cameraMovementMode: CastsToEnum): void;
/**
* Registers that a touch movement mode is available to be selected from the game menu.
*/
RegisterTouchMovementMode(this: PlayerScripts, movementMode: CastsToEnum): void;
}
interface PlayerViewService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PlayerViewService: unique symbol;
GetDeviceCameraCFrame(this: PlayerViewService, player?: Player): CFrame;
}
/** The Players game service contains only [Player](https://developer.roblox.com/en-us/api-reference/class/Player) objects for presently connected clients to a Roblox game server. It also contains information about a place's configuration (such as bubble chat or classic chat). It can fetch information about players not connected to the server, such as character appearances, friends and avatar thumbnail. */
interface Players extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Players: unique symbol;
/**
* The BubbleChat [Players](https://developer.roblox.com/en-us/api-reference/class/Players) property indicates whether or not bubble chat is enabled. It is set with the [Players:SetChatStyle](https://developer.roblox.com/en-us/api-reference/function/Players/SetChatStyle) method using the [ChatStyle](https://developer.roblox.com/en-us/api-reference/enum/ChatStyle) enum.
*
* When this chat mode is enabled, the game displays chats in the chat user interface at the top-left corner of the screen.
*
* There are two other chat modes, [Players.ClassicChat](https://developer.roblox.com/en-us/api-reference/property/Players/ClassicChat) and a chat mode where both classic and bubble chat are enabled.
*
* See also
* --------
*
* Developers who are interested interested in configuring their games' bubble chat system even further should take a look at the [Bubble Chat](https://developer.roblox.com/en-us/articles/bubble-chat) article.
*
* Tags: NotReplicated
*/
readonly BubbleChat: boolean;
/**
* The CharacterAutoLoads [Players](https://developer.roblox.com/en-us/api-reference/class/Players) property indicates whether `Character`s will respawn automatically. The default value is _true_.
*
* If this property is disabled (_false_), players `Characters` will not spawn until the [Player:LoadCharacter](https://developer.roblox.com/en-us/api-reference/function/Player/LoadCharacter) function is called for each [Player](https://developer.roblox.com/en-us/api-reference/class/Player) - including when players join the game.
*
* This can be useful in games where players have finite lives, such as competitive games in which players do not respawn until a game round ends.
*
* Tags: NotReplicated
*/
CharacterAutoLoads: boolean;
/**
* Indicates whether or not classic chat is enabled. This property is set by the [Players:SetChatStyle](https://developer.roblox.com/en-us/api-reference/function/Players/SetChatStyle) method using the [ChatStyle](https://developer.roblox.com/en-us/api-reference/enum/ChatStyle) enum.
*
* When this chat mode is enabled, the game displays chats in a bubble above the sender's head.
*
* There are two other chat modes, [Players.BubbleChat](https://developer.roblox.com/en-us/api-reference/property/Players/BubbleChat) and a chat mode where both classic and bubble chat are enabled.
*
* Tags: NotReplicated
*/
readonly ClassicChat: boolean;
/**
* **LocalPlayer** is a read-only property which refers to the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) whose client is running the game.
*
* This property is only defined for [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s (and [ModuleScript](https://developer.roblox.com/en-us/api-reference/class/ModuleScript)s required by them), as they run on the client. For the server (on which [Script](https://developer.roblox.com/en-us/api-reference/class/Script) objects run their code), this property is nil. See [Roblox Client-Server Model](https://developer.roblox.com/en-us/articles/roblox-client-server-model) for more information on game networking on Roblox.
*
* This property is useful in [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s which display information about the player viewing a GUI. Using For example, if there were [IntValue](https://developer.roblox.com/en-us/api-reference/class/IntValue) parented to a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) named “Coins” which represented how much money that player has, you could use the following to display this value for them:
*
* \-- This code is appropriate for a LocalScript in StarterGui,
* -- for example: game.StarterGui.ScreenGui.TextLabel.LocalScript
*
* local player = game:GetService("Players").LocalPlayer
* -- Wait for a value we're expecting for the server to have created
* local vCoins = player:WaitForChild("Coins")
*
* local textLabel = script.Parent
* local function update()
* textLabel.Text = "Coins: " .. vCoins.Value
* end
*
* -- Update once, then every time the value changes
* update()
* vCoins.Changed:Connect(update)
*
* Loading GUIs
* ------------
*
* When creating loading GUIs using [ReplicatedFirst](https://developer.roblox.com/en-us/api-reference/class/ReplicatedFirst), sometimes a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) can run before the LocalPlayer is available. In this case, you should yield until it becomes available by using [Instance:GetPropertyChangedSignal](https://developer.roblox.com/en-us/api-reference/function/Instance/GetPropertyChangedSignal)
*
* local Players = game:GetService("Players")
* -- Below: access Players.LocalPlayer; if it is nil, we'll wait for it using GetPropertyChangedSignal.
* local player = Players.LocalPlayer or Players:GetPropertyChangedSignal("LocalPlayer"):wait()
*
* Doing this isn't for a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript) within [StarterGui](https://developer.roblox.com/en-us/api-reference/class/StarterGui), [StarterPlayerScripts](https://developer.roblox.com/en-us/api-reference/class/StarterPlayerScripts) or [StarterCharacterScripts](https://developer.roblox.com/en-us/api-reference/class/StarterCharacterScripts): these scripts can only run after a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) object is already available, and LocalPlayer will have been set by then.
*
* Tags: NotReplicated
*/
readonly LocalPlayer: Player;
/**
* The MaxPlayers [Players](https://developer.roblox.com/en-us/api-reference/class/Players) property determines the maximum amount of players that can be in this server.
*
* While this property cannot be set through [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s in-game, it can be set from the place settings' _Access_ tab on the site.
*
* You can change this value depending on the number of player's you would like to limit in a single server. The number of players in a server affects the feel of your game and it's performance.
*
* Tags: NotReplicated
*/
readonly MaxPlayers: number;
/**
* This property indicates the number of people in the server at the current time. It is read only. Meaning it cannot be written to, only read.
*
* Tags: NotReplicated
* @deprecated Use `GetPlayers` instead
*/
readonly NumPlayers: number;
/**
* The PreferredPlayers property determines the number of players to which Roblox's matchmaker will fill servers. This is number should be less than the maximum number of players supported by the game in order to leave some spaces for additional players (such as friends or those following another player) to join.
*
* This property can be set from the place settings' _Access_ tab on the site. It cannot be set through [Script](https://developer.roblox.com/en-us/api-reference/class/Script)s or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript)s in-game.
*
* When a player press the Play button to join a game server, Roblox attempts to match that player to a server such that the player count will try not to exceed PreferredPlayers. If a friend (or friends) of the player are in a server that is not full, Roblox prioritizes that server instead.
*
* Example
* -------
*
* There are 8 players in a server where the `Player/MaximumPlayers` is 10 and the PreferredPlayers is 8. A player presses the play button:
*
* * If the player has **at least one friend** in the server, Roblox selects the already-existing server so the player can play with their friend.
* * If the player has **no friends** in the server, a new server is started since the existing server has met the number of PreferredPlayers (the player could still join the server by manually selecting it or following another user).
*
* Tags: NotReplicated
*/
readonly PreferredPlayers: number;
/**
* The RespawnTime property controls the time, in seconds, it takes for a player to respawn when [Players.CharacterAutoLoads](https://developer.roblox.com/en-us/api-reference/property/Players/CharacterAutoLoads) is _true_. It defaults to 5.0 seconds.
*
* 
*
* This is useful when you want to change how long it takes to respawn based on the type of your game but don't want to handle spawning players individually. Social games may want to decrease the respawn time whereas action games may want to increase it.
*
* Although this can be set from within a [Script](https://developer.roblox.com/en-us/api-reference/class/Script), you will likely set the property from within Studio via the Players service property window.
*
* local Players = game:GetService(“Players”)
* Players.RespawnTime = 10.0
*
* ### See also
*
* * `Player/SpawnLocation`, if set, the player will respawn at the given [SpawnLocation](https://developer.roblox.com/en-us/api-reference/class/SpawnLocation)
*/
RespawnTime: number;
/**
* This function searches each [player](https://developer.roblox.com/en-us/api-reference/class/Player) in [Players](https://developer.roblox.com/en-us/api-reference/class/Players) for one whose [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) matches the given UserId. If such a player does not exist, it simply returns `nil`. It is equivalent to the following function:
*
* local Players = game:GetService("Players")
* local function getPlayerByUserId(userId)
* for \_, player in pairs(Players:GetPlayers()) do
* if player.UserId == userId then
* return player
* end
* end
* end
*
* This method is useful in finding the purchaser of a developer product using [MarketplaceService.ProcessReceipt](https://developer.roblox.com/en-us/api-reference/property/MarketplaceService/ProcessReceipt), which provides a table that includes the purchaser's UserId and not a reference to the Player object itself. Most games will require a reference to the player in order to grant products.
*/
GetPlayerByUserId(this: Players, userId: number): Player | undefined;
/**
* This function returns the [Player](https://developer.roblox.com/en-us/api-reference/class/Player) associated with the given [Player.Character](https://developer.roblox.com/en-us/api-reference/property/Player/Character), or `nil` if one cannot be found. It is equivalent to the following function:
*
* local function getPlayerFromCharacter(character)
* for \_, player in pairs(game:GetService("Players"):GetPlayers()) do
* if player.Character == character then
* return player
* end
* end
* end
*
* This method is often used when some event in player's character fires (such as their [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) [dying](https://developer.roblox.com/en-us/api-reference/event/Humanoid/Died)). Such an event might not directly reference the Player object, but this method provides easy access. The inverse of this function can be described as getting the Character of a Player. To do this, simply access the Character property.
*/
GetPlayerFromCharacter(this: Players, character: Instance | undefined): Player | undefined;
/**
* This method returns a table of all presently connected [Player](https://developer.roblox.com/en-us/api-reference/class/Player). It functions the same way [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) would except that it only returns Player objects. It functions similarly to [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) when called on [Players](https://developer.roblox.com/en-us/api-reference/class/Players). 0 When used in conjunction with a for-loop, it is useful for iterating over all players in a game.
*
* Players = game:GetService("Players")
* for i, player in pairs(Players:GetPlayers()) do
* print(player.Name)
* end
*
* Scripts that connect to [Players.PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded) are often trying to process every Player that connects to the game. This method is useful for iterating over already-connected players that wouldn't fire [PlayerAdded](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerAdded). Using this method ensures that no player is missed!
*
* local Players = game:GetService("Players")
*
* local function onPlayerAdded(player)
* print("Player: " .. player.Name)
* end
*
* for \_, player in pairs(Players:GetPlayers()) do
* onPlayerAdded(player)
* end
* Players.PlayerAdded:Connect(onPlayerAdded)
*/
GetPlayers(this: Players): Array;
/**
* Tags: Yields
*/
CreateHumanoidModelFromDescription(
this: Players,
description: HumanoidDescription,
rigType: CastsToEnum,
assetTypeVerification?: CastsToEnum,
): Model;
/**
* Tags: Yields
*/
CreateHumanoidModelFromUserId(this: Players, userId: number): Model;
/**
* This function returns a [Model](https://developer.roblox.com/en-us/api-reference/class/Model) containing the assets which the player is wearing, excluding gear.
*
* If you prefer a Lua table of information about these assets instead of a model, use [Players:GetCharacterAppearanceInfoAsync](https://developer.roblox.com/en-us/api-reference/function/Players/GetCharacterAppearanceInfoAsync).
*
* This method behaves similar to [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset), and is like using [LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) on the asset information returned by [Players:GetCharacterAppearanceInfoAsync](https://developer.roblox.com/en-us/api-reference/function/Players/GetCharacterAppearanceInfoAsync) except faster.
*
* Tags: Yields
* @deprecated
*/
GetCharacterAppearanceAsync(this: Players, userId: number): Model;
/**
* This function returns information about a player's avatar (ignoring gear) on the Roblox website in the form of a dictionary. It is not to be confused with [GetCharacterAppearanceAsync](https://developer.roblox.com/en-us/api-reference/function/Players/GetCharacterAppearanceAsync), which actually loads the assets described by this method. You can use [InsertService:LoadAsset](https://developer.roblox.com/en-us/api-reference/function/InsertService/LoadAsset) to load the assets that are used in the player's avatar. The structure of the returned dictionary is as follows:
*
* Name
*
* Type
*
* Description
*
* `bodyColors`
*
* table (see below)
*
* Describes the BrickColor values for each limb
*
* `assets`
*
* table (see below)
*
* Describes the equipped assets (hats, body parts, etc)
*
* `defaultPantsApplied`
*
* bool
*
* Describes whether default pants are applied
*
* `defaultShirtApplied`
*
* bool
*
* Describes whether default shirt is applied
*
* `playerAvatarType`
*
* string
*
* Either "R15" or "R6"
*
* `scales`
*
* table (see below)
*
* Describes various body scaling factors
*
* ### Assets sub-table
*
* The assets table is an array of tables containing the following keys that describe the assets currently equipped by the player:
*
* Name
*
* Type
*
* Description
*
* `id`
*
* number
*
* The asset ID of the equipped asset
*
* `assetType`
*
* table
*
* A table with `name` and `id` fields, each describing the kind of asset equipped ("Hat", "Face", etc.)
*
* `name`
*
* string
*
* The name of the equipped asset
*
* ### Scales sub-table
*
* The scales table has the following keys, each a number corresponding to one [Humanoid](https://developer.roblox.com/en-us/api-reference/class/Humanoid) scaling property:
* `bodyType`, `head`, `height`, `proportion`, `depth`, `width`
*
* ### Body Colors sub-table
*
* The body colors table has the following keys, each a number corresponding to a [BrickColor](https://developer.roblox.com/en-us/api-reference/datatype/BrickColor) ID number which can be used with `BrickColor.new(id)`:
* `leftArmColorId`, `torsoColorId`, `rightArmColorId`, `headColorId`, `leftLegColorId`, `rightLegColorId`
*
* Tags: Yields
*/
GetCharacterAppearanceInfoAsync(this: Players, userId: number): CharacterAppearanceInfo;
/**
* The GetFriends [Players](https://developer.roblox.com/en-us/api-reference/class/Players) function returns a [FriendPages](https://developer.roblox.com/en-us/api-reference/class/FriendPages) object which contains information for all of the given [Player's](https://developer.roblox.com/en-us/api-reference/class/Player) friends. The items within the FriendPages object are tables with the following fields:
*
* Name
*
* Type
*
* Description
*
* Id
*
* int64
*
* The friend's UserId
*
* Username
*
* string
*
* The friend's username
*
* DisplayName
*
* string
*
* The [display name](https://developer.roblox.com/en-us/api-reference/property/Player/DisplayName) of the friend.
*
* IsOnline
*
* bool
*
* If the friend is currently online
*
* See the code samples for an easy way to iterate over all a player's friends.
*
* Tags: Yields
*/
GetFriendsAsync(this: Players, userId: number): FriendPages;
/**
* Tags: Yields
*/
GetHumanoidDescriptionFromOutfitId(this: Players, outfitId: number): HumanoidDescription;
/**
* Tags: Yields
*/
GetHumanoidDescriptionFromUserId(this: Players, userId: number): HumanoidDescription;
/**
* The GetNameFromUserIdAsync [Players](https://developer.roblox.com/en-us/api-reference/class/Players) function will send a query to the Roblox website asking what the username is of the account with the given [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId).
*
* This method errors if no account exists with the given UserId. If you aren't certain such an account exists, it's recommended to wrap calls to this function with `pcall`. In addition, you can manually cache results to make future calls with the same UserId fast. See the code samples to learn how to do this.
*
* Tags: Yields
*/
GetNameFromUserIdAsync(this: Players, userId: number): string;
/**
* This function will send a query to the Roblox website asking what the [Player.UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId) is of the account with the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player) name.
*
* This method errors if no account exists with the given username. If you aren't certain such an account exists, it's recommended to wrap calls to this function with `pcall`. In addition, you can manually cache results to quickly make future calls with the same username. See the code samples to learn how to do this.
*
* Tags: Yields
*/
GetUserIdFromNameAsync(this: Players, userName: string): number;
/**
* This function fetches a [content URL](https://developer.roblox.com/en-us/articles/content) of an image of a player's avatar given their [UserId](https://developer.roblox.com/en-us/api-reference/property/Player/UserId), the image size (as an enum) and type (also an enum: avatar, bust, headshot). It also returns a bool describing if the image is ready to be used.
*
* Most often, this method is used with [ImageLabel.Image](https://developer.roblox.com/en-us/api-reference/property/ImageLabel/Image) to display player pictures next to their username in-game. It is also appropriate for [Decal.Texture](https://developer.roblox.com/en-us/api-reference/property/Decal/Texture) as well.
*
* Available Sizes
* ---------------
*
* `Enum.ThumbnailSize`: `Size48x48`, `Size60x60`, `Size100x100`, `Size150x150`, `Size180x180`, `Size353x353`, `Size420x420`
*
* Types of User Thumbnails
* ------------------------
*
* Enum.ThumbnailType
*
* Description
*
* Example (60px)
*
* `AvatarBust`
*
* Upper chest and head
*
* 
*
* `AvatarThumbnail`
*
* Entire avatar
*
* 
*
* `HeadShot`
*
* Just the head and face
*
* 
*
* Tags: Yields
*/
GetUserThumbnailAsync(
this: Players,
userId: number,
thumbnailType: CastsToEnum,
thumbnailSize: CastsToEnum,
): LuaTuple<[string, boolean]>;
/**
* The PlayerAdded event fires when a player enters the game. This is used to fire an event when a player joins a game, such as loading the player's saved [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore) data.
*
* This can be used alongside the [Players.PlayerRemoving](https://developer.roblox.com/en-us/api-reference/event/Players/PlayerRemoving) event, which fires when a player is about to leave the game. For instance, if you would like print a message every time a new player joins or leaves the game:
*
* local Players = game:GetService("Players")
*
* Players.PlayerAdded:Connect(function(player)
* print(player.Name .. " joined the game!")
* end)
*
* Players.PlayerRemoving:Connect(function(player)
* print(player.Name .. " left the game!")
* end)
*
* If you want to track when a player's character is added or removed from the game, such as when a player respawns or dies, you can use the [Player.CharacterAdded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAdded) and [Player.CharacterRemoving](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterRemoving) functions.
*
* Notes
* -----
*
* * Up until recently, this event didn't work on the client (in `Localscript`s), but this has been changed
*
* * This event does not work as expected in _solo mode_, because the player is created before scripts that connect to PlayerAdded run. To handle this case, as well as cases in which the script is added into the game after a player enters, create an OnPlayerAdded function that you can call to handle a player's entrance.
*/
readonly PlayerAdded: RBXScriptSignal<(player: Player) => void>;
/**
* This event fires when the game server recognizes that a player's membership has changed. Note, however, that the server will only attempt to check and update the membership **after** the Premium modal has been closed. Thus, to account for cases where the user purchases Premium **outside** of the game while playing, you must still prompt them to purchase Premium; this will then show a message telling them they're already upgraded and, once they close the modal, the game server will update their membership and trigger this event.
*
* To learn more about and incorporating Premium into your game, and monetizing your game with the Premium Payouts system, take a look at [this](https://developer.roblox.com/articles/premium-payouts) article.
*
* See also
* --------
*
* * [MarketplaceService:PromptPremiumPurchase](https://developer.roblox.com/en-us/api-reference/function/MarketplaceService/PromptPremiumPurchase), used to prompt a user to purchase Premium
* * [MarketplaceService.PromptPremiumPurchaseFinished](https://developer.roblox.com/en-us/api-reference/event/MarketplaceService/PromptPremiumPurchaseFinished), fires when the Premium purchase UI closes
*/
readonly PlayerMembershipChanged: RBXScriptSignal<(player: Player) => void>;
/**
* The PlayerRemoving event fires right before a [Player](https://developer.roblox.com/en-us/api-reference/class/Player) leaves the game. This event fires before [ChildRemoved](https://developer.roblox.com/en-us/api-reference/event/Instance/ChildRemoved) does on [Players](https://developer.roblox.com/en-us/api-reference/class/Players), and behaves somewhat similarly to [Instance.DescendantRemoving](https://developer.roblox.com/en-us/api-reference/event/Instance/DescendantRemoving). Since it fires before the actual removal of a [Player](https://developer.roblox.com/en-us/api-reference/class/Player), this event is useful for storing player data using a [GlobalDataStore](https://developer.roblox.com/en-us/api-reference/class/GlobalDataStore).
*
* This can be used alongside the `Player/PlayerAdded` event, which fires when a player joins the game. For instance, to print a message every time a new player joins or leaves the game:
*
* local Players = game:GetService("Players")
*
* Players.PlayerAdded:Connect(function(player)
* print(player.Name .. " joined the game!")
* end)
*
* Players.PlayerRemoving:Connect(function(player)
* print(player.Name .. " left the game!")
* end)
*
* If you want to track when a player's character is added or removed from the game, such as when a player respawns or dies, you can use the [Player.CharacterAdded](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterAdded) and [Player.CharacterRemoving](https://developer.roblox.com/en-us/api-reference/event/Player/CharacterRemoving) functions.
*/
readonly PlayerRemoving: RBXScriptSignal<(player: Player) => void>;
readonly UserSubscriptionStatusChanged: RBXScriptSignal<(user: Player, subscriptionId: string) => void>;
}
interface PluginCapabilities extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PluginCapabilities: unique symbol;
}
interface PluginManagementService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PluginManagementService: unique symbol;
}
interface PluginManagerInterface extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PluginManagerInterface: unique symbol;
}
interface PluginPolicyService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PluginPolicyService: unique symbol;
}
/** Important for getting your game to all audiences, [PolicyService](https://developer.roblox.com/en-us/api-reference/class/PolicyService) helps you build gameplay components that can be made compliant with various national regulations for multiple countries. This service is used to query information regarding policy compliance for players around the world based on age range, location, and platform type. */
interface PolicyService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PolicyService: unique symbol;
/**
* Returns policy information about a player which is based on geolocation, age group, and platform. The structure of the returned dictionary is as follows:
*
* Name
*
* Type
*
* Required for
*
* Description
*
* ArePaidRandomItemsRestricted
*
* Boolean
*
* Any experience that has paid random items
*
* When true, the player cannot interact with paid (via in-experience currency or Robux) random item generators.
*
* AllowedExternalLinkReferences
*
* Array of strings
*
* Any experience that references external links
*
* A list of external link references (for example, social media links, handles, or iconography) a player is permitted to see. Possible values include: “Discord”, “Facebook”, “Twitch”, and “YouTube”.
*
* IsPaidItemTradingAllowed
*
* Boolean
*
* Any experience that allows users to purchase virtual items that they can trade with other players
*
* When true, the player can trade virtual items that they purchased with in-experience currency or Robux.
*
* IsSubjectToChinaPolicies
*
* Boolean
*
* Any experience that is available in China
*
* When true, an experience should enforce compliance changes. See [this developer forum post](https://devforum.roblox.com/t/new-programs-available-roblox-china-licensed-to-operate/1023361) for more information.
*
* Exceptions
* ----------
*
* Like any async call, this needs to be wrapped in a `pcall` and error-handled properly. A full list of possible error messages and their reasons is as below:
*
* Message
*
* Reason
*
* Instance was not a player
*
* Dev's usage - The parameter is not a Player instance
*
* Players not found
*
* Internal error - Players object missing
*
* This method cannot be called on the client for a non-local player
*
* Dev's usage - This method cannot be called on the client for a non-local player
*
* GetPolicyInfoForPlayerAsync is called too many times
*
* Internal error - GetPolicyInfoForPlayerAsync is called more than 100(current setting) times before http response coming back
*
* See also
* --------
*
* * [LocalizationService:GetCountryRegionForPlayerAsync](https://developer.roblox.com/en-us/api-reference/function/LocalizationService/GetCountryRegionForPlayerAsync), returns country/region code string according to player's client IP geolocation
*
* Tags: Yields
*/
GetPolicyInfoForPlayerAsync(this: PolicyService, player: Player): PolicyInfo;
}
interface PoseBase extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PoseBase: unique symbol;
EasingDirection: Enum.PoseEasingDirection;
EasingStyle: Enum.PoseEasingStyle;
Weight: number;
}
interface NumberPose extends PoseBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_NumberPose: unique symbol;
Value: number;
}
/** A Pose holds the `CFrame` applied to the [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connected to its associated [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart). The part which is controlled depends on the name of the Pose.
*
* Poses are the fundamental building blocks of animations and, with `Keyframes`, make up `KeyframeSequences`.
*
* Poses, joints and hierarchy
* ---------------------------
*
* Although a Pose is assigned to a [BasePart](https://developer.roblox.com/en-us/api-reference/class/BasePart) by name, the object manipulated during animation playback is actually the [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) connected to this part. Animation rigs branch out from the model's root part through such joints.
*
* As an example. In a R15 character rig the root part is the HumanoidRootPart. The LowerTorso is connected to the HumanoidRootPart by the a motor named 'Root'. Therefore, the `CFrame` of a Pose named 'LowerTorso' in a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) would be applied to the motor named 'Root', and not the LowerTorso itself.
*
* Poses are arranged in a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) based on joint hierarchy. This means, the Pose's `CFrame` is applied to the motor connecting the part associated with the pose to the part associated with the pose's parent. See below for a visual example of the structure of Poses on a R15 character.
*
* 
*
* Pose CFrame
* -----------
*
* The Roblox animation system applies [Pose.CFrame](https://developer.roblox.com/en-us/api-reference/property/Pose/CFrame) to the corresponding [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) by manipulating the relative transformation of the motor, the [Motor6D.Transform](https://developer.roblox.com/en-us/api-reference/property/Motor6D/Transform) property. The original [C0](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) and [C1](https://developer.roblox.com/en-us/api-reference/property/JointInstance/C1) values are not changed.
*/
interface Pose extends PoseBase {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_Pose: unique symbol;
/**
* The `CFrame` that will be applied to the [Motor6D](https://developer.roblox.com/en-us/api-reference/class/Motor6D) corresponding with the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose). This `CFrame` is applied by changing the `Motor6D\Transform` property of the motor. The original `Motor6D/C0` and `Motor6D/C1` values are not changed.
*
* [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) objects are arranged in a [Keyframe](https://developer.roblox.com/en-us/api-reference/class/Keyframe) based on joint hierarchy. This means, the the [Pose.CFrame](https://developer.roblox.com/en-us/api-reference/property/Pose/CFrame) is applied to the motor connecting the part associated with the pose to the part associated with the pose's parent.
*/
CFrame: CFrame;
/**
* Tags: NotReplicated
* @deprecated
*/
MaskWeight: number;
/**
* This function adds a sub [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) to the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) by parenting it to it. It is functionally identical to setting the new pose's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to the pose.
*
* Note, this function will not error when an instance other than a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is given as the pose parameter and will parent it successfully.
*/
AddSubPose(this: Pose, pose: Pose): void;
/**
* This function returns an array containing all sub [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose)s that have been added to a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose). This is functionally the same as using the [Instance:GetChildren](https://developer.roblox.com/en-us/api-reference/function/Instance/GetChildren) function on the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose).
*
* Note, this function will return all children of the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose), including non [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) [Instance](https://developer.roblox.com/en-us/api-reference/class/Instance)s if any are present.
*/
GetSubPoses(this: Pose): Array;
/**
* This function removes a sub [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) from the [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) by parenting it to nil. It is functionally identical to setting the new pose's [Instance.Parent](https://developer.roblox.com/en-us/api-reference/property/Instance/Parent) to nil.
*
* Note, this function will not error when an instance other than a [Pose](https://developer.roblox.com/en-us/api-reference/class/Pose) is given as the pose parameter and remove it successfully.
*/
RemoveSubPose(this: Pose, pose: Pose): void;
}
/** PostEffect is an abstract base class for post-processing effects, such as [BloomEffect](https://developer.roblox.com/en-us/api-reference/class/BloomEffect) and [ColorCorrectionEffect](https://developer.roblox.com/en-us/api-reference/class/ColorCorrectionEffect). They change how the world looks **after** it has been rendered. They do not affect [GuiObject](https://developer.roblox.com/en-us/api-reference/class/GuiObject)s. Objects of this kind should be parented to the [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) in order to work.
*
* It should also be noted that some post-processing effects will work differently or **not at all** when Roblox is set to a low [QualityLevel](https://developer.roblox.com/en-us/api-reference/property/RenderSettings/QualityLevel) (or [EditQualityLevel](https://developer.roblox.com/en-us/api-reference/property/RenderSettings/EditQualityLevel) in Studio). On some low-end devices, faster rendering algorithms may be used. By default, these quality settings are set to Automatic, so if you aren't seeing post-processing effects you should check Roblox's settings under the “Rendering” section. It may be necessary to override the automatic behavior temporarily in order to preview post-processing effects.
*/
interface PostEffect extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PostEffect: unique symbol;
/**
* Toggles whether or not the PostEffect is enabled.
*/
Enabled: boolean;
}
/** The **BloomEffect** simulates the camera viewing a very bright light. It causes brighter colors to glow, similar to applying the neon [Material](https://developer.roblox.com/en-us/api-reference/property/BasePart/Material) to everything, including the the [Sky](https://developer.roblox.com/en-us/api-reference/class/Sky). Multiple **BloomEffect** objects can be applied at once and they will compose their effects together.
*
* Like other post-processing effects, **BloomEffect** will only work while [Enabled](https://developer.roblox.com/en-us/api-reference/property/PostEffect/Enabled) and when parented to [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Also, it may render differently depending on your Studio settings (see the **Quality Level** settings in **Rendering** → **Performance**).
*
* For more details on this effect and others, see the [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects) article.
*/
interface BloomEffect extends PostEffect {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BloomEffect: unique symbol;
/**
* Intensity determines how intensely the colors that bloom (determined by the [Threshold](https://developer.roblox.com/en-us/api-reference/property/BloomEffect/Threshold)) will additively blend with themselves. Higher values will produce brighter colors.
*/
Intensity: number;
/**
* Size determines the radius of the bloom effect in pixels in a similar manner to [BlurEffect.Size](https://developer.roblox.com/en-us/api-reference/property/BlurEffect/Size). Larger values create a wider bloom effect, and a value of 0 will disable the bleed (but not the color adjustment).
*/
Size: number;
/**
* Threshold determines how bright a color can be before it blooms. If set to 1, only pure white colors will bloom. If set to 0, all colors will bloom.
*/
Threshold: number;
}
/** The **BlurEffect** applies a gaussian blur to the entire rendered game world. The strength of the blur is controlled by the [BlurEffect.Size](https://developer.roblox.com/en-us/api-reference/property/BlurEffect/Size). Only one **BlurEffect** can be applied at once (the instance with the greatest [Size](https://developer.roblox.com/en-us/api-reference/property/BlurEffect/Size) takes priority).
*
* Like other post-processing effects, **BlurEffect** will only work while [Enabled](https://developer.roblox.com/en-us/api-reference/property/PostEffect/Enabled) and when parented to [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Also, it may render differently on low-end devices and/or depending on your Studio settings (see the **Quality Level** settings in **Rendering** → **Performance**).
*
* For more details on this effect and others, see the [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects) article.
*/
interface BlurEffect extends PostEffect {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_BlurEffect: unique symbol;
/**
* Size controls the blur radius, measured in pixels. The larger the size, the blurrier the screen will become.
*/
Size: number;
}
/** The **ColorCorrectionEffect** can be used to adjust several color-related properties at once: [Saturation](https://developer.roblox.com/en-us/api-reference/property/ColorCorrectionEffect/Saturation), [TintColor](https://developer.roblox.com/en-us/api-reference/property/ColorCorrectionEffect/TintColor), [Brightness](https://developer.roblox.com/en-us/api-reference/property/ColorCorrectionEffect/Brightness) and [Contrast](https://developer.roblox.com/en-us/api-reference/property/ColorCorrectionEffect/Contrast). It's useful for fine-tuning the visual aesthetic of a world or communicating status effects to the player. Multiple **ColorCorrectionEffect** objects can be applied at once and they will compose their effects together.
*
* Like other post-processing effects, **ColorCorrectionEffect** will only work while [Enabled](https://developer.roblox.com/en-us/api-reference/property/PostEffect/Enabled) and when parented to [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Also, it may render differently depending on your Studio settings (see the **Quality Level** settings in **Rendering** → **Performance**).
*
* For more details on this effect and others, see the [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects) article.
*/
interface ColorCorrectionEffect extends PostEffect {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ColorCorrectionEffect: unique symbol;
/**
* Brightness determines by how much the colors of pixels will be shifted. A value of -1 will cause all pixels to be completely black while a value of 1 will cause them to be white.
*/
Brightness: number;
/**
* Contrast determines the separation between the dark and light colors. Values less than 0 have reduced contrast while values greater than 0 have increased contrast.
*/
Contrast: number;
/**
* Saturation determines the change in intensity of pixel colors. Values above 1 will cause colors to be more vivid while values below 0 will make colors more dull, eventually reaching full desaturation at -1.
*/
Saturation: number;
/**
* Determines by what factors the RGB channels of pixel colors are scaled. The effect is multiplicative, so changing this to **\[255, 0, 0\]** (red) would cause the green and blue channels to be multiplied by 0.
*/
TintColor: Color3;
}
/** The **DepthOfFieldEffect** simulates a camera lens by blurring parts of a scene not in focus. Distant objects can be blurred or this effect can be used to focus on specific parts of a scene, like an item in an in-game shop.
*
* Like other post-processing effects, **DepthOfFieldEffect** will only work while [Enabled](https://developer.roblox.com/en-us/api-reference/property/PostEffect/Enabled) and when parented to [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Also, it may render differently on low-end devices or depending on your Studio settings (see the **Quality Level** settings in **Rendering** → **Performance**).
*
* For more details on this effect and others, see the [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects) article.
*
* 
*/
interface DepthOfFieldEffect extends PostEffect {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_DepthOfFieldEffect: unique symbol;
/**
* Intensity of the far field blur, moving out in distance from the [FocusDistance](https://developer.roblox.com/en-us/api-reference/property/DepthOfFieldEffect/FocusDistance) point plus [InFocusRadius](https://developer.roblox.com/en-us/api-reference/property/DepthOfFieldEffect/InFocusRadius) value.
*
* 
*/
FarIntensity: number;
/**
* Controls the distance away from the camera (in studs) where objects are in focus.
*
* 
*/
FocusDistance: number;
/**
* Controls the distance away from the [FocusDistance](https://developer.roblox.com/en-us/api-reference/property/DepthOfFieldEffect/FocusDistance) (on both sides) where no blur is applied. Measured in studs.
*
* 
*/
InFocusRadius: number;
/**
* Intensity of the near field blur, between the camera and the [FocusDistance](https://developer.roblox.com/en-us/api-reference/property/DepthOfFieldEffect/FocusDistance) point minus [InFocusRadius](https://developer.roblox.com/en-us/api-reference/property/DepthOfFieldEffect/InFocusRadius) value.
*
* 
*/
NearIntensity: number;
}
/** The **SunRaysEffect** renders a halo of light around sun. The halo is shaped/blocked by world objects between the [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera) and the sun.
*
* Like other post-processing effects, **SunRaysEffect** will only work while [Enabled](https://developer.roblox.com/en-us/api-reference/property/PostEffect/Enabled) and when parented to [Lighting](https://developer.roblox.com/en-us/api-reference/class/Lighting) or [Workspace.CurrentCamera](https://developer.roblox.com/en-us/api-reference/property/Workspace/CurrentCamera). Also, it may not render on low-end devices, and it may render differently depending on your Studio settings (see the **Quality Level** settings in **Rendering** → **Performance**).
*
* For more details on this effect and others, see the [Post-Processing Effects](https://developer.roblox.com/en-us/articles/post-processing-effects) article.
*/
interface SunRaysEffect extends PostEffect {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_SunRaysEffect: unique symbol;
/**
* Intensity determines the opacity of the sun rays. Values closer to 0 are less visible, while values closer to 1 become more visible.
*/
Intensity: number;
/**
* Spread determines how wide the sun rays will spread across the sky. Its value should be set between 0 and 1 as values outside that range have undefined behavior.
*/
Spread: number;
}
interface ProcessInstancePhysicsService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ProcessInstancePhysicsService: unique symbol;
}
/** The ProximityPrompt is an object that allows developers to prompt users to interact with an object in the 3D world, such as opening a door or picking up an item.
*
* ProximityPrompts work when parented to a [Part](https://developer.roblox.com/en-us/api-reference/class/Part), [Model](https://developer.roblox.com/en-us/api-reference/class/Model), or [Attachment](https://developer.roblox.com/en-us/api-reference/class/Attachment) in the workspace.
* In order to detect when the user interacts with the object, listen for the Triggered event on the ProximityPrompt in either a [Script](https://developer.roblox.com/en-us/api-reference/class/Script) or [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), as in this simple example:
*
* workspace.Part.ProximityPrompt.Triggered:Connect(function(player)
* print("The user interacted with me!")
* end)
*
* When a user is near, a UI will appear to prompt them for input. This works for all input types - keyboard, gamepad, and touchscreen.
*
* The provided UI can be swapped out for your own custom UI. See [ProximityPrompt.Style](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/Style) for details.
*
* ### Prompt Appearance
*
* Prompts consist of three primary elements, each of which can be controlled by the following properties:
*
* 
*
* * * *
*
* * **ObjectText** — An optional name for the object being interacted with.
* * **ActionText** — An optional action name shown to the player.
* * **KeyboardKeyCode** — The keyboard key which will trigger the prompt.
* * **GamepadKeyCode** — The gamepad button which will trigger the prompt.
*
* See also
* --------
*
* For more information regarding ProximityPrompts, take a look at the [Proximity Prompts](https://developer.roblox.com/en-us/articles/proximity-prompts).
*/
interface ProximityPrompt extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ProximityPrompt: unique symbol;
/**
* This property determines the action text shown to the user.
*/
ActionText: string;
/**
* This property determines whether the prompt's [ProximityPrompt.ActionText](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/ActionText) and [ProximityPrompt.ObjectText](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/ObjectText) will be localized according to the [ProximityPrompt.RootLocalizationTable](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/RootLocalizationTable). When set to true, localization will be applied.
*/
AutoLocalize: boolean;
/**
* This property determines whether the prompt can be activated by clicking/tapping on the prompt's UI. When set to false, the prompt cannot be activated by click/tap except on mobile.
*/
ClickablePrompt: boolean;
/**
* This property indicates whether or this [ProximityPrompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) should be shown.
*/
Enabled: boolean;
/**
* This property is used to customize which prompts can be shown at the same time.
*/
Exclusivity: Enum.ProximityPromptExclusivity;
/**
* This property determines the gamepad button the player should press to trigger the [prompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt).
*/
GamepadKeyCode: Enum.KeyCode;
/**
* This property indicates the duration, in seconds, that the player must hold the button/key down to trigger the prompt.
*/
HoldDuration: number;
/**
* This property determines the key the player should press to trigger the [prompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt).
*/
KeyboardKeyCode: Enum.KeyCode;
/**
* This property determines the maximum distance a Player's [character](https://developer.roblox.com/en-us/api-reference/property/Player/Character) can be from the [ProximityPrompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) for the prompt to appear.
*/
MaxActivationDistance: number;
/**
* This optional property determines the optional object name text shown to the user.
*/
ObjectText: string;
/**
* This property indicates whether the prompt is hidden if the path between the player's [Camera](https://developer.roblox.com/en-us/api-reference/class/Camera) and object parented to the [ProximityPrompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) is obstructed. If true, this prompt will only be shown if there is a clear path from the camera to the object.
*
* The parent [Part](https://developer.roblox.com/en-us/api-reference/class/Part) or [Model](https://developer.roblox.com/en-us/api-reference/class/Model) of the prompt will be excluded from this check.
*/
RequiresLineOfSight: boolean;
/**
* This property serves as a reference to the [LocalizationTable](https://developer.roblox.com/en-us/api-reference/class/LocalizationTable) used to apply automated localization to the ProximityPrompt's [ProximityPrompt.ActionText](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/ActionText) and [ProximityPrompt.ObjectText](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/ObjectText). In order for this to appy, [ProximityPrompt.AutoLocalize](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/AutoLocalize) must be set.
*
* Developers can set this to reference a LocalizationTable anywhere in the [DataModel](https://developer.roblox.com/en-us/api-reference/class/DataModel). It is not required to be a child of [LocalizationService](https://developer.roblox.com/en-us/api-reference/class/LocalizationService). If there is no translation available in the referenced table it will look for a translation in the parent of that table, if it is also a LocalizationTable, and so on.
*/
RootLocalizationTable: LocalizationTable | undefined;
/**
* This property indicates the [ProximityPrompt's](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) style. When set to Custom, no default UI will be provided.
*
* The provided UI can be swapped out for a custom UI. In order to do this, set Style to Custom. Then, listen to the [ProximityPrompt.PromptShown](https://developer.roblox.com/en-us/api-reference/event/ProximityPrompt/PromptShown) and [ProximityPrompt.PromptHidden](https://developer.roblox.com/en-us/api-reference/event/ProximityPrompt/PromptHidden) events in a [LocalScript](https://developer.roblox.com/en-us/api-reference/class/LocalScript), where developers should create and tear down the UI.
*
* Developers may also use [ProximityPrompt.PromptButtonHoldBegan](https://developer.roblox.com/en-us/api-reference/event/ProximityPrompt/PromptButtonHoldBegan) and [ProximityPrompt.PromptButtonHoldEnded](https://developer.roblox.com/en-us/api-reference/event/ProximityPrompt/PromptButtonHoldEnded) in order to utilize the [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration) progress animation feature.
*/
Style: Enum.ProximityPromptStyle;
/**
* This property indicates the pixel offset applied to the prompt's UI.
*/
UIOffset: Vector2;
/**
* This function triggers a signal indicating that the user began pressing the [ProximityPrompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) prompt button. It should be used by developers who wish to customize the prompt and trigger it from a prompt GUI button press.
*/
InputHoldBegin(this: ProximityPrompt): void;
/**
* A counterpoint to [ProximityPrompt:InputHoldBegin](https://developer.roblox.com/en-us/api-reference/function/ProximityPrompt/InputHoldBegin), this signals that the user ended pressing the prompt GUI button.
*/
InputHoldEnd(this: ProximityPrompt): void;
/**
* This event triggers when a player begins holding down the [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button on a prompt with a non-zero [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration). One possible usage includes to animate a hold progress bar.
*/
readonly PromptButtonHoldBegan: RBXScriptSignal<(playerWhoTriggered: Player) => void>;
/**
* This event triggers when the player ends holding down the button on a prompt with a non-zero [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration). One possible usage includes to animate a hold progress bar.
*/
readonly PromptButtonHoldEnded: RBXScriptSignal<(playerWhoTriggered: Player) => void>;
/**
* This event triggers when the [prompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) becomes hidden. This event is triggered client-side for `LocalScripts`.
*/
readonly PromptHidden: RBXScriptSignal<() => void>;
/**
* This event triggers when the [prompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) becomes visible. This event is triggered client-side for `LocalScripts`.
*/
readonly PromptShown: RBXScriptSignal<(inputType: Enum.ProximityPromptInputType) => void>;
/**
* This event is triggered when the [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button is released, for longer events where the user is required to hold down the button (e.g. heal another player over time.)
*/
readonly TriggerEnded: RBXScriptSignal<(playerWhoTriggered: Player) => void>;
/**
* This event is triggered when the prompt [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button is pressed, or after a specified amount of time holding the button, if [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration) is used.
*/
readonly Triggered: RBXScriptSignal<(playerWhoTriggered: Player) => void>;
}
/** The ProximityPromptService allows developers to interact with [ProximityPrompt](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) objects in a global way. It may be more convenient to listen to events on this service rather than individual ProximityPrompt objects. */
interface ProximityPromptService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ProximityPromptService: unique symbol;
/**
* This property determines whether [ProximityPrompts](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) are enabled, and therefore shown, in-game. When false, no prompts will be shown.
*
* For example, in a round based system developers could disable prompts at certain points in the game to disable proximity-based interactions.
*
* \-- Server Script 1
* local ProximityPromptService = game:GetService("ProximityPromptService")
* local enablePrompts = workspace.EnablePrompts -- BindableEvent
*
* -- Connected to a BindableEvent that is fired by another script controlling game logic
* enablePrompts.OnServerEvent:Connect(function(enabled)
* ProximityPromptService.Enabled = enabled
* end)\-- Server Script 2
* local enablePrompts = workspace.EnablePrompts -- BindableEvent
*
* -- Some game event
* enablePrompts:FireServer(false) -- Disable
* wait(5)
* enablePrompts:FireServer(true) -- Re-enable
*/
Enabled: boolean;
/**
* This property indicates the maximum number of [ProximityPrompts](https://developer.roblox.com/en-us/api-reference/class/ProximityPrompt) that will be shown to the user.
*
* The code block below demonstrates how this limit would be applied:
*
* local ProximityPromptService = game:GetService("ProximityPromptService")
* ProximityPromptService.MaxPromptsVisible = 2 -- No more than 2 prompts will be shown to the user at any given time
*/
MaxPromptsVisible: number;
/**
* This event triggers when the player begins holding down the [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button on a prompt with a non-zero [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration). This can be used to animate a progress bar.
*/
readonly PromptButtonHoldBegan: RBXScriptSignal<(prompt: ProximityPrompt, playerWhoTriggered: Player) => void>;
/**
* This event triggers when the user stops holding down the [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button on a prompt with a non-zero [ProximityPrompt.HoldDuration](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/HoldDuration). This can be used to animate a progress bar.
*/
readonly PromptButtonHoldEnded: RBXScriptSignal<(prompt: ProximityPrompt, playerWhoTriggered: Player) => void>;
/**
* This event triggers client-side, in connected [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript) when a prompt becomes hidden.
*/
readonly PromptHidden: RBXScriptSignal<(prompt: ProximityPrompt) => void>;
/**
* This event triggers client-side, in connected [LocalScripts](https://developer.roblox.com/en-us/api-reference/class/LocalScript), when a prompt becomes visible.
*/
readonly PromptShown: RBXScriptSignal<(prompt: ProximityPrompt, inputType: Enum.ProximityPromptInputType) => void>;
/**
* This event triggers when the player stops holding down the [key](https://developer.roblox.com/en-us/api-reference/property/ProximityPrompt/KeyboardKeyCode)/button while triggering a prompt. This is intended to allow interactions which require the player to hold a button while something happens in-game.
*/
readonly PromptTriggerEnded: RBXScriptSignal<(prompt: ProximityPrompt, playerWhoTriggered: Player) => void>;
/**
* This event triggers when the player interacts with this prompt.
*/
readonly PromptTriggered: RBXScriptSignal<(prompt: ProximityPrompt, playerWhoTriggered: Player) => void>;
}
interface PublishService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_PublishService: unique symbol;
}
interface ReflectionService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_ReflectionService: unique symbol;
}
interface RemoteCursorService extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RemoteCursorService: unique symbol;
}
interface RemoteDebuggerServer extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RemoteDebuggerServer: unique symbol;
}
/** A server should rarely invoke a client via [InvokeClient()](https://developer.roblox.com/en-us/api-reference/function/RemoteFunction/InvokeClient) as it can be potentially game breaking. For client-only actions that don't require a callback, like updating a GUI, a [server-to-client remote event](#server-to-client-remote-event) should be used instead. If [InvokeClient()](https://developer.roblox.com/en-us/api-reference/function/RemoteFunction/InvokeClient) is used, risks include:
*
* * If the client throws an error, the server will throw the error too.
* * If the client disconnects while it's being invoked, the [InvokeClient()](https://developer.roblox.com/en-us/api-reference/function/RemoteFunction/InvokeClient) call will error.
* * If the client never returns a value, the server will hang forever.
*
* A **RemoteFunction** is used to create in-game APIs that both the client and the server can use to communicate with each other. Like [BindableFunction](https://developer.roblox.com/en-us/api-reference/class/BindableFunction), a RemoteFunction can be invoked (called) to do a certain action and return the results.
*
* If the result is **not** needed, we recommend that you use a [RemoteEvent](https://developer.roblox.com/en-us/api-reference/class/RemoteEvent) instead, since its call is asynchronous and doesn't need to wait for a response to continue execution. See `[Remote Functions and Events](https://developer.roblox.com/articles/Remote-Functions-and-Events)` for more info.
*/
interface RemoteFunction extends Instance {
/**
* **DO NOT USE!**
*
* This field exists to force TypeScript to recognize this as a nominal type
* @hidden
* @deprecated
*/
readonly _nominal_RemoteFunction: unique symbol;
/**
* Calls the method bound to the RemoteFunction by [RemoteFunction.OnClientInvoke](https://developer.roblox.com/en-us/api-reference/property/RemoteFunction/OnClientInvoke) for the given [Player](https://developer.roblox.com/en-us/api-reference/class/Player). Use from a [Script](https://developer.roblox.com/en-us/api-reference/class/Script).
*
* If the result is not needed then it is recommended to use a [RemoteEvent:FireClient](https://developer.roblox.com/en-us/api-reference/function/RemoteEvent/FireClient) instead, as its call is asynchronous and doesn't need to wait for a response to continue execution.
*
* This is used to bind functions to invoke the client when the remote function is invoked by the server. This function is in place to provide a method for communicating between the client and server, which is well documented in [this](https://developer.roblox.com/articles/Remote-Functions-and-Events) article.
*
* To fire from the server to the client, you should use [RemoteFunction:InvokeServer](https://developer.roblox.com/en-us/api-reference/function/RemoteFunction/InvokeServer) and [RemoteFunction.OnServerInvoke](https://developer.roblox.com/en-us/api-reference/property/RemoteFunction/OnServerInvoke).
*
* Note
* ----
*
* In practice, the server does not often invoke the client. Clients typically do not have information the server doesn't have and the actions that only a client can take (displaying a GUI for instance), often do not require a callback. That said, the server invoking clients is still an action that the Roblox engine will support and may be useful in niche situations.
*
* Warning
* -------
*
* If a client disconnects or leaves the game while it is being invoked from the server, the InvokeClient function will error. It is therefore recommended to wrap this function in a pcall so it doesn't stop the execution of other code.
*
* There are limitations on the kinds of data that can be passed between the client and server. For more information, see [Parameter Limitations](https://developer.roblox.com/articles/Remote-Functions-and-Events#parameter-limitations).
*
* Tags: Yields
*/
InvokeClient(this: RemoteFunction, player: Player, ...args: Parameters