Full API List

Built-In
- Anchor
  - location: LocationAsset
  - position: vec3
- AnimatedTextureFileProvider
  - clone(): AnimatedTextureFileProvider
  - duration: number
  - getCurrentPlayingFrame(): number
  - getDuration(): number
  - getFramesCount(): number
  - isAutoplay: boolean
  - isFinished(): boolean
  - isPaused(): boolean
  - isPingPong: boolean
  - isPlaying(): boolean
  - isReversed: boolean
  - pause(): void
  - pauseAtFrame(_frameIndex: number): void
  - play(_loops: number, _offset: number): void
  - playFromFrame(_frameIndex: number, _loops: number): void
  - resume(): void
  - setOnFinish(_{eventCallback:} (_{animatedTexture:} AnimatedTextureFileProvider) => void): void
  - stop(): void
- AnimationAsset
  - addLayer(_layerName: string, _layer: AnimationPropertyLayer): void
  - clearLayers(): void
  - createEvent(_eventName: string, _time: number): AnimationPropertyEventRegistration
  - deleteEvent(_{registration:} AnimationPropertyEventRegistration): void
  - deleteLayer(_layerName: string): void
  - duration: number
  - fps: number
  - getLayer(_layerName: string): AnimationPropertyLayer
- AnimationClip
  - animation: AnimationAsset
  - begin: number
  - blendMode: AnimationLayerBlendMode
  - clone(_clipName: string): AnimationClip
  - create(_clipName: string): AnimationClip
  - createFromAnimation(_clipName: string, _animation: AnimationAsset): AnimationClip
  - disabled: boolean
  - duration: number
  - end: number
  - name: string
  - playbackMode: PlaybackMode
  - playbackSpeed: number
  - reversed: boolean
  - scaleMode: AnimationLayerScaleMode
  - weight: number
- AnimationCurve
  - addKeyframe(_frame: AnimationKeyFrame): void
  - create(): AnimationCurve
  - createEasingCurve(_startValue: number, _endValue: number, _x1: number, _y1: number, _x2: number, _y2: number): AnimationCurve
  - createKeyFrame(): AnimationKeyFrame
  - evaluate(_time: number): number
  - getKeyFrame(_index: number): AnimationKeyFrame
  - keyFrameCount: number
  - removeKeyFrame(_t: number): void
- AnimationCurveTrack
  - evaluateNumber(_time: number): number
  - evaluateRotation(_time: number): quat
  - evaluateVec2(_time: number): vec2
  - evaluateVec3(_time: number): vec3
  - evaluateVec4(_time: number): vec4
  - getProperty(_key: string): AnimationCurve
  - getPropertyKeys(): string[]
  - setProperty(_key: string, _curve: AnimationCurve): void
- AnimationKeyFrame
  - inWeightPoint: vec2
  - leftTangentType: TangentType
  - outWeightPoint: vec2
  - rightTangentType: TangentType
  - time: number
  - value: number
  - weightedMode: WeightedMode
- AnimationLayerBlendMode
  - Additive: number
  - Default: number
- AnimationLayerScaleMode
  - Additive: number
  - Multiply: number
- AnimationPlayer
  - addClip(_clip: AnimationClip): void
  - clips: AnimationClip[]
  - forceUpdate(_deltaTime: number): void
  - getActiveClips(): string[]
  - getClip(_name: string): AnimationClip
  - getClipCurrentTime(_name: string): number
  - getClipEnabled(_name: string): boolean
  - getClipIsPlaying(_name: string): boolean
  - getInactiveClips(): string[]
  - onEvent: event1
  - pauseAll(): void
  - pauseClip(_name: string): void
  - playAll(): void
  - playClipAt(_name: string, _time: number): void
  - removeClip(_name: string): void
  - resumeAll(): void
  - resumeClip(_name: string): void
  - setClipEnabled(_name: string, _enabled: boolean): void
  - stopAll(): void
  - stopClip(_name: string): void
- AnimationPlayerOnEventArgs
  - eventName: string
- AnimationPropertyEventRegistration
- AnimationPropertyLayer
- AnimationTrack
- Asset
  - name: string
- AttachmentPointType
  - CandideCenter: number
  - Chin: number
  - Forehead: number
  - HeadCenter: number
  - LeftCheek: number
  - LeftEyeballCenter: number
  - LeftForehead: number
  - MouthCenter: number
  - RightCheek: number
  - RightEyeballCenter: number
  - RightForehead: number
  - TriangleBarycentric: number
- Audio
  - DistanceCurveType
    - Inverse: number
    - InverseLogarithm: number
    - Linear: number
    - Logarithm: number
  - PlaybackMode
    - LowLatency: number
    - LowPower: number
- AudioComponent
  - audioTrack: AudioTrackAsset
  - duration: number
  - fadeInTime: number
  - fadeOutTime: number
  - isPaused(): boolean
  - isPlaying(): boolean
  - mixToSnap: boolean
  - pause(): boolean
  - play(_loops: number): void
  - playbackMode: Audio.PlaybackMode
  - position: number
  - recordingVolume: number
  - resume(): boolean
  - setOnFinish(_{eventCallback:} (_{audioComponent:} AudioComponent) => void): void
  - spatialAudio: SpatialAudio
  - stop(_fade: boolean): void
  - volume: number
- AudioEffectAsset
- AudioEffectComponent
- AudioEffectProvider
- AudioListenerComponent
- AudioOutputProvider
  - enqueueAudioFrame(_audioFrame: Float32Array, _inShape: vec3): void
  - getPreferredFrameSize(): number
- AudioTrackAsset
  - control: AudioTrackProvider
- AudioTrackProvider
  - maxFrameSize: number
  - sampleRate: number
- Axis
  - X: number
  - Y: number
  - Z: number
- BackgroundSettings
  - cornerRadius: number
  - enabled: boolean
  - fill: TextFill
  - margins: Rect
- Base64
  - decode(_value: string): Uint8Array
  - decodeTextureAsync(_value: string, _onSuccess: (_{decodedTexture:} Texture) => void, _onFailure: () => void): void
  - encode(_data: Uint8Array): string
  - encodeTextureAsync(_texture: Texture, _onSuccess: (_{encodedTexture:} string) => void, _onFailure: () => void, _{compressionQuality:} CompressionQuality, _{encodingType:} EncodingType): void
- BaseMeshVisual
  - extentsTarget: ScreenTransform
  - horizontalAlignment: HorizontalAlignment
  - localAabbMax(): vec3
  - localAabbMin(): vec3
  - meshShadowMode: MeshShadowMode
  - shadowColor: vec4
  - shadowDensity: number
  - snap(_camera: Camera): void
  - stretchMode: StretchMode
  - verticalAlignment: VerticalAlignment
  - worldAabbMax(): vec3
  - worldAabbMin(): vec3
- BaseMultiplayerSessionOptions
  - hostManagementEnabled: boolean
  - onConnected: (_session: MultiplayerSession, _{connectionInfo:} ConnectedLensModule.ConnectionInfo) => void
  - onDisconnected: (_session: MultiplayerSession, _{disconnectInfo:} string) => void
  - onError: (_session: MultiplayerSession, _code: string, _description: string) => void
  - onHostUpdated: (_session: MultiplayerSession, _removalInfo: ConnectedLensModule.HostUpdateInfo) => void
  - onMessageReceived: (_session: MultiplayerSession, _userId: string, _message: string, _senderInfo: ConnectedLensModule.UserInfo) => void
  - onRealtimeStoreCreated: (_session: MultiplayerSession, _store: GeneralDataStore, _ownerInfo: ConnectedLensModule.UserInfo, _{creationInfo:} ConnectedLensModule.RealtimeStoreCreationInfo) => void
  - onRealtimeStoreDeleted: (_session: MultiplayerSession, _store: GeneralDataStore, _deleteInfo: ConnectedLensModule.RealtimeStoreDeleteInfo) => void
  - onRealtimeStoreKeyRemoved: (_session: MultiplayerSession, _removalInfo: ConnectedLensModule.RealtimeStoreKeyRemovalInfo) => void
  - onRealtimeStoreOwnershipUpdated: (_session: MultiplayerSession, _store: GeneralDataStore, _ownerInfo: ConnectedLensModule.UserInfo, _{ownershipUpdateInfo:} ConnectedLensModule.RealtimeStoreOwnershipUpdateInfo) => void
  - onRealtimeStoreUpdated: (_session: MultiplayerSession, _store: GeneralDataStore, _key: string, _updateInfo: ConnectedLensModule.RealtimeStoreUpdateInfo) => void
  - onUserJoinedSession: (_session: MultiplayerSession, _userInfo: ConnectedLensModule.UserInfo) => void
  - onUserLeftSession: (_session: MultiplayerSession, _userInfo: ConnectedLensModule.UserInfo) => void
- BasePlaceholder
  - name: string
  - shape: vec3
  - transformer: Transformer
- BasicTransform
  - getInvertedMatrix(): mat4
  - getMatrix(): mat4
  - getPosition(): vec3
  - getRotation(): quat
  - getScale(): vec3
- BinAsset
- Bitmoji2DOptions
  - create(): Bitmoji2DOptions
  - poseId: string
  - user: SnapchatUser
- Bitmoji2DResource
- Bitmoji3DOptions
  - create(): Bitmoji3DOptions
  - user: SnapchatUser
- Bitmoji3DResource
- BitmojiModule
  - requestBitmoji2DResource(_options: Bitmoji2DOptions, _callback: (_resource: Bitmoji2DResource) => void): void
  - requestBitmoji3DResource(_callback: (_resource: Bitmoji3DResource) => void): void
  - requestBitmoji3DResourceWithOptions(_options: Bitmoji3DOptions, _callback: (_resource: Bitmoji3DResource) => void): void
- BlendMode
  - Add: number
  - AlphaTest: number
  - AlphaToCoverage: number
  - ColoredGlass: number
  - Disabled: number
  - Max: number
  - Min: number
  - Multiply: number
  - Normal: number
  - PremultipliedAlpha: number
  - PremultipliedAlphaAuto: number
  - PremultipliedAlphaHardware: number
  - Screen: number
- Blob
  - bytes(): any
  - size: number
  - text(): any
- BlurNoiseEstimation
- BodyComponent
  - addForce(_force: vec3, _mode: Physics.ForceMode): void
  - addForceAt(_force: vec3, _offset: vec3, _mode: Physics.ForceMode): void
  - addPointConstraint(_target: ColliderComponent, _position: vec3): ConstraintComponent
  - addRelativeForce(_force: vec3, _mode: Physics.ForceMode): void
  - addRelativeForceAt(_force: vec3, _position: vec3, _mode: Physics.ForceMode): void
  - addRelativeTorque(_torque: vec3, _mode: Physics.ForceMode): void
  - addTorque(_torque: vec3, _mode: Physics.ForceMode): void
  - angularDamping: number
  - damping: number
  - density: number
  - dynamic: boolean
  - mass: number
  - removeConstraint(_constraint: ConstraintComponent): void
- BodyDepthTextureProvider
  - bodyIndex: number
  - minimumConfidence: number
  - zFar: number
  - zNear: number
- BodyInstanceSegmentationTextureProvider
  - bodyIndex: number
- BodyNormalsTextureProvider
  - bodyIndex: number
- BodyRenderObjectProvider
  - bodyGeometryEnabled: boolean
  - bodyIndex: number
  - headGeometryEnabled: boolean
  - leftHandGeometryEnabled: boolean
  - rightHandGeometryEnabled: boolean
- BodyTrackingAsset
  - Head: string
  - Hips: string
  - LeftArm: string
  - LeftFoot: string
  - LeftForeArm: string
  - LeftHand: string
  - LeftHandIndex1: string
  - LeftHandIndex2: string
  - LeftHandIndex3: string
  - LeftHandMiddle1: string
  - LeftHandMiddle2: string
  - LeftHandMiddle3: string
  - LeftHandPinky1: string
  - LeftHandPinky2: string
  - LeftHandPinky3: string
  - LeftHandRing1: string
  - LeftHandRing2: string
  - LeftHandRing3: string
  - LeftHandThumb1: string
  - LeftHandThumb2: string
  - LeftHandThumb3: string
  - LeftLeg: string
  - LeftShoulder: string
  - LeftToeBase: string
  - LeftUpLeg: string
  - Neck: string
  - RightArm: string
  - RightFoot: string
  - RightForeArm: string
  - RightHand: string
  - RightHandIndex1: string
  - RightHandIndex2: string
  - RightHandIndex3: string
  - RightHandMiddle1: string
  - RightHandMiddle2: string
  - RightHandMiddle3: string
  - RightHandPinky1: string
  - RightHandPinky2: string
  - RightHandPinky3: string
  - RightHandRing1: string
  - RightHandRing2: string
  - RightHandRing3: string
  - RightHandThumb1: string
  - RightHandThumb2: string
  - RightHandThumb3: string
  - RightLeg: string
  - RightShoulder: string
  - RightToeBase: string
  - RightUpLeg: string
  - Spine: string
  - Spine1: string
  - Spine2: string
  - handTrackingEnabled: boolean
- BoxShape
  - size: vec3
- BrowsLoweredEvent
- BrowsRaisedEvent
- BrowsReturnedToNormalEvent
- Camera
  - aspect: number
  - clearColor: vec4
  - colorRenderTargets: Camera.ColorRenderTarget[]
  - createColorRenderTarget(): Camera.ColorRenderTarget
  - createDepthStencilRenderTarget(): Camera.DepthStencilRenderTarget
  - depthBufferMode: Camera.DepthBufferMode
  - depthStencilRenderTarget: Camera.DepthStencilRenderTarget
  - depthStencilRenderTargetSupported(): boolean
  - devicePropertyUsage: Camera.DeviceProperty
  - enableClearColor: boolean
  - enableClearDepth: boolean
  - far: number
  - fov: number
  - getOrthographicSize(): vec2
  - getSupportedColorRenderTargetCount(): number
  - inputTexture: Texture
  - isSphereVisible(_center: vec3, _radius: number): boolean
  - maskTexture: Texture
  - near: number
  - project(_{worldSpacePoint:} vec3): vec3
  - rayTracing: any
  - renderLayer: LayerSet
  - renderOrder: number
  - renderTarget: Texture
  - renderTargetCubemapFace: Camera.CubemapFace
  - screenSpaceToWorldSpace(_{normalizedScreenSpacePoint:} vec2, _{absoluteDepth:} number): vec3
  - size: number
  - type: Camera.Type
  - unproject(_{clipSpacePoint:} vec3): vec3
  - worldSpaceToScreenSpace(_{worldSpacePoint:} vec3): vec2
- Camera
  - BaseRenderTarget
    - inputTexture: Texture
    - maskTexture: Texture
    - targetTexture: Texture
  - ColorRenderTarget
    - clearColor: vec4
    - clearColorOption: ClearColorOption
  - CubemapFace
    - Back: number
    - Bottom: number
    - Front: number
    - Left: number
    - NegativeX: number
    - NegativeY: number
    - NegativeZ: number
    - PositiveX: number
    - PositiveY: number
    - PositiveZ: number
    - Right: number
    - Top: number
  - DepthBufferMode
    - Logarithmic: number
    - Regular: number
  - DepthStencilRenderTarget
    - clearDepthValue: number
    - clearStencilValue: number
    - depthClearOption: DepthClearOption
    - stencilClearOption: StencilClearOption
  - DeviceProperty
    - All: number
    - Aspect: number
    - Fov: number
    - None: number
  - Type
    - Orthographic: number
    - Perspective: number
- CameraBackEvent
- CameraFrame
  - timestampMillis: number
- CameraFrontEvent
- CameraModule
  - createCameraRequest(): CameraModule.CameraRequest
  - requestCamera(_request: CameraModule.CameraRequest): Texture
- CameraModule
  - CameraId
    - Default_Color: number
    - Left_Color: number
    - Right_Color: number
  - CameraRequest
    - cameraId: CameraModule.CameraId
    - imageSmallerDimension: number
- CameraTextureProvider
  - onNewFrame: event1
- Canvas
  - getSize(): vec2
  - pivot: vec2
  - setSize(_value: vec2): void
  - sortingType: Canvas.SortingType
  - unitType: Canvas.UnitType
  - worldSpaceRect: Rect
- Canvas
  - SortingType
    - Depth: number
    - Hierarchy: number
  - UnitType
    - Pixels: number
    - Points: number
    - World: number
- CapitilizationOverride
  - AllLower: number
  - AllUpper: number
  - None: number
- CapsuleShape
  - axis: Axis
  - length: number
  - radius: number
- ClearColorOption
  - Background: number
  - CustomColor: number
  - CustomTexture: number
  - None: number
- ClearDepth
- ClothVisual
  - addCollider(_{colliderComponent:} ColliderComponent): void
  - bendMode: ClothVisual.BendMode
  - bendStiffness: number
  - bendStiffnessVertexWeight: number
  - clearColliders(): void
  - colliders: ColliderComponent[]
  - createVertexSettings(): VertexSimulationSettings
  - externalBodyMeshWeight: number
  - friction: number
  - frictionVertexWeight: number
  - getAllColors(): vec4[]
  - getPointColorByIndex(_index: number): vec4
  - getPointIndicesByColor(_color: vec4, _colorMask: vec4b): number[]
  - getPointIndicesByMask(_colorMask: vec4b): number[]
  - getVertexBinding(_index: number): SceneObject
  - getVertexSettings(_index: number): VertexSimulationSettings
  - gravity: vec3
  - isHardwareSupported(): boolean
  - isInitialized(): boolean
  - iterationsPerStep: number
  - mass: number
  - massVertexWeight: number
  - maxAcceleration: number
  - mergeCloseVerticesEnabled: boolean
  - mergeCloseVerticesThreshold: number
  - mesh: RenderMesh
  - onInitialized: (_clothVisual: ClothVisual) => void
  - removeColliderByIndex(_index: number): ColliderComponent
  - repulsionEnabled: boolean
  - repulsionFriction: number
  - repulsionOffset: number
  - repulsionStiffness: number
  - resetSimulation(): void
  - setVertexBinding(_index: number, _bindingObj: SceneObject): void
  - setVertexSettings(_index: number, _{vertexSettings:} VertexSimulationSettings): void
  - simulatedMesh: RenderMesh
  - stretchStiffness: number
  - stretchStiffnessVertexWeight: number
  - updateNormalsEnabled: boolean
- ClothVisual
  - BendMode
    - Isometric: number
    - Linear: number
- CloudStorageListOptions
  - create(): CloudStorageListOptions
  - cursor: string
  - scope: StorageScope
- CloudStorageModule
  - getCloudStore(_options: CloudStorageOptions, _{onCloudStoreReady:} (_store: CloudStore) => void, _onError: (_code: string, _description: string) => void): void
- CloudStorageOptions
  - create(): CloudStorageOptions
  - session: MultiplayerSession
- CloudStorageReadOptions
  - create(): CloudStorageReadOptions
  - scope: StorageScope
- CloudStorageWriteOptions
  - create(): CloudStorageWriteOptions
  - scope: StorageScope
- CloudStore
  - deleteValue(_key: string, _readOptions: CloudStorageReadOptions, _onDeleted: () => void, _onError: (_code: string, _description: string) => void): void
  - getValue(_key: string, _readOptions: CloudStorageReadOptions, _onRetrieved: (_key: string, _value: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2) => void, _onError: (_code: string, _description: string) => void): void
  - listValues(_listOptions: CloudStorageListOptions, _onRetrieved: (_values: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2[][], _cursor: string) => void, _onError: (_code: string, _description: string) => void): void
  - setValue(_key: string, _value: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2, _{writeOptions:} CloudStorageWriteOptions, _onSaved: () => void, _onError: (_code: string, _description: string) => void): void
- ColliderComponent
  - angularVelocity: vec3
  - clearMotion(): void
  - debugDrawEnabled: boolean
  - filter: Filter
  - fitVisual: boolean
  - forceCompound: boolean
  - intangible: boolean
  - matter: Matter
  - onCollisionEnter: event1
  - onCollisionExit: event1
  - onCollisionStay: event1
  - onOverlapEnter: event1
  - onOverlapExit: event1
  - onOverlapStay: event1
  - overlapFilter: Filter
  - rotateSmoothFactor: number
  - shape: Shape
  - smooth: boolean
  - translateSmoothFactor: number
  - velocity: vec3
  - worldSettings: Physics.WorldSettingsAsset
- Collision
  - collider: ColliderComponent
  - contactCount: number
  - contacts: Contact[]
  - id: number
- CollisionEnterEventArgs
  - collision: Collision
- CollisionExitEventArgs
  - collision: Collision
- CollisionMesh
- CollisionStayEventArgs
  - collision: Collision
- ColocatedLandmarks2DRenderObjectProvider
- ColocatedLandmarks3DRenderObjectProvider
- ColocatedLandmarksRenderObjectProviderBase
- ColocatedTrackingComponent
  - buildingProgress: number
  - canBuild: boolean
  - canTrack: boolean
  - isBuilding: boolean
  - isJoining: boolean
  - isTracking: boolean
  - join(_session: MultiplayerSession): void
  - onBuildFailed: event0
  - onFound: event0
  - onJoinFailed: event0
  - onLost: event0
  - onTrackingAvailable: event0
  - startBuilding(_session: MultiplayerSession): void
- Colorspace
  - R: number
  - RG: number
  - RGBA: number
- Component
  - destroy(): void
  - enabled: boolean
  - getSceneObject(): SceneObject
  - getTransform(): Transform
  - sceneObject: SceneObject
- CompressionQuality
  - HighQuality: number
  - IntermediateQuality: number
  - LowQuality: number
  - MaximumCompression: number
  - MaximumQuality: number
- ConeShape
  - axis: Axis
  - length: number
  - radius: number
- ConnectedLensEnteredEvent
- ConnectedLensModule
  - createSession(_{sessionOptions:} ConnectedLensSessionOptions): void
  - shareSession(_{sessionShareType:} ConnectedLensModule.SessionShareType, _{onSessionShared:} (_session: MultiplayerSession, _snapcode: Texture) => void): void
- ConnectedLensModule
  - ConnectionInfo
  - HostUpdateInfo
    - sentServerTimeMilliseconds: number
    - userInfo: ConnectedLensModule.UserInfo
  - RealtimeStoreCreationInfo
    - allowOwnershipTakeOver: boolean
    - lastUpdatedServerTimestamp: number
    - ownerInfo: ConnectedLensModule.UserInfo
    - persistence: RealtimeStoreCreateOptions.Persistence
    - sentServerTimeMilliseconds: number
    - storeId: string
  - RealtimeStoreDeleteInfo
    - deleterInfo: ConnectedLensModule.UserInfo
    - sentServerTimeMilliseconds: number
  - RealtimeStoreKeyRemovalInfo
    - key: string
    - removerInfo: ConnectedLensModule.UserInfo
    - sentServerTimeMilliseconds: number
    - store: GeneralDataStore
  - RealtimeStoreOwnershipUpdateInfo
    - sentServerTimeMilliseconds: number
  - RealtimeStoreUpdateInfo
    - sentServerTimeMilliseconds: number
    - updaterInfo: ConnectedLensModule.UserInfo
  - SessionShareType
    - Invitation: number
    - Snapcode: number
  - UserInfo
    - connectionId: string
    - displayName: string
    - joinServerTimeMilliseconds: number
    - userId: string
- ConnectedLensSessionOptions
  - create(): ConnectedLensSessionOptions
  - maxNumberOfInvitations: number
  - onSessionCreated: (_session: MultiplayerSession, _{sessionCreationType:} ConnectedLensSessionOptions.SessionCreationType) => void
- ConnectedLensSessionOptions
  - SessionCreationType
    - MultiplayerReceiver: number
    - New: number
    - NewSoloMode: number
- Constraint
  - constraintType: Physics.ConstraintType
- ConstraintComponent
  - constraint: Constraint
  - debugDrawEnabled: boolean
  - reanchorTarget(): void
  - target: ColliderComponent
- Contact
  - distance: number
  - impulse: number
  - normal: vec3
  - position: vec3
- CropTextureProvider
  - inputTexture: Texture
- CullMode
  - Back: number
  - Front: number
  - FrontAndBack: number
- CylinderShape
  - axis: Axis
  - length: number
  - radius: number
- DeformingCollisionMesh
- Delay
  - maxTensorSize: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- DelayBuilder
  - build(): Delay
  - setDelay(_delay: number): DelayBuilder
  - setNumFeatures(_numFeatures: number): DelayBuilder
- DelayedCallbackEvent
  - cancel(): void
  - getDelayTime(): number
  - getTimeLeft(): number
  - reset(_time: number): void
- Delta
  - maxTensorSize: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- DeltaBuilder
  - build(): Delta
  - setNumFeatures(_numFeatures: number): DeltaBuilder
  - setWindowSize(_winSize: number): DeltaBuilder
- DepthClearOption
  - CustomTexture: number
  - CustomValue: number
  - None: number
- DepthSetter
- DepthStencilRenderTargetProvider
  - clearDepthValue: number
  - clearStencilValue: number
  - depthClearOption: DepthClearOption
  - inputTexture: Texture
  - maskTexture: Texture
  - resolution: vec2
  - stencilClearOption: StencilClearOption
- DepthTextureProvider
  - sampleDepthAtPoint(_point: vec2): number
- DeviceCamera
  - focalLength: vec2
  - pose: mat4
  - principalPoint: vec2
  - project(_{pointInDeviceReferenceNode:} vec3): vec2
  - resolution: vec2
  - unproject(_{normalizedScreenSpacePoint:} vec2, _{absoluteDepth:} number): vec3
- DeviceInfoSystem
  - getOS(): OS
  - getTrackingCamera(): DeviceCamera
  - getTrackingCameraForId(_cameraId: CameraModule.CameraId): DeviceCamera
  - isDesktop(): boolean
  - isEditor(): boolean
  - isMobile(): boolean
  - isSpectacles(): boolean
  - screenScale: number
  - supportsDualCamera(_callback: (_{supportsDualCamera:} boolean) => void): void
- DeviceLocationTrackingComponent
  - distanceToLocation: number
  - isTracking(): boolean
  - location: LocationAsset
  - locationProximityStatus: LocationProximityStatus
  - onLocationDataDownloadFailed: () => void
  - onLocationDataDownloaded: () => void
  - onLocationFound: () => void
  - onLocationLost: () => void
- DeviceTracking
  - calculateWorldMeshHistogram(_center: vec3, _radius: number): TrackedMeshHistogramResult
  - createTrackedWorldPoint(_worldPos: vec3, _worldRot: quat): TrackedPoint
  - getActualDeviceTrackingMode(): DeviceTrackingMode
  - getDevicePath(): BasicTransform[]
  - getDevicePathIndex(): number
  - getPointCloud(): PointCloud
  - getRequestedDeviceTrackingMode(): DeviceTrackingMode
  - hitTestWorldMesh(_screenPos: vec2): TrackedMeshHitTestResult[]
  - isDeviceTrackingModeSupported(_mode: DeviceTrackingMode): boolean
  - raycastWorldMesh(_from: vec3, _to: vec3): TrackedMeshHitTestResult[]
  - requestDeviceTrackingMode(_val: DeviceTrackingMode): void
  - resetTracking(_position: vec2): void
  - rotationOptions: RotationOptions
  - setWorldOriginOffset(_offset: vec3): void
  - surfaceOptions: SurfaceOptions
  - surfaceTrackingTarget: SceneObject
  - worldOptions: WorldOptions
  - worldTrackingCapabilities: WorldTrackingCapabilities
- DeviceTrackingMode
  - Rotation: number
  - Surface: number
  - World: number
- DeviceTrackingModule
- Dialog
  - Answer
    - answer: string
    - questionId: number
    - status: number
- DialogModule
  - askQuestions(_context: string, _questions: string[], _{onQuestionsAnswerComplete:} (_answers: Dialog.Answer[]) => void, _{onQuestionsAnswerError:} (_error: number, _description: string) => void): void
- DirectMultiplayerSessionOptions
- DirectivityEffect
  - enabled: boolean
  - shapeDecay: number
  - shapeFactor: number
- DistanceEffect
  - enabled: boolean
  - maxDistance: number
  - minDistance: number
  - type: Audio.DistanceCurveType
- DomainInfo
  - assetType: string
  - description: string
  - name: string
  - states: StateInfo[]
- DropshadowSettings
  - enabled: boolean
  - fill: TextFill
  - offset: vec2
- DynamicResource
- EncodingType
  - Jpg: number
  - Png: number
- EventRegistration
- Expressions
  - BrowsDownLeft: string
  - BrowsDownRight: string
  - BrowsUpCenter: string
  - BrowsUpLeft: string
  - BrowsUpRight: string
  - CheekSquintLeft: string
  - CheekSquintRight: string
  - EyeBlinkLeft: string
  - EyeBlinkRight: string
  - EyeDownLeft: string
  - EyeDownRight: string
  - EyeInLeft: string
  - EyeInRight: string
  - EyeOpenLeft: string
  - EyeOpenRight: string
  - EyeOutLeft: string
  - EyeOutRight: string
  - EyeSquintLeft: string
  - EyeSquintRight: string
  - EyeUpLeft: string
  - EyeUpRight: string
  - JawForward: string
  - JawLeft: string
  - JawOpen: string
  - JawRight: string
  - LipsFunnel: string
  - LipsPucker: string
  - LowerLipClose: string
  - LowerLipDownLeft: string
  - LowerLipDownRight: string
  - LowerLipRaise: string
  - MouthClose: string
  - MouthDimpleLeft: string
  - MouthDimpleRight: string
  - MouthFrownLeft: string
  - MouthFrownRight: string
  - MouthLeft: string
  - MouthRight: string
  - MouthSmileLeft: string
  - MouthSmileRight: string
  - MouthStretchLeft: string
  - MouthStretchRight: string
  - MouthUpLeft: string
  - MouthUpRight: string
  - Puff: string
  - SneerLeft: string
  - SneerRight: string
  - UpperLipClose: string
  - UpperLipRaise: string
  - UpperLipUpLeft: string
  - UpperLipUpRight: string
- ExternalMusicInfo
  - isSameTrack(_other: ExternalMusicInfo): boolean
- ExternalMusicModule
  - getExternalMusicInfo(): ExternalMusicInfo
  - getLyricsTracker(): LyricsTracker
  - isTrackSet: boolean
  - onTrackChanged: event1
  - onTrackRemoved: event0
  - onTrackStarted: event1
  - onTrackStopped: event0
- EyeColorVisual
  - faceIndex: number
- FaceCropTextureProvider
  - faceCenterMouthWeight: number
  - faceIndex: number
  - textureScale: vec2
- FaceFoundEvent
- FaceInsetRegion
  - Face: number
  - LeftEye: number
  - Mouth: number
  - Nose: number
  - RightEye: number
- FaceInsetVisual
  - faceIndex: number
  - faceRegion: FaceInsetRegion
  - flipX: boolean
  - flipY: boolean
  - innerBorderRadius: number
  - outerBorderRadius: number
  - sourceScale: vec2
  - subdivisionsCount: number
- FaceLostEvent
- FaceMaskVisual
  - customMaskOnMouthClosed: Texture
  - faceIndex: number
  - hidesMaskOnMouthClosed: boolean
  - originalFaceIndex: number
  - swapsMaskOnMouthClosed: boolean
  - teethAlpha: number
  - useOriginalTexCoords: boolean
- FaceRenderObjectProvider
  - earGeometryEnabled: boolean
  - eyeCornerGeometryEnabled: boolean
  - eyeGeometryEnabled: boolean
  - faceGeometryEnabled: boolean
  - faceIndex: number
  - getExpressionNames(): string[]
  - getExpressionWeightByName(_{expressionName:} string): number
  - getExpressionWeights(): Float32Array
  - mouthGeometryEnabled: boolean
  - skullGeometryEnabled: boolean
- FaceStretchVisual
  - faceIndex: number
  - getFeatureWeight(_feature: string): number
  - setFeatureWeight(_feature: string, _intensity: number): void
- FaceTextureProvider
  - faceIndex: number
  - inputTexture: Texture
  - scale: vec2
- FaceTrackingEvent
  - faceIndex: number
- FileAudioTrackProvider
  - duration: number
  - getAudioBuffer(_audioBuffer: Float32Array, _readSize: number): vec3
  - getAudioFrame(_audioFrame: Float32Array): vec3
  - loops: number
  - position: number
- FileLicensedSoundProvider
  - duration: number
  - getAudioBuffer(_audioBuffer: Float32Array, _readSize: number): vec3
  - getAudioFrame(_audioFrame: Float32Array): vec3
  - loops: number
- FileTextureProvider
- Filter
  - includeDynamic: boolean
  - includeIntangible: boolean
  - includeStatic: boolean
  - onlyColliders: ColliderComponent[]
  - onlyLayers: LayerSet
  - skipColliders: ColliderComponent[]
  - skipLayers: LayerSet
- FilteringMode
  - Bilinear: number
  - Nearest: number
  - Trilinear: number
- FixedCollisionMesh
- FixedConstraint
- FocusEndEventArgs
- FocusStartEventArgs
- Font
- FrustumCullMode
  - Auto: number
  - Extend: number
  - UserDefinedAABB: number
- GaussianSplattingAsset
  - getNumberOfFrames(): number
- GaussianSplattingVisual
  - activeFrame: number
  - asset: GaussianSplattingAsset
  - autoPlay: boolean
  - fps: number
  - isPlaying(): boolean
  - pause(): void
  - play(): void
- GeneralDataStore
  - clear(): void
  - create(): GeneralDataStore
  - getAllKeys(): string[]
  - getBool(_key: string): boolean
  - getBoolArray(_key: string): boolean[]
  - getDouble(_key: string): number
  - getFloat(_key: string): number
  - getFloat32Array(_key: string): Float32Array
  - getFloat64Array(_key: string): any
  - getFloatArray(_key: string): number[]
  - getInt(_key: string): number
  - getInt16Array(_key: string): any
  - getInt32Array(_key: string): any
  - getInt8Array(_key: string): any
  - getIntArray(_key: string): number[]
  - getMat2(_key: string): mat2
  - getMat2Array(_key: string): mat2[]
  - getMat3(_key: string): mat3
  - getMat3Array(_key: string): mat3[]
  - getMat4(_key: string): mat4
  - getMat4Array(_key: string): mat4[]
  - getMaxSizeInBytes(): number
  - getQuat(_key: string): quat
  - getQuatArray(_key: string): quat[]
  - getSizeInBytes(): number
  - getString(_key: string): string
  - getStringArray(_key: string): string[]
  - getUint16Array(_key: string): Uint16Array
  - getUint32Array(_key: string): Uint32Array
  - getUint8Array(_key: string): Uint8Array
  - getVec2(_key: string): vec2
  - getVec2Array(_key: string): vec2[]
  - getVec3(_key: string): vec3
  - getVec3Array(_key: string): vec3[]
  - getVec4(_key: string): vec4
  - getVec4Array(_key: string): vec4[]
  - has(_key: string): boolean
  - onStoreFull: () => void
  - putBool(_key: string, _value: boolean): void
  - putBoolArray(_key: string, _value: boolean[]): void
  - putDouble(_key: string, _value: number): void
  - putFloat(_key: string, _value: number): void
  - putFloat32Array(_key: string, _value: Float32Array): void
  - putFloat64Array(_key: string, _value: any): void
  - putFloatArray(_key: string, _value: number[]): void
  - putInt(_key: string, _value: number): void
  - putInt16Array(_key: string, _value: any): void
  - putInt32Array(_key: string, _value: any): void
  - putInt8Array(_key: string, _value: any): void
  - putIntArray(_key: string, _value: number[]): void
  - putMat2(_key: string, _value: mat2): void
  - putMat2Array(_key: string, _value: mat2[]): void
  - putMat3(_key: string, _value: mat3): void
  - putMat3Array(_key: string, _value: mat3[]): void
  - putMat4(_key: string, _value: mat4): void
  - putMat4Array(_key: string, _value: mat4[]): void
  - putQuat(_key: string, _value: quat): void
  - putQuatArray(_key: string, _value: quat[]): void
  - putString(_key: string, _value: string): void
  - putStringArray(_key: string, _value: string[]): void
  - putUint16Array(_key: string, _value: Uint16Array): void
  - putUint32Array(_key: string, _value: Uint32Array): void
  - putUint8Array(_key: string, _value: Uint8Array): void
  - putVec2(_key: string, _value: vec2): void
  - putVec2Array(_key: string, _value: vec2[]): void
  - putVec3(_key: string, _value: vec3): void
  - putVec3Array(_key: string, _value: vec3[]): void
  - putVec4(_key: string, _value: vec4): void
  - putVec4Array(_key: string, _value: vec4[]): void
  - remove(_key: string): void
- GeoLocation
  - createLocationService(): LocationService
  - getNorthAlignedHeading(_{northAlignedOrientation:} quat): number
- GeoLocationAccuracy
  - High: number
  - Low: number
  - Medium: number
  - Navigation: number
- GeoPosition
  - create(): GeoPosition
  - heading: number
  - horizontalAccuracy: number
  - isHeadingAvailable: boolean
  - latitude: number
  - longitude: number
  - verticalAccuracy: number
- GestureModule
  - getPalmTapDownEvent(_handType: GestureModule.HandType): event1
  - getPalmTapUpEvent(_handType: GestureModule.HandType): event1
  - getPinchDownEvent(_handType: GestureModule.HandType): event1
  - getPinchStrengthEvent(_handType: GestureModule.HandType): event1
  - getPinchUpEvent(_handType: GestureModule.HandType): event1
  - getTargetingDataEvent(_handType: GestureModule.HandType): event1
- GestureModule
  - HandType
    - Left: number
    - Right: number
- GltfAsset
  - extras: string
  - tryInstantiate(_parent: SceneObject, _material: Material): SceneObject
  - tryInstantiateWithSetting(_parent: SceneObject, _material: Material, _{gltfSettings:} GltfSettings): SceneObject
- GltfSettings
  - convertMetersToCentimeters: boolean
  - create(): GltfSettings
  - optimizeGeometry: boolean
  - storeTriangleOrder: boolean
- HairDataAsset
- HairVisual
  - addCollider(_{colliderComponent:} ColliderComponent): void
  - clearColliders(): void
  - clumpDensity: number
  - clumpRadius: number
  - clumpTipScale: number
  - colliders: ColliderComponent[]
  - collisionEnabled: boolean
  - collisionFriction: number
  - collisionOffset: number
  - collisionStiffness: number
  - damp: number
  - density: number
  - fallbackModeEnabled: boolean
  - friction: number
  - gravity: vec3
  - hairMaterial: Material
  - hairResolution: number
  - isHardwareSupported(): boolean
  - isInitialized(): boolean
  - noise: number
  - onInitialized: (_hairVisual: HairVisual) => void
  - removeColliderByIndex(_index: number): ColliderComponent
  - resetSimulation(): void
  - selfCollisionEnabled: boolean
  - selfCollisionFriction: number
  - selfCollisionRadius: number
  - selfCollisionStiffness: number
  - stiffness: number
  - strandTaper: number
  - strandWidth: number
  - windEnabled: boolean
  - windForce: vec3
- HandSpecificData
- HandTracking3DAsset
- HapticFeedbackSystem
  - hapticFeedback(_type: HapticFeedbackType): void
- HapticFeedbackType
  - TapticEngine: number
  - Vibration: number
- Head
  - faceIndex: number
  - getFacesCount(): number
  - getLandmark(_index: number): vec2
  - getLandmarkCount(): number
  - getLandmarks(): vec2[]
  - setAttachmentPointType(_{attachmentPointType:} AttachmentPointType): void
- Headers
  - append(_name: string, _value: string): void
  - delete(_name: string): void
  - entries(): string[][]
  - get(_name: string): string
  - has(_name: string): boolean
  - keys(): string[]
  - set(_name: string, _value: string): void
  - values(): string[]
- HingeConstraint
  - limitSettings: HingeLimitSettings
  - motorSettings: HingeMotorSettings
- HingeLimitSettings
  - bias: number
  - enabled: boolean
  - high: number
  - low: number
  - relaxation: number
- HingeMotorSettings
  - enabled: boolean
  - maxImpulse: number
  - targetType: HingeMotorType
  - targetValue: number
- HingeMotorType
  - AngleTarget: number
  - VelocityTarget: number
- HintsComponent
  - hideHint(_hintID: string): boolean
  - showHint(_hintID: string, _duration: number): boolean
- HitTestSession
  - hitTest(_rayStart: vec3, _rayEnd: vec3, _hitCallback: (_hit: WorldQueryHitTestResult) => void): void
  - reset(): void
  - start(): void
  - stop(): void
- HitTestSessionOptions
  - create(): HitTestSessionOptions
  - filter: boolean
- HorizontalAlignment
  - Center: number
  - Left: number
  - Right: number
- HorizontalOverflow
  - Ellipsis: number
  - Overflow: number
  - Shrink: number
  - Truncate: number
  - Wrap: number
- HoverEvent
  - getHoverPosition(): vec2
- IEventParameters
- Image
  - flipX: boolean
  - flipY: boolean
  - pivot: vec2
  - rotationAngle: number
- InputBuilder
  - build(): InputPlaceholder
  - setInputTexture(_texture: Texture): InputBuilder
  - setName(_name: string): InputBuilder
  - setSampler(_sampler: Sampler): InputBuilder
  - setShape(_shape: vec3): InputBuilder
  - setTransformer(_transformer: Transformer): InputBuilder
- InputPlaceholder
  - data: Float32Array
  - texture: Texture
- InteractionComponent
  - addMeshVisual(_meshVisual: BaseMeshVisual): void
  - addTouchBlockingException(_exception: string): void
  - getMinimumTouchSize(): number
  - isFilteredByDepth: boolean
  - isFocused: boolean
  - isSelected: boolean
  - onFocusEnd: event1
  - onFocusStart: event1
  - onSelectEnd: event1
  - onSelectStart: event1
  - onTap: event1
  - onTouchEnd: event1
  - onTouchMove: event1
  - onTouchStart: event1
  - onTriggerPrimary: event1
  - removeMeshVisual(_meshVisual: BaseMeshVisual): void
  - setCamera(_camera: Camera): void
  - setMinimumTouchSize(_value: number): void
- KissFinishedEvent
- KissStartedEvent
- LateUpdateEvent
  - getDeltaTime(): number
- LayerSet
  - contains(_other: LayerSet): boolean
  - except(_other: LayerSet): LayerSet
  - fromNumber(_layerId: number): LayerSet
  - intersect(_other: LayerSet): LayerSet
  - isEmpty(): boolean
  - makeUnique(): LayerSet
  - numbers: number[]
  - toString(): string
  - union(_other: LayerSet): LayerSet
- Leaderboard
  - getLeaderboardInfo(_options: Leaderboard.RetrievalOptions, _{successCallback:} (_othersInfo: Leaderboard.UserRecord[], _{currentUserInfo:} Leaderboard.UserRecord) => void, _{failureCallback:} (_status: number) => void): void
  - name: string
  - orderingType: Leaderboard.OrderingType
  - submitScore(_score: number, _{successCallback:} (_{currentUserInfo:} Leaderboard.UserRecord) => void, _{failureCallback:} (_status: number) => void): void
  - ttlSeconds: number
- Leaderboard
  - CreateOptions
    - name: string
    - orderingType: Leaderboard.OrderingType
    - ttlSeconds: number
    - create(): Leaderboard.CreateOptions
  - OrderingType
    - Ascending: number
    - Descending: number
  - RetrievalOptions
    - usersLimit: number
    - usersType: Leaderboard.UsersType
    - create(): Leaderboard.RetrievalOptions
  - UserRecord
    - globalExactRank: number
    - globalRankPercentile: number
    - score: number
    - snapchatUser: SnapchatUser
  - UsersType
    - Friends: number
    - Global: number
- LeaderboardModule
  - getLeaderboard(_options: Leaderboard.CreateOptions, _{successCallback:} (_leaderboard: Leaderboard) => void, _{failureCallback:} (_message: string) => void): void
- LevelsetColliderAsset
- LevelsetShape
  - asset: LevelsetColliderAsset
- LicensedAudioTrackAsset
- LightSource
  - autoLightSourcePosition: boolean
  - autoShadowFrustumSize: boolean
  - castsShadows: boolean
  - color: vec3
  - diffuseEnvmapTexture: Texture
  - envmapExposure: number
  - envmapRotation: number
  - intensity: number
  - renderLayer: LayerSet
  - shadowBlurRadius: number
  - shadowColor: vec4
  - shadowDensity: number
  - shadowFrustumFarClipPlane: number
  - shadowFrustumNearClipPlane: number
  - shadowFrustumSize: number
  - specularEnvmapTexture: Texture
  - useEnvmap: boolean
- LiquifyVisual
  - intensity: number
  - radius: number
- LoadStatus
  - Idle: number
  - Loaded: number
  - Loading: number
- LocalizationSystem
  - getDateAndTimeFormatted(_date: Date): string
  - getDateFormatted(_date: Date): string
  - getDateShortFormatted(_date: Date): string
  - getDayOfWeek(_date: Date): string
  - getFormattedDistanceFromMeters(_meters: number): string
  - getFormattedNumber(_number: number): string
  - getFormattedSeconds(_seconds: number): string
  - getFormattedTemperatureFromCelsius(_temperature: number): string
  - getFormattedTemperatureFromFahrenheit(_temperature: number): string
  - getLanguage(): string
  - getMonth(_date: Date): string
  - getTimeFormatted(_date: Date): string
  - language: string
  - localize(_key: string): string
- LocalizationsAsset
- LocatedAtComponent
  - createMappingOptions(): MappingOptions
  - createMappingSession(_options: MappingOptions): MappingSession
  - distanceToLocation: number
  - location: LocationAsset
  - onCanTrack: event0
  - onCannotTrack: event0
  - onError: event0
  - onFound: event0
  - onLost: event0
  - onReady: event0
  - position: vec3
  - proximityStatus: LocationProximityStatus
- LocationAsset
  - adjacentTile(_xOffset: number, _yOffset: number, _zoomOffset: number): LocationAsset
  - getAROrigin(): LocationAsset
  - getGeoAnchoredPosition(_longitude: number, _latitude: number): Anchor
  - getNearby(_xOffset: number, _yOffset: number, _zoomOffset: number): LocationAsset
  - getProxy(_proxyId: string): LocationAsset
  - getProxyId(): string
- LocationCloudStorageModule
  - getNearbyLocationStores(_options: LocationCloudStorageOptions): void
  - retrieveLocation(_{persistedLocationId:} string, _{onRetrievedLocation:} (_location: LocationAsset) => void, _onError: (_error: string) => void): void
  - session: MultiplayerSession
  - storeLocation(_location: LocationAsset, _{onStoredLocation:} (_{persistedLocationId:} string) => void, _onError: (_error: string) => void): void
- LocationCloudStorageOptions
  - collection: string
  - create(): LocationCloudStorageOptions
  - location: LocationAsset
  - onDiscoveredNearby: event2
  - onError: event3
- LocationCloudStore
  - deleteValue(_key: string, _readOptions: CloudStorageReadOptions, _onDeleted: () => void, _onError: (_code: string, _description: string) => void): void
  - getValue(_key: string, _readOptions: CloudStorageReadOptions, _onRetrieved: (_key: string, _value: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2, _collection: string) => void, _onError: (_code: string, _description: string) => void): void
  - listValues(_listOptions: CloudStorageListOptions, _onRetrieved: (_values: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2[][], _cursor: string, _collection: string) => void, _onError: (_code: string, _description: string) => void): void
  - setValue(_key: string, _value: string|number|boolean|vec4|vec3|quat|mat4|vec2|mat3|mat2, _{writeOptions:} CloudStorageWriteOptions, _onSaved: () => void, _onError: (_code: string, _description: string) => void): void
- LocationProximityStatus
  - OutOfRange: number
  - Unknown: number
  - WithinRange: number
- LocationRenderObjectProvider
  - create(): RenderMesh
  - location: LocationAsset
  - onLocationDataDownloadFailed: event0
  - onLocationDataDownloaded: event0
- LocationService
  - accuracy: GeoLocationAccuracy
  - getCurrentPosition(_onSucess: (_geoPosition: GeoPosition) => void, _onError: (_error: string) => void): void
  - onNorthAlignedOrientationUpdate: event1
- LocationTextureProvider
  - create(): Texture
  - location: LocationAsset
- LookAtComponent
  - aimVectors: LookAtComponent.AimVectors
  - lookAtMode: LookAtComponent.LookAtMode
  - offsetRotation: quat
  - target: SceneObject
  - worldUpVector: LookAtComponent.WorldUpVector
- LookAtComponent
  - AimVectors
    - NegativeXAimNegativeYUp: number
    - NegativeXAimNegativeZUp: number
    - NegativeXAimYUp: number
    - NegativeXAimZUp: number
    - NegativeYAimNegativeXUp: number
    - NegativeYAimNegativeZUp: number
    - NegativeYAimXUp: number
    - NegativeYAimZUp: number
    - NegativeZAimNegativeXUp: number
    - NegativeZAimNegativeYUp: number
    - NegativeZAimXUp: number
    - NegativeZAimYUp: number
    - XAimNegativeYUp: number
    - XAimNegativeZUp: number
    - XAimYUp: number
    - XAimZUp: number
    - YAimNegativeXUp: number
    - YAimNegativeZUp: number
    - YAimXUp: number
    - YAimZUp: number
    - ZAimNegativeXUp: number
    - ZAimNegativeYUp: number
    - ZAimXUp: number
    - ZAimYUp: number
  - LookAtMode
    - LookAtDirection: number
    - LookAtPoint: number
  - WorldUpVector
    - ObjectX: number
    - ObjectY: number
    - ObjectZ: number
    - SceneX: number
    - SceneY: number
    - SceneZ: number
    - TargetX: number
    - TargetY: number
    - TargetZ: number
- Lyrics
  - clipDuration: number
  - lines: LyricsLine[]
  - type: LyricsType
- LyricsLine
  - fullLineText: string
  - offset: number
  - offsetEnd: number
  - syncs: LyricsSync[]
- LyricsSync
  - duration: number
  - offset: number
  - offsetEnd: number
  - text: string
- LyricsTracker
  - currentLine: LyricsLine
  - fullLyrics: Lyrics
  - isPlaying: boolean
  - nextLine: LyricsLine
  - onLineEnd: event1
  - onLineStart: event1
  - onLyricsAvailable: event0
  - onLyricsCleared: event0
  - onPlaybackReset: event0
  - onPlaybackStarted: event1
  - onWordEnd: event1
  - onWordStart: event1
  - playbackPosition: number
- LyricsType
  - LineSync: number
  - RichSync: number
  - Unset: number
- MFCC
  - maxTensorSize: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- MFCCBuilder
  - build(): MFCC
  - setFFTSize(_fftSize: number): MFCCBuilder
  - setFrameSize(_frameSize: number): MFCCBuilder
  - setHopSize(_hopSize: number): MFCCBuilder
  - setLifter(_lifter: number): MFCCBuilder
  - setMaxFreq(_maxFreq: number): MFCCBuilder
  - setMinFreq(_minFreq: number): MFCCBuilder
  - setNumMFCC(_numMFCC: number): MFCCBuilder
  - setNumMel(_numMel: number): MFCCBuilder
  - setSampleRate(_sampleRate: number): MFCCBuilder
- MLAsset
  - getMetadata(): object
- MLComponent
  - autoRun: boolean
  - build(_{placeholders:} BasePlaceholder[]): void
  - cancel(): void
  - getInput(_name: string): InputPlaceholder
  - getInputs(): InputPlaceholder[]
  - getOutput(_name: string): OutputPlaceholder
  - getOutputs(): OutputPlaceholder[]
  - getScheduledEnd(): MachineLearning.FrameTiming
  - getScheduledStart(): MachineLearning.FrameTiming
  - inferenceMode: MachineLearning.InferenceMode
  - isRecurring(): boolean
  - model: MLAsset
  - onLoadingFinished: () => void
  - onRunningFinished: () => void
  - renderOrder: number
  - runImmediate(_sync: boolean): void
  - runScheduled(_recurring: boolean, _startTiming: MachineLearning.FrameTiming, _endTiming: MachineLearning.FrameTiming): void
  - state: MachineLearning.ModelState
  - stop(): void
  - waitOnLoading(): void
  - waitOnRunning(): void
- MachineLearning
  - createDelayBuilder(): DelayBuilder
  - createDeltaBuilder(): DeltaBuilder
  - createInputBuilder(): InputBuilder
  - createMFCCBuilder(): MFCCBuilder
  - createMelSpectrogramBuilder(): MelSpectrogramBuilder
  - createNoiseReductionBuilder(): NoiseReductionBuilder
  - createOutputBuilder(): OutputBuilder
  - createPitchShifterBuilder(): PitchShifterBuilder
  - createSamplerBuilder(): SamplerBuilder
  - createSpectrogramBuilder(): SpectrogramBuilder
  - createTransformerBuilder(): TransformerBuilder
- MachineLearning
  - FrameTiming
    - LateUpdate: number
    - None: number
    - OnRender: number
    - Update: number
  - InferenceMode
    - Accelerator: number
    - Auto: number
    - CPU: number
    - GPU: number
  - ModelState
    - Idle: number
    - Loading: number
    - NotReady: number
    - Running: number
  - OutputMode
    - Data: number
    - Texture: number
- ManipulateComponent
  - clampWorldPosition(): void
  - enableManipulateType(_type: ManipulateType, _enable: boolean): void
  - intersectManipulateFrame(_{screenSpacePoint:} vec2): ManipulateFrameIntersectResult
  - isContextualSwivel: boolean
  - isManipulateTypeEnabled(_type: ManipulateType): boolean
  - isManipulating: boolean
  - maxDistance: number
  - maxHeight: number
  - maxScale: number
  - minDistance: number
  - minHeight: number
  - minScale: number
  - onManipulateEnd: event1
  - onManipulateStart: event1
  - rotationScale: number
- ManipulateEndEvent
- ManipulateEndEventArgs
- ManipulateFrameIntersectResult
  - getIntersectionPoint(): vec3
  - isValid(): boolean
- ManipulateStartEvent
- ManipulateStartEventArgs
- ManipulateType
  - Drag: number
  - Scale: number
  - Swivel: number
- MapModule
  - createMapTextureProvider(): Texture
  - longLatToImageRatio(_longitude: number, _latitude: number, _location: LocationAsset): vec2
- MapTextureProvider
  - location: LocationAsset
  - onFailed: event0
  - onReady: event0
- MappingOptions
  - location: LocationAsset
  - locationCloudStorageModule: LocationCloudStorageModule
  - policy: string
- MappingSession
  - canCheckpoint: boolean
  - cancel(): void
  - capacityUsed: number
  - checkpoint(): void
  - handheldMaximumSize: number
  - handheldMinimumSize: number
  - onCapacityUsedAtLimit: event0
  - onMapped: event1
  - onQualityAcceptable: event0
  - quality: number
  - throttling: MappingSession.MappingThrottling
  - wearableAcceptableRawCapacity: number
  - wearableAllowEarlyCheckpoint: boolean
  - wearableMaximumSize: number
  - wearableMinimumSize: number
- MappingSession
  - MappingThrottling
    - Auto: number
    - Background: number
    - Foreground: number
    - Off: number
- MarkerAsset
  - getAspectRatio(): number
  - height: number
- MarkerProvider
- MarkerTrackingComponent
  - autoEnableWhenTracking: boolean
  - isTracking(): boolean
  - marker: MarkerAsset
  - onMarkerFound: () => void
  - onMarkerLost: () => void
- MaskingComponent
  - cornerRadius: number
- Material
  - clone(): Material
  - getPass(_index: number): Pass
  - getPassCount(): number
  - mainPass: Pass
- MaterialMeshVisual
  - addMaterial(_material: Material): void
  - clearMaterials(): void
  - getMaterial(_index: number): Material
  - getMaterialsCount(): number
  - mainMaterial: Material
  - mainPass: Pass
  - materials: Material[]
- MathUtils
  - DegToRad: number
  - RadToDeg: number
  - clamp(_v: number, _lo: number, _hi: number): number
  - lerp(_a: number, _b: number, _time: number): number
  - randomRange(_lo: number, _hi: number): number
  - remap(_v: number, _inMin: number, _inMax: number, _outMin: number, _outMax: number): number
- Matter
  - dynamicBounciness: number
  - friction: number
  - rollingFriction: number
  - spinningFriction: number
  - staticBounciness: number
- MediaPickerTextureProvider
  - autoShowMediaPicker: boolean
  - cropFace: boolean
  - faceImageControl: FaceTextureProvider
  - hideMediaPicker(): void
  - imageControl: TextureProvider
  - isContentReady: boolean
  - isFaceImagePickingEnabled: boolean
  - isImagePickingEnabled: boolean
  - isVideoPickingEnabled: boolean
  - setFaceMeshReadyCallback(_callback: () => void): void
  - setFilePickedCallback(_callback: () => void): void
  - showMediaPicker(): void
  - videoControl: VideoTextureProvider
- MelSpectrogram
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- MelSpectrogramBuilder
  - build(): MelSpectrogram
  - setFFTSize(_fftSize: number): MelSpectrogramBuilder
  - setFrameSize(_frameSize: number): MelSpectrogramBuilder
  - setHopSize(_hopSize: number): MelSpectrogramBuilder
  - setMaxFreq(_maxFreq: number): MelSpectrogramBuilder
  - setMinFreq(_minFreq: number): MelSpectrogramBuilder
  - setNumMel(_numMel: number): MelSpectrogramBuilder
  - setSampleRate(_sampleRate: number): MelSpectrogramBuilder
- MeshBuilder
  - appendIndices(_indices: number[]): void
  - appendVertices(_verts: number[][]): void
  - appendVerticesInterleaved(_verts: number[]): void
  - createFromMesh(_mesh: RenderMesh): MeshBuilder
  - eraseIndices(_from: number, _to: number): void
  - eraseVertices(_from: number, _to: number): void
  - getIndicesCount(): number
  - getMesh(): RenderMesh
  - getVerticesCount(): number
  - indexType: MeshIndexType
  - isValid(): boolean
  - setBones(_bones: string[], _{inverseMatrices:} mat4[]): void
  - setVertexInterleaved(_index: number, _verts: number[]): void
  - topology: MeshTopology
  - updateMesh(): void
- MeshClassificationFormat
  - None: number
  - PerVertexFast: number
- MeshIndexType
  - None: number
  - UInt16: number
- MeshRenderObjectProvider
- MeshShadowMode
  - Caster: number
  - None: number
  - Receiver: number
- MeshShape
  - convex: boolean
  - mesh: RenderMesh
  - skin: Skin
- MeshTopology
  - LineStrip: number
  - Lines: number
  - Points: number
  - TriangleFan: number
  - TriangleStrip: number
  - Triangles: number
- MeshVisual
- MicrophoneAudioProvider
  - getAudioFrame(_audioFrame: Float32Array): vec3
  - start(): void
  - stop(): void
- MotionController
  - getMotionState(): MotionController.MotionType
  - getTouchpadPhysicalSize(): vec2
  - getTouchpadPointSize(): vec2
  - getTrackingQuality(): MotionController.TrackingQuality
  - getWorldPosition(): vec3
  - getWorldRotation(): quat
  - invokeHaptic(_{hapticRequest:} MotionController.HapticRequest): void
  - isControllerAvailable(): boolean
  - onControllerStateChange: event1
  - onMotionTypeChange: event1
  - onTouchEvent: event4
  - onTouchpadSizeChange: event2
  - onTrackingQualityChange: event1
  - onTransformEvent: event2
  - options: MotionController.MotionControllerOptions
- MotionController
  - HapticFeedback
    - Default: number
    - Error: number
    - Select: number
    - Success: number
    - Tick: number
    - VibrationHigh: number
    - VibrationLow: number
    - VibrationMedium: number
  - HapticRequest
    - duration: number
    - hapticFeedback: MotionController.HapticFeedback
    - create(): MotionController.HapticRequest
  - MotionControllerOptions
    - controllerId: string
    - motionType: MotionController.MotionType
  - MotionType
    - NoMotion: number
    - SixDoF: number
    - ThreeDoF: number
  - Options
    - create(): MotionController.MotionControllerOptions
  - TouchPhase
    - Began: number
    - Canceled: number
    - Ended: number
    - Moved: number
  - TrackingQuality
    - Limited: number
    - Normal: number
    - Unknown: number
- MotionControllerModule
  - getController(_options: MotionController.MotionControllerOptions): MotionController
- MouthClosedEvent
- MouthOpenedEvent
- MultiplayerSession
  - activeUserCount: number
  - activeUsersInfo: ConnectedLensModule.UserInfo[]
  - allRealtimeStores: GeneralDataStore[]
  - clearRealtimeStoreOwnership(_store: GeneralDataStore, _onSuccess: (_store: GeneralDataStore) => void, _onError: (_message: string) => void): void
  - createRealtimeStore(_options: RealtimeStoreCreateOptions, _onSuccess: (_store: GeneralDataStore) => void, _onError: (_message: string) => void): void
  - deleteRealtimeStore(_store: GeneralDataStore, _onSuccess: (_store: GeneralDataStore) => void, _onError: (_message: string) => void): void
  - getLocalUserId(_{localUserIdCallback:} (_userId: string) => void): void
  - getLocalUserInfo(_{localUserInfoCallback:} (_userInfo: ConnectedLensModule.UserInfo) => void): void
  - getRealtimeStoreInfo(_store: GeneralDataStore): ConnectedLensModule.RealtimeStoreCreationInfo
  - getServerTimestamp(): number
  - requestRealtimeStoreOwnership(_store: GeneralDataStore, _onSuccess: (_store: GeneralDataStore) => void, _onError: (_message: string) => void): void
  - sendMessage(_message: string): void
  - sendMessageWithTimeout(_message: string, _timeoutMs: number): void
- NativePlaneTrackingType
  - Both: number
  - Horizontal: number
  - None: number
  - Vertical: number
- NoiseReduction
  - amount: number
  - maxTensorSize: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- NoiseReductionBuilder
  - build(): NoiseReduction
  - setSampleRate(_sampleRate: number): NoiseReductionBuilder
- OS
  - Android: number
  - MacOS: number
  - Windows: number
  - iOS: number
- Object3DAsset
- ObjectPrefab
  - instantiate(_parent: SceneObject): SceneObject
  - instantiateAsync(_parent: SceneObject, _onSuccess: (_sceneObject: SceneObject) => void, _onFailure: (_error: string) => void, _onProgress: (_progress: number) => void): void
- ObjectSpecificData
- ObjectTracking
  - autoEnableWhenTracking: boolean
  - isTracking(): boolean
  - objectIndex: number
  - objectSpecificData: ObjectSpecificData
  - onObjectFound: () => void
  - onObjectLost: () => void
  - registerDescriptorEnd(_descriptor: string, _callback: (_descriptor: string) => void): void
  - registerDescriptorStart(_descriptor: string, _callback: (_descriptor: string) => void): void
- ObjectTracking3D
  - addAttachmentPoint(_name: string, _object: SceneObject): void
  - attachmentModeInheritRotation: boolean
  - attachmentModeInheritScale: boolean
  - createAttachmentPoint(_name: string): SceneObject
  - getAttachedObjects(_name: string): SceneObject[]
  - isAttachmentPointTracking(_name: string): boolean
  - isTracking(): boolean
  - objectIndex: number
  - objectSpecificData: ObjectSpecificData
  - onTrackingLost: () => void
  - onTrackingStarted: () => void
  - removeAttachmentPoint(_object: SceneObject): void
  - trackPosition: boolean
  - trackingAsset: Object3DAsset
  - trackingMode: ObjectTracking3D.TrackingMode
- ObjectTracking3D
  - TrackingMode
    - Attachment: number
    - PoseOnly: number
    - ProportionsAndPose: number
- ObjectTrackingMaskedTextureProvider
  - objectIndex: number
- ObjectTrackingNormalsTextureProvider
- ObjectTrackingTextureProvider
- OnAwakeEvent
- OnDestroyEvent
- OnDisableEvent
- OnEnableEvent
- OnStartEvent
- OutlineSettings
  - enabled: boolean
  - fill: TextFill
  - size: number
- OutputBuilder
  - build(): OutputPlaceholder
  - setName(_name: string): OutputBuilder
  - setOutputMode(_outputMode: MachineLearning.OutputMode): OutputBuilder
  - setTransformer(_transformer: Transformer): OutputBuilder
- OutputPlaceholder
  - data: Float32Array
  - mode: MachineLearning.OutputMode
  - texture: Texture
- Overlap
  - collider: ColliderComponent
  - id: number
- OverlapEnterEventArgs
  - currentOverlapCount: number
  - currentOverlaps: Overlap[]
  - overlap: Overlap
- OverlapExitEventArgs
  - currentOverlapCount: number
  - currentOverlaps: Overlap[]
  - overlap: Overlap
- OverlapStayEventArgs
  - currentOverlapCount: number
  - currentOverlaps: Overlap[]
  - overlap: Overlap
- PalmTapDownArgs
  - confidence: number
- PalmTapUpArgs
  - confidence: number
- Pass
  - baseColor: vec4
  - baseTex: Texture
  - blendMode: BlendMode
  - colorMask: vec4b
  - cullMode: CullMode
  - depthTest: boolean
  - depthWrite: boolean
  - frustumCullMax: vec3
  - frustumCullMin: vec3
  - frustumCullMode: FrustumCullMode
  - frustumCullPad: number
  - instanceCount: number
  - lineWidth: number
  - name: string
  - polygonOffset: vec2
  - samplers: SamplerWrappers
  - stencilState: StencilState
  - twoSided: boolean
- PassWrapper
  - blendMode: BlendMode
  - colorMask: vec4b
  - cullMode: CullMode
  - depthTest: boolean
  - depthWrite: boolean
  - instanceCount: number
  - lineWidth: number
  - name: string
  - polygonOffset: vec2
  - samplers: SamplerWrappers
  - twoSided: boolean
- PassWrappers
  - allPasses: PassWrapper[]
- PersistentStorageSystem
  - store: GeneralDataStore
- Physics
  - createGlobalProbe(): Probe
  - createRootProbe(): Probe
  - getRootWorldSettings(): Physics.WorldSettingsAsset
- Physics
  - Constraint
    - create(_type: Physics.ConstraintType): Physics.Constraint
  - ConstraintType
    - Fixed: number
    - Hinge: number
    - Point: number
  - Filter
    - create(): Physics.Filter
  - ForceMode
    - Acceleration: number
    - Force: number
    - Impulse: number
    - VelocityChange: number
  - WorldSettingsAsset
    - absoluteSpeedLimit: number
    - defaultFilter: Physics.Filter
    - defaultMatter: Matter
    - gravity: vec3
    - relativeSpeedLimit: number
    - simulationRate: number
    - slowDownStep: number
    - slowDownTime: number
    - create(): Physics.WorldSettingsAsset
    - getLayersCollidable(_{layerNumberA:} number, _{layerNumberB:} number): boolean
    - resetLayerCollisionMatrix(): void
    - setLayersCollidable(_{layerNumberA:} number, _{layerNumberB:} number, _enable: boolean): void
- PinToMeshComponent
  - offsetPosition: vec3
  - offsetRotation: vec3
  - orientation: PinToMeshComponent.Orientation
  - pinUV: vec2
  - preferredTriangle: number
  - preferredUVLayerIndex: number
  - target: BaseMeshVisual
  - useInterpolatedVertexNormal: boolean
- PinToMeshComponent
  - Orientation
    - OnlyPosition: number
    - PositionAndDirection: number
- PinchDownArgs
  - palmOrientation: vec3
- PinchStrengthArgs
  - strength: number
- PinchUpArgs
  - palmOrientation: vec3
- PitchShifter
  - maxTensorSize: number
  - pitch: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- PitchShifterBuilder
  - build(): PitchShifter
  - setSampleRate(_sampleRate: number): PitchShifterBuilder
- PlaybackMode
  - Loop: number
  - PingPong: number
  - Single: number
- PointCloud
  - confidences: number[]
  - ids: number[]
  - positions: vec3[]
- PointConstraint
- PositionEffect
  - enabled: boolean
- PostEffectVisual
- Probe
  - debugDrawEnabled: boolean
  - filter: Filter
  - rayCast(_start: vec3, _end: vec3, _hitCB: (_hit: RayCastHit) => void): void
  - rayCastAll(_start: vec3, _end: vec3, _hitCB: (_hit: RayCastHit[]) => void): void
  - shapeCast(_shape: Shape, _start: vec3, _startRot: quat, _end: vec3, _endRot: quat, _hitCB: (_hit: RayCastHit) => void): void
  - shapeCastAll(_shape: Shape, _start: vec3, _startRot: quat, _end: vec3, _endRot: quat, _hitCB: (_hit: RayCastHit[]) => void): void
  - sphereCast(_radius: number, _start: vec3, _end: vec3, _hitCB: (_hit: RayCastHit) => void): void
  - sphereCastAll(_radius: number, _start: vec3, _end: vec3, _hitCB: (_hit: RayCastHit[]) => void): void
- ProceduralMeshRenderObjectProvider
- ProceduralTextureProvider
  - create(_width: number, _height: number, _colorspace: Colorspace): Texture
  - createFromTexture(_texture: Texture): Texture
  - getPixels(_x: number, _y: number, _width: number, _height: number, _data: Uint8Array): void
  - setPixels(_x: number, _y: number, _width: number, _height: number, _data: Uint8Array): void
- ProcessedLocationModule
- Properties
- PropertyOnEventArgs
- Provider
  - getLoadStatus(): LoadStatus
- RawLocationModule
- RayCastHit
  - collider: ColliderComponent
  - distance: number
  - normal: vec3
  - position: vec3
  - skipRemaining: boolean
  - t: number
  - triangle: TriangleHit
- RealtimeStoreCreateOptions
  - allowOwnershipTakeOver: boolean
  - create(): RealtimeStoreCreateOptions
  - initialStore: GeneralDataStore
  - ownership: RealtimeStoreCreateOptions.Ownership
  - persistence: RealtimeStoreCreateOptions.Persistence
  - storeId: string
- RealtimeStoreCreateOptions
  - Ownership
    - Owned: number
    - Unowned: number
  - Persistence
    - Ephemeral: number
    - Owner: number
    - Persist: number
    - Session: number
- Rect
  - bottom: number
  - create(_left: number, _right: number, _bottom: number, _top: number): Rect
  - getCenter(): vec2
  - getSize(): vec2
  - left: number
  - right: number
  - setCenter(_value: vec2): void
  - setSize(_value: vec2): void
  - toString(): string
  - top: number
- RectCropTextureProvider
  - cropRect: Rect
  - rotation: number
- RectangleSetter
  - cropTexture: Texture
- RemoteApiRequest
  - body: string|number[]|Uint8Array
  - create(): RemoteApiRequest
  - endpoint: string
  - parameters: object
- RemoteApiResponse
  - asResource(): DynamicResource
  - body: string
  - metadata: object
  - statusCode: number
  - uriResources: DynamicResource[]
- RemoteMediaModule
  - loadResourceAsAudioTrackAsset(_resource: DynamicResource, _onSuccess: (_glTFAsset: AudioTrackAsset) => void, _onFailure: (_{errorMessage:} string) => void): void
  - loadResourceAsGltfAsset(_resource: DynamicResource, _onSuccess: (_glTFAsset: GltfAsset) => void, _onFailure: (_{errorMessage:} string) => void): void
  - loadResourceAsImageTexture(_resource: DynamicResource, _onSuccess: (_texture: Texture) => void, _onFailure: (_{errorMessage:} string) => void): void
  - loadResourceAsVideoTexture(_resource: DynamicResource, _onSuccess: (_texture: Texture) => void, _onFailure: (_{errorMessage:} string) => void): void
- RemoteReferenceAsset
  - downloadAsset(_{onDownloaded:} (_asset: Asset) => void, _onFailed: () => void): void
- RemoteServiceHttpRequest
  - body: string|number[]|Uint8Array
  - contentType: string
  - create(): RemoteServiceHttpRequest
  - getHeader(_name: string): string
  - headers: object
  - method: RemoteServiceHttpRequest.HttpRequestMethod
  - setHeader(_name: string, _value: string): void
  - url: string
- RemoteServiceHttpRequest
  - HttpRequestMethod
    - Delete: number
    - Get: number
    - Post: number
    - Put: number
- RemoteServiceHttpResponse
  - asResource(): DynamicResource
  - body: string
  - contentType: string
  - getHeader(_name: string): string
  - headers: object
  - statusCode: number
- RemoteServiceModule
  - createWebSocket(_url: string): WebSocket
  - createWebView(_options: WebViewOptions, _onSuccess: (_texture: Texture) => void, _onFailure: (_{errorMessage:} string) => void): void
  - createWebViewOptions(_resolution: vec2): WebViewOptions
  - fetch(_request: string|Request, _options: any): Promise
  - makeResourceFromUrl(_mediaUrl: string): DynamicResource
  - performApiRequest(_request: RemoteApiRequest, _{onApiResponse:} (_response: RemoteApiResponse) => void): void
  - performHttpRequest(_{requestOptions:} RemoteServiceHttpRequest, _{onHttpResponse:} (_response: RemoteServiceHttpResponse) => void): void
  - subscribeApiRequest(_request: RemoteApiRequest, _{onApiResponse:} (_response: RemoteApiResponse) => void): string
- RenderMesh
  - aabbMax: vec3
  - aabbMin: vec3
  - control: RenderObjectProvider
  - extractBoneInverseMatrices(): mat4[]
  - extractBoneNames(): string[]
  - extractIndices(): number[]
  - extractVerticesForAttribute(_{attributeName:} string): number[]
  - indexType: MeshIndexType
  - topology: MeshTopology
- RenderMeshVisual
  - blendNormals: boolean
  - blendShapesEnabled: boolean
  - clearBlendShapeWeights(): void
  - emitter: boolean
  - getBlendShapeNames(): string[]
  - getBlendShapeWeight(_name: string): number
  - hasBlendShapeWeight(_name: string): boolean
  - mesh: RenderMesh
  - receiver: boolean
  - setBlendShapeWeight(_name: string, _weight: number): void
  - setSkin(_value: Skin): void
  - unsetBlendShapeWeight(_name: string): void
- RenderObjectProvider
- RenderTargetProvider
  - clearColor: vec4
  - clearColorEnabled: boolean
  - clearColorOption: ClearColorOption
  - clearDepthEnabled: boolean
  - inputTexture: Texture
  - resolution: vec2
  - resolutionScale: number
  - textureType: RenderTargetProvider.TextureType
  - useScreenResolution: boolean
- RenderTargetProvider
  - TextureType
    - Texture2D: number
    - TextureCubemap: number
- Request
  - bodyUsed: boolean
  - bytes(): any
  - headers: Headers
  - json(): any
  - method: string
  - redirect: string
  - text(): any
  - url: string
- Response
  - bodyUsed: boolean
  - bytes(): any
  - headers: Headers
  - json(): any
  - ok: boolean
  - status: number
  - statusText: string
  - text(): any
  - url: string
- RetouchVisual
  - eyeSharpeningEnabled: boolean
  - eyeWhiteningEnabled: boolean
  - eyeWhiteningIntensity: number
  - faceIndex: number
  - isAuto(): boolean
  - sharpenEyeIntensity: number
  - softSkinEnabled: boolean
  - softSkinIntensity: number
  - teethWhiteningEnabled: boolean
  - teethWhiteningIntensity: number
- ReverseCameraTextureProvider
- RotatedRect
  - angle: number
  - center: vec2
  - create(_center: vec2, _size: vec2, _angle: number): RotatedRect
  - size: vec2
  - toString(): string
- RotationOptions
  - invertRotation: boolean
- Sampler
- SamplerBuilder
  - build(): Sampler
  - setBorderColor(_borderColor: vec4): SamplerBuilder
  - setFilteringMode(_{filteringMode:} FilteringMode): SamplerBuilder
  - setUseMipmaps(_value: boolean): SamplerBuilder
  - setWrapMode(_wrapMode: WrapMode): SamplerBuilder
  - setWrapUMode(_wrapMode: WrapMode): SamplerBuilder
  - setWrapVMode(_wrapMode: WrapMode): SamplerBuilder
  - setWrapWMode(_wrapMode: WrapMode): SamplerBuilder
- SamplerWrapper
  - filtering: FilteringMode
  - texture: Texture
  - wrap: WrapMode
  - wrapU: WrapMode
  - wrapV: WrapMode
  - wrapW: WrapMode
- SamplerWrappers
- ScanModule
  - scan(_contexts: string[], _{scanComplete:} (_resultJson: string) => void, _scanFailed: (_{failureMessage:} string) => void): void
  - scanTarget: Texture
- ScanModule
  - Contexts
    - Cars: string
    - Objects: string
    - Places: string
- SceneEvent
  - bind(_evCallback: (_arg1: this) => void): void
  - enabled: boolean
  - getTypeName(): string
- SceneObject
  - children: SceneObject[]
  - copyComponent(_component: K): K
  - copySceneObject(_sceneObject: SceneObject): SceneObject
  - copyWholeHierarchy(_sceneObject: SceneObject): SceneObject
  - createComponent(_typeName: K): ComponentNameMap[K]
  - destroy(): void
  - enabled: boolean
  - getChild(_index: number): SceneObject
  - getChildrenCount(): number
  - getComponent(_{componentType:} K): ComponentNameMap[K]
  - getComponents(_{componentType:} K): ComponentNameMap[K][]
  - getParent(): SceneObject
  - getTransform(): Transform
  - hasParent(): boolean
  - isEnabledInHierarchy: boolean
  - layer: LayerSet
  - name: string
  - onDisabled: event0
  - onEnabled: event0
  - removeParent(): void
  - setParent(_newParent: SceneObject): void
  - setParentPreserveWorldTransform(_newParent: SceneObject): void
- SceneObjectEvent
  - getSceneObject(): SceneObject
- ScreenRegionComponent
  - region: ScreenRegionType
- ScreenRegionType
  - Capture: number
  - FullFrame: number
  - Preview: number
  - RoundButton: number
  - SafeRender: number
- ScreenTextureProvider
- ScreenTransform
  - anchors: Rect
  - containsLocalPoint(_localPoint: vec2): boolean
  - containsScreenPoint(_screenPoint: vec2): boolean
  - containsWorldPoint(_worldPoint: vec3): boolean
  - enableDebugRendering: boolean
  - isInScreenHierarchy(): boolean
  - localPointToScreenPoint(_{relativeLocalPoint:} vec2): vec2
  - localPointToWorldPoint(_{relativeLocalPoint:} vec2): vec3
  - offsets: Rect
  - pivot: vec2
  - position: vec3
  - rotation: quat
  - scale: vec3
  - screenPointToLocalPoint(_screenPoint: vec2): vec2
  - screenPointToParentPoint(_screenPoint: vec2): vec2
  - worldPointToLocalPoint(_worldPoint: vec3): vec2
  - worldPointToParentPoint(_worldPoint: vec3): vec2
- ScriptAsset
- ScriptComponent
  - createEvent(_eventType: K): EventNameMap[K]
  - removeEvent(_event: SceneEvent): void
- ScriptObject
  - getTypeName(): string
  - isOfType(_type: string): boolean
  - isSame(_other: ScriptObject): boolean
- ScriptScene
  - captureTarget: Texture
  - createDepthStencilRenderTargetTexture(): Texture
  - createRenderTargetTexture(): Texture
  - createSceneObject(_name: string): SceneObject
  - getCameraType(): string
  - getRootObject(_index: number): SceneObject
  - getRootObjectsCount(): number
  - isRayTracingSupported: boolean
  - isRecording(): boolean
  - liveOverlayTarget: Texture
  - liveTarget: Texture
- SegmentationModel
- SegmentationTextureProvider
  - onMaskPercentageUpdated: event1
- SelectEndEventArgs
- SelectStartEventArgs
- SerializableWithUID
  - uniqueIdentifier: string
- Shape
  - createBoxShape(): BoxShape
  - createCapsuleShape(): CapsuleShape
  - createConeShape(): ConeShape
  - createCylinderShape(): CylinderShape
  - createLevelsetShape(): LevelsetShape
  - createMeshShape(): MeshShape
  - createSphereShape(): SphereShape
- ShoppingModule
  - domains: DomainInfo[]
  - loadingStarted(): any
  - onError: event2
  - onProductStateUpdate: event1
- Skin
  - clearBones(): void
  - getSkinBone(_boneName: string): SceneObject
  - getSkinBoneNames(): string[]
  - setSkinBone(_boneName: string, _bone: SceneObject): void
- SmileFinishedEvent
- SmileStartedEvent
- SnapImageCaptureEvent
- SnapRecordStartEvent
- SnapRecordStopEvent
- SnapchatFriendUserInfo
  - friendshipStart: Date
  - lastInteractionTime: Date
- SnapchatUser
  - birthday: SnapchatUserBirthday
  - displayName: string
  - friendInfo: SnapchatFriendUserInfo
  - hasBitmoji: boolean
  - userName: string
  - zodiac: Zodiac
- SnapchatUserBirthday
  - day: number
  - month: number
- SnapcodeMarkerProvider
- SortOrder
  - Ascending: number
  - Descending: number
- SpatialAudio
  - directivityEffect: DirectivityEffect
  - distanceEffect: DistanceEffect
  - enabled: boolean
  - positionEffect: PositionEffect
- SpectaclesHandSpecificData
- Spectrogram
  - maxTensorSize: number
  - process(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): vec3
- SpectrogramBuilder
  - build(): Spectrogram
  - setFFTSize(_fftSize: number): SpectrogramBuilder
  - setFrameSize(_frameSize: number): SpectrogramBuilder
  - setHopSize(_hopSize: number): SpectrogramBuilder
- SphereShape
  - radius: number
- SplineComponent
- SpriteAligner
  - bindingPoint: vec2
  - size: vec2
- StateInfo
  - description: string
  - name: string
- StencilClearOption
  - CustomTexture: number
  - CustomValue: number
  - None: number
- StencilFace
  - Back: number
  - Front: number
  - FrontAndBack: number
- StencilFunction
  - Always: number
  - Equal: number
  - Greater: number
  - GreaterEqual: number
  - Less: number
  - LessEqual: number
  - Never: number
  - NotEqual: number
- StencilOperation
  - DecrementClamp: number
  - DecrementWrap: number
  - IncrementClamp: number
  - IncrementWrap: number
  - Invert: number
  - Keep: number
  - Replace: number
  - Zero: number
- StencilState
  - depthFailureOperation: StencilOperation
  - depthStencilPassOperation: StencilOperation
  - enabled: boolean
  - face: StencilFace
  - readMask: number
  - referenceValue: number
  - stencilCompareFunction: StencilFunction
  - stencilFailureOperation: StencilOperation
  - writeMask: number
- StorageOptions
  - create(): StorageOptions
  - scope: StorageScope
- StorageScope
  - Session: number
  - User: number
- StretchMode
  - Fill: number
  - FillAndCut: number
  - Fit: number
  - FitHeight: number
  - FitWidth: number
  - Stretch: number
- Studio
  - log(_message: any): void
- SurfaceOptions
  - enhanceWithNativeAR: boolean
- SurfaceTrackingResetEvent
- TangentType
  - Broken: number
  - Clamped: number
  - Const: number
  - Free: number
  - Linear: number
- TapEvent
- TapEventArgs
  - position: vec2
- TargetingDataArgs
  - handIntendsToTarget: boolean
  - isValid: boolean
  - rayDirectionInWorld: vec3
  - rayOriginInWorld: vec3
- TensorMath
  - addScalar(_inTensor: Float32Array, _scalar: number, _outTensor: Float32Array): void
  - addTensors(_inTensorA: Float32Array, _inShapeA: vec3, _inTensorB: Float32Array, _inShapeB: vec3, _outTensor: Float32Array): void
  - amplitudeToDb(_inTensor: Float32Array, _outTensor: Float32Array): void
  - applyBoxFilter(_inTensor: Float32Array, _inShape: vec3, _kernelSize: vec2, _anchor: vec2, _normalize: boolean, _borderType: TensorMath.BorderType, _outTensor: Float32Array): void
  - applyNMS(_inTensor: Float32Array, _inShape: vec3, _scores: Float32Array, _{scoreThreshold:} number, _{iouThreshold:} number, _outTensor: Uint32Array): number
  - applyThreshold(_inTensor: Float32Array, _threshold: number, _maxValue: number, _type: TensorMath.ThresholdMethod, _outTensor: Float32Array): void
  - approximatePolygonalCurve(_inTensor: Float32Array, _inShape: vec3, _epsilon: number, _closed: boolean, _outTensor: Float32Array): number
  - argMax(_inTensor: Float32Array, _inShape: vec3, _outTensor: Uint32Array): void
  - argSort(_inTensor: Float32Array, _shape: vec3, _axis: number, _outTensor: Uint32Array): void
  - argSortMasked(_inTensor: Float32Array, _mask: Float32Array, _outTensor: Uint32Array, _order: SortOrder): number
  - clamp(_inTensor: Float32Array, _minVal: number, _maxVal: number, _outTensor: Float32Array): void
  - concat(_inTensorA: Float32Array, _inShapeA: vec3, _inTensorB: Float32Array, _inShapeB: vec3, _axis: number, _outTensor: Float32Array): void
  - dilate(_inTensor: Float32Array, _inShape: vec3, _{kernelTensor:} Float32Array, _kernelShape: vec3, _anchor: vec2, _iterations: number, _borderType: TensorMath.BorderType, _borderValue: vec4, _outTensor: Float32Array): void
  - divTensors(_inTensorA: Float32Array, _inShapeA: vec3, _inTensorB: Float32Array, _inShapeB: vec3, _outTensor: Float32Array): void
  - drawLine(_imgTensor: Float32Array, _imgShape: vec3, _point1: vec2, _point2: vec2, _color: vec4, _thickness: number, _lineType: number, _shift: number): void
  - erode(_inTensor: Float32Array, _inShape: vec3, _{kernelTensor:} Float32Array, _kernelShape: vec3, _anchor: vec2, _iterations: number, _borderType: TensorMath.BorderType, _borderValue: vec4, _outTensor: Float32Array): void
  - fillConvexPoly(_imgTensor: Float32Array, _imgShape: vec3, _{pointsTensor:} any, _pointsShape: vec3, _color: vec4, _lineType: number, _shift: number): void
  - fillPoly(_imgTensor: Float32Array, _imgShape: vec3, _{polygonsTensors:} any[], _color: vec4, _lineType: number, _shift: number, _offset: vec2): void
  - findContours(_inTensor: Uint8Array, _inShape: vec3, _mode: number, _method: number, _offset: vec2, _outTensor: any): number[]
  - findMinDistancesBetween(_from: Float32Array, _fromShape: vec3, _to: Float32Array, _toShape: vec3, _output: Float32Array): void
  - getContour(_{grayscaledTexture:} Float32Array, _{textureShape:} vec3, _threshold: number, _winSize: number, _{maxNearCount:} number, _outTensor: Float32Array): number
  - getRotatedRectPoints(_rotatedRect: RotatedRect, _outTensor: Float32Array): void
  - getVectorsLength(_vectors: Float32Array, _{vectorsShape:} vec3, _output: Float32Array): void
  - isInRectangle(_points: Float32Array, _pointsShape: vec3, _rect: Rect, _output: Uint8Array): void
  - max(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): void
  - maxDistanceBetweenPoints(_points: Float32Array, _pointsShape: vec3): number
  - maxInSlideWindow(_tensor: Float32Array, _tensorShape: vec3, _window: vec3, _output: Uint32Array): void
  - min(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): void
  - minAreaRect(_inTensor: Float32Array, _inShape: vec3): RotatedRect
  - minInSlideWindow(_tensor: Float32Array, _tensorShape: vec3, _window: vec3, _output: Uint32Array): void
  - mulMatToPoints(_{pointsTensor:} Float32Array, _pointsShape: vec3, _matrix: mat4, _outTensor: Float32Array): void
  - mulScalar(_inTensor: Float32Array, _scalar: number, _outTensor: Float32Array): void
  - mulTensors(_inTensorA: Float32Array, _inShapeA: vec3, _inTensorB: Float32Array, _inShapeB: vec3, _outTensor: Float32Array): void
  - opticalFlow(_{prevGrayscale:} Uint8Array, _grayscale: Uint8Array, _{textureShape:} vec3, _prevPoints: Float32Array, _points: Float32Array, _pointsShape: vec3, _winSize: vec2, _maxLevel: number, _maxCount: number, _epsilon: number): void
  - permute(_inTensor: Float32Array, _inShape: vec3, _permuteAxis: vec3, _outTensor: Float32Array): void
  - polarSort2d(_inTensor: Float32Array, _tensorShape: vec3, _center: vec2): void
  - power(_inTensor: Float32Array, _val: number, _outTensor: Float32Array): void
  - powerToDb(_inTensor: Float32Array, _topDb: number, _outTensor: Float32Array): void
  - projectPoints(_{pointsTensor:} Float32Array, _pointsShape: vec3, _{projectionMatrix:} mat4, _outTensor: Float32Array): void
  - repeat(_inTensor: Float32Array, _inShape: vec3, _axis: vec3, _outTensor: Float32Array): void
  - rotatePoints3d(_points: Float32Array, _pointsShape: vec3, _rotation: quat, _outPoints: Float32Array): void
  - smoothPoints(_inTensor: Float32Array, _tensorShape: vec3, _step: number, _outTensor: Float32Array): void
  - softArgMax(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array, _normalized: boolean): void
  - softMax(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array): void
  - solvePnP(_{inObjectPoints:} Float32Array, _{inImagePoints:} Float32Array, _{imagePointsShape:} vec3, _transform: mat3, _flags: number, _outRotTrans: Float32Array): boolean
  - solvePnPExtended(_{inObjectPoints:} Float32Array, _{inImagePoints:} Float32Array, _{imagePointsShape:} vec3, _{cameraIntrinsicsMatrix:} mat3, _{distortionCoeff:} Float32Array, _{distortionCoeffShape:} vec3, _{useExtrinsicGuess:} boolean, _flags: number, _outRotTrans: Float32Array): boolean
  - solvePnPRansac(_{inObjectPoints:} Float32Array, _{inImagePoints:} Float32Array, _{imagePointsShape:} vec3, _{cameraIntrinsicsMatrix:} mat3, _{distortionCoeff:} Float32Array, _{distortionCoeffShape:} vec3, _{useExtrinsicGuess:} boolean, _{iterationsCount:} number, _{reprojectionError:} number, _confidence: number, _flags: number, _outInliers: Uint8Array, _outRotTrans: Float32Array): boolean
  - subTensors(_inTensorA: Float32Array, _inShapeA: vec3, _inTensorB: Float32Array, _inShapeB: vec3, _outTensor: Float32Array): void
  - subpixelArgMax(_inTensor: Float32Array, _inShape: vec3, _outTensor: Float32Array, _kernelSize: number): void
  - sum(_inTensor: Float32Array, _inShape: vec3, _axis: vec3, _outTensor: Float32Array): void
  - textureToGrayscale(_texture: Texture, _{grayscaleBuffer:} Uint8Array, _{grayscaleBufferShape:} vec3): void
- TensorMath
  - BorderType
    - Constant: number
    - Reflect: number
    - Reflect101: number
    - Replicate: number
  - ThresholdMethod
    - Binary: number
    - BinaryInv: number
    - ToZero: number
    - ToZeroInv: number
    - Trunc: number
- Text
  - backgroundSettings: BackgroundSettings
  - capitilizationOverride: CapitilizationOverride
  - colorMask: vec4b
  - depthTest: boolean
  - dropshadowSettings: DropshadowSettings
  - editable: boolean
  - font: Font
  - horizontalOverflow: HorizontalOverflow
  - letterSpacing: number
  - lineSpacing: number
  - onEditingFinished: event1
  - onEditingStarted: event0
  - onEditingUpdated: event1
  - outlineSettings: OutlineSettings
  - showEditingPreview: boolean
  - size: number
  - sizeToFit: boolean
  - text: string
  - textFill: TextFill
  - touchHandler: InteractionComponent
  - twoSided: boolean
  - verticalOverflow: VerticalOverflow
  - worldSpaceRect: Rect
- Text3D
  - capitilizationOverride: CapitilizationOverride
  - editable: boolean
  - extrudeDirection: number
  - extrusionDepth: number
  - font: Font
  - horizontalOverflow: HorizontalOverflow
  - letterSpacing: number
  - lineSpacing: number
  - onEditingFinished: event1
  - onEditingStarted: event0
  - onEditingUpdated: event1
  - showEditingPreview: boolean
  - size: number
  - sizeToFit: boolean
  - split(): RenderMeshVisual[]
  - text: string
  - touchHandler: InteractionComponent
  - verticalOverflow: VerticalOverflow
  - worldSpaceRect: Rect
- TextFill
  - color: vec4
  - mode: TextFillMode
  - texture: Texture
  - textureStretch: StretchMode
  - tileCount: number
  - tileZone: TileZone
- TextFillMode
  - Solid: number
  - Texture: number
- TextInputModule
- TextInputSystem
  - dismissKeyboard(): void
  - requestKeyboard(_options: TextInputSystem.KeyboardOptions): void
  - setEditingPosition(_position: number): void
  - setSelectedTextRange(_range: vec2): void
- TextInputSystem
  - KeyboardOptions
    - enablePreview: boolean
    - initialSelectedRange: vec2
    - initialText: string
    - keyboardType: TextInputSystem.KeyboardType
    - onError: (_error: number, _description: string) => void
    - onKeyboardStateChanged: (_{keyboardIsOpen:} boolean) => void
    - onReturnKeyPressed: () => void
    - onTextChanged: (_text: string, _range: vec2) => void
    - returnKeyType: TextInputSystem.ReturnKeyType
  - KeyboardType
    - Num: number
    - Phone: number
    - Text: number
    - Url: number
  - ReturnKeyType
    - Done: number
    - Go: number
    - Next: number
    - Return: number
    - Search: number
    - Send: number
- TextProvider
  - fontAsset: Font
  - outlineColor: vec4
  - outlineSize: number
  - shadowColor: vec4
  - shadowOffset: vec2
  - size: number
  - text: string
  - textColor: vec4
  - useDropshadow: boolean
  - useOutline: boolean
- TextToSpeech
- TextToSpeech
  - Options
    - create(): TextToSpeech.Options
  - PhonemeInfo
    - endTime: number
    - isAbusive: boolean
    - phoneme: string
    - startTime: number
  - VoiceNames
  - WordInfo
    - endTime: number
    - startTime: number
    - word: string
- TextToSpeechModule
  - synthesize(_input: string, _options: TextToSpeech.Options, _{onTTSComplete:} (_{audioTrackAsset:} AudioTrackAsset, _wordInfo: TextToSpeech.WordInfo[], _phonemeInfo: TextToSpeech.PhonemeInfo[], _voiceStyle: any) => void, _onTTSError: (_error: number, _description: string) => void): void
- Texture
  - control: TextureProvider
  - copyFrame(): Texture
  - createMarkerAsset(): MarkerAsset
  - getColorspace(): Colorspace
  - getHeight(): number
  - getWidth(): number
- TextureFormat
- TextureProvider
  - getAspect(): number
  - getHeight(): number
  - getWidth(): number
- TileZone
  - Character: number
  - Extents: number
  - Rect: number
  - Screen: number
- TouchDataProvider
  - composeTouchBlockingExceptionMask(_currentMask: number, _{newException:} string): number
  - enableTouchBlockingException(_exception: string, _enable: boolean): void
  - touchBlocking: boolean
  - touchBlockingExceptionMask: number
- TouchEndEvent
  - getTouchId(): number
  - getTouchPosition(): vec2
- TouchEndEventArgs
  - position: vec2
  - touchId: number
- TouchMoveEvent
  - getTouchId(): number
  - getTouchPosition(): vec2
- TouchMoveEventArgs
  - position: vec2
  - touchId: number
- TouchStartEvent
  - getTouchId(): number
  - getTouchPosition(): vec2
- TouchStartEventArgs
  - position: vec2
  - touchId: number
- TouchState
  - Began: number
  - Cancelled: number
  - Ended: number
  - Moved: number
- TrackedMesh
  - isValid: boolean
  - transform: mat4
- TrackedMeshFaceClassification
  - Ceiling: number
  - Door: number
  - Floor: number
  - None: number
  - Seat: number
  - Table: number
  - Wall: number
  - Window: number
- TrackedMeshHistogramResult
  - avgNormal: vec3
  - histogram: number[]
- TrackedMeshHitTestResult
  - classification: TrackedMeshFaceClassification
  - mesh: TrackedMesh
  - normal: vec3
  - position: vec3
- TrackedPlane
  - isValid: boolean
  - mesh: RenderMesh
  - orientation: TrackedPlaneOrientation
  - pivot: vec3
  - size: vec3
  - transform: mat4
- TrackedPlaneOrientation
  - Horizontal: number
  - Vertical: number
- TrackedPoint
  - orientation: quat
  - position: vec3
- TrackedPointComponent
  - isValid: boolean
  - trackedPoint: TrackedPoint
- Transform
  - back: vec3
  - down: vec3
  - forward: vec3
  - getInvertedWorldTransform(): mat4
  - getLocalPosition(): vec3
  - getLocalRotation(): quat
  - getLocalScale(): vec3
  - getSceneObject(): SceneObject
  - getWorldPosition(): vec3
  - getWorldRotation(): quat
  - getWorldScale(): vec3
  - getWorldTransform(): mat4
  - left: vec3
  - right: vec3
  - segmentScaleCompensate: boolean
  - setLocalPosition(_pos: vec3): void
  - setLocalRotation(_rotation: quat): void
  - setLocalScale(_scale: vec3): void
  - setLocalTransform(_{transformMat:} mat4): void
  - setWorldPosition(_pos: vec3): void
  - setWorldRotation(_rotation: quat): void
  - setWorldScale(_scale: vec3): void
  - setWorldTransform(_{transformMat:} mat4): void
  - up: vec3
- Transformer
  - inverseMatrix: mat3
  - matrix: mat3
- TransformerBuilder
  - build(): Transformer
  - setFillColor(_color: vec4): TransformerBuilder
  - setFlipX(_value: boolean): TransformerBuilder
  - setFlipY(_value: boolean): TransformerBuilder
  - setHorizontalAlignment(_mode: HorizontalAlignment): TransformerBuilder
  - setRotation(_mode: TransformerRotation): TransformerBuilder
  - setStretch(_value: boolean): TransformerBuilder
  - setVerticalAlignment(_mode: VerticalAlignment): TransformerBuilder
- TransformerRotation
  - None: number
  - Rotate180: number
  - Rotate270: number
  - Rotate90: number
- TriangleHit
  - barycentricCoordinate: vec3
  - index: number
  - mesh: CollisionMesh
  - vertexIndices: number[]
  - vertexPositions: vec3[]
- TriggerPrimaryEvent
  - position: vec2
- TriggerPrimaryEventArgs
- TurnOffEvent
- UpdateEvent
  - getDeltaTime(): number
- UpperBodyRenderObjectProvider
  - faceIndex: number
- UpperBodyTrackingAsset
- UserContextSystem
  - getAllFriends(_callback: (_data: SnapchatUser[]) => void): void
  - getBestFriends(_callback: (_data: SnapchatUser[]) => void): void
  - getCurrentUser(_callback: (_data: SnapchatUser) => void): void
  - getMyAIUser(_callback: (_data: SnapchatUser) => void): void
  - getUsersInCurrentContext(_callback: (_data: SnapchatUser[]) => void): void
  - requestAltitudeFormatted(_callback: (_{formattedData:} string) => void): void
  - requestAltitudeInMeters(_callback: (_data: number) => void): void
  - requestBirthdate(_callback: (_data: Date) => void): void
  - requestBirthdateFormatted(_callback: (_{formattedData:} string) => void): void
  - requestCity(_callback: (_data: string) => void): void
  - requestDisplayName(_callback: (_data: string) => void): void
  - requestTemperatureCelsius(_callback: (_data: number) => void): void
  - requestTemperatureFahrenheit(_callback: (_data: number) => void): void
  - requestTemperatureFormatted(_callback: (_{formattedData:} string) => void): void
  - requestUsername(_callback: (_data: string) => void): void
  - requestWeatherCondition(_callback: (_data: WeatherCondition) => void): void
  - requestWeatherLocalized(_callback: (_{formattedData:} string) => void): void
- VFXAsset
  - clone(): VFXAsset
  - feedbacks: PassWrappers
  - mesh: RenderMesh
  - outputs: PassWrappers
  - properties: Properties
  - simulations: PassWrappers
- VFXComponent
  - asset: VFXAsset
  - clear(): void
  - emitting: boolean
  - restart(): void
- VertexCache
  - currentTime: number
  - weight: number
- VertexSimulationSettings
  - bendStiffness: number
  - bendStiffnessGlobalWeight: number
  - friction: number
  - frictionGlobalWeight: number
  - mass: number
  - massGlobalWeight: number
  - stretchStiffness: number
  - stretchStiffnessGlobalWeight: number
- VerticalAlignment
  - Bottom: number
  - Center: number
  - Top: number
- VerticalOverflow
  - Overflow: number
  - Shrink: number
  - Truncate: number
- VideoStatus
  - Paused: number
  - Playing: number
  - Preparing: number
  - Stopped: number
- VideoTextureProvider
  - currentPlayCount: number
  - currentTime: number
  - duration: number
  - isPlaybackReady: boolean
  - lastFrameTime: number
  - onPlaybackDone: event0
  - onPlaybackReady: event0
  - pause(): void
  - play(_playCount: number): void
  - playbackRate: number
  - relativeEndTime: number
  - relativeStartTime: number
  - resume(): void
  - seek(_value: number): boolean
  - status: VideoStatus
  - stop(): void
  - totalDuration: number
  - volume: number
- Visual
  - getRenderOrder(): number
  - setRenderOrder(_value: number): void
- VoiceML
- VoiceML
  - AdditionalParam
    - key: string
    - value: string
  - BaseNlpModel
    - addParam(_key: string, _value: string): void
  - BaseNlpResponse
    - additionalParams: VoiceML.AdditionalParam[]
    - modelName: string
    - status: VoiceML.NlpResponseStatus
  - KeywordModelGroup
    - keywords: string[]
    - name: string
  - ListeningErrorEventArgs
    - description: string
    - error: number
  - ListeningOptions
    - languageCode: string
    - nlpModels: VoiceML.BaseNlpModel[]
    - postProcessingActions: VoiceML.PostProcessingAction[]
    - shouldReturnAsrTranscription: boolean
    - shouldReturnInterimAsrTranscription: boolean
    - speechContexts: VoiceML.SpeechContext[]
    - speechRecognizer: string
    - addSpeechContext(_phrases: string[], _boost: number): void
    - create(): VoiceML.ListeningOptions
  - ListeningUpdateEventArgs
    - isFinalTranscription: boolean
    - transcription: string
    - getCommandResponses(): VoiceML.NlpCommandResponse[]
    - getIntentResponses(): VoiceML.NlpIntentResponse[]
    - getKeywordResponses(): VoiceML.NlpKeywordResponse[]
    - getQnaResponses(): VoiceML.QnaResponse[]
  - NlpCommandResponse
    - command: string
  - NlpIntentModel
    - possibleIntents: string[]
  - NlpIntentResponse
    - intent: string
  - NlpIntentsModelOptions
    - create(_{intentModelName:} string): VoiceML.NlpIntentModel
  - NlpKeywordModel
    - keywordGroups: VoiceML.KeywordModelGroup[]
    - addKeywordGroup(_name: string, _keywords: string[]): void
  - NlpKeywordModelOptions
    - create(): VoiceML.NlpKeywordModel
  - NlpKeywordResponse
    - keywords: string[]
  - NlpResponseStatus
    - code: number
    - description: string
  - PostProcessingAction
  - PostProcessingActionResponse
    - id: number
    - status: VoiceML.PostProcessingActionResponseStatus
  - PostProcessingActionResponseStatus
    - code: number
    - description: string
  - QnaAction
    - context: string
    - create(_context: string): VoiceML.QnaAction
  - QnaResponse
    - answer: string
    - answerStatusCode: number
  - SpeechContext
    - boost: number
    - phrases: string[]
- VoiceMLModule
  - enableSystemCommands(): void
  - onListeningDisabled: event0
  - onListeningEnabled: event0
  - onListeningError: event1
  - onListeningUpdate: event1
  - startListening(_options: VoiceML.ListeningOptions): void
  - stopListening(): void
- VoiceMLModule
  - AnswerStatusCodes
    - NOT_A_QUESTION: number
    - NO_ANSWER_FOUND: number
    - STATUS_OK: number
    - UNSET: number
  - NlpResponsesStatusCodes
    - ERROR: number
    - OK: number
  - SpeechRecognizer
    - Default: string
- WeatherCondition
  - ClearNight: number
  - Cloudy: number
  - Hail: number
  - Lightning: number
  - LowVisibility: number
  - PartlyCloudy: number
  - Rainy: number
  - Snow: number
  - Sunny: number
  - Unknown: number
  - Windy: number
- WebPageTextureProvider
  - canGoBack: boolean
  - canGoForward: boolean
  - getUserAgent(): string
  - goBack(): void
  - goForward(): void
  - loadUrl(_url: string): void
  - onReady: event0
  - reload(): void
  - setUserAgent(_userAgent: string): void
  - stop(): void
  - touch(_id: number, _state: TouchState, _x: number, _y: number): void
- WebSocket
  - addEventListener(_type: string, _listener: (_event: WebSocketEvent) => void): void
  - binaryType: string
  - close(): void
  - onclose: (_event: WebSocketEvent) => void
  - onerror: (_event: WebSocketEvent) => void
  - onmessage: (_event: WebSocketEvent) => void
  - onopen: (_event: WebSocketEvent) => void
  - readyState: number
  - send(_data: string|Uint8Array): void
  - url: string
- WebSocketCloseEvent
  - code: number
  - reason: string
  - wasClean: boolean
- WebSocketErrorEvent
- WebSocketEvent
- WebSocketMessageEvent
  - data: string|Blob
  - type: string
- WebViewOptions
  - requestPolicy: WebViewPolicy
  - resolution: vec2
- WebViewPolicy
  - allow: string[]
  - block: string[]
- WeightedMode
  - Both: number
  - Left: number
  - None: number
  - Right: number
- WorldComponent
  - createProbe(): Probe
  - updateOrder: number
  - worldSettings: Physics.WorldSettingsAsset
- WorldOptions
  - enableWorldMeshesClassificationTracking: boolean
  - enableWorldMeshesTracking: boolean
  - nativePlaneTrackingType: NativePlaneTrackingType
  - pointCloudEnabled: boolean
- WorldQueryHitTestResult
  - normal: vec3
  - position: vec3
- WorldQueryModule
  - createHitTestSession(): HitTestSession
  - createHitTestSessionWithOptions(_options: HitTestSessionOptions): HitTestSession
- WorldRenderObjectProvider
  - enableWorldMeshesTracking: boolean
  - faceCount: number
  - meshClassificationFormat: MeshClassificationFormat
  - useNormals: boolean
  - vertexCount: number
- WorldTrackingCapabilities
  - planesTrackingSupported: boolean
  - sceneReconstructionSupported: boolean
  - trackedWorldPointsSupported: boolean
- WorldTrackingMeshesAddedEvent
  - getMeshes(): TrackedMesh[]
- WorldTrackingMeshesRemovedEvent
  - getMeshes(): TrackedMesh[]
- WorldTrackingMeshesUpdatedEvent
  - getMeshes(): TrackedMesh[]
- WorldTrackingPlanesAddedEvent
  - getPlanes(): TrackedPlane[]
- WorldTrackingPlanesRemovedEvent
  - getPlanes(): TrackedPlane[]
- WorldTrackingPlanesUpdatedEvent
  - getPlanes(): TrackedPlane[]
- WorldUnderstandingModule
- WrapMode
  - ClampToBorder: number
  - ClampToEdge: number
  - MirroredRepeat: number
  - Repeat: number
- Zodiac
  - Aquarius: number
  - Aries: number
  - Cancer: number
  - Capricorn: number
  - Gemini: number
  - Leo: number
  - Libra: number
  - Pisces: number
  - Sagittarius: number
  - Scorpio: number
  - Taurus: number
  - Virgo: number
- event0
  - add(_callback: () => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event1
  - add(_callback: (_arg0: T0) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event2
  - add(_callback: (_arg0: T0, _arg1: T1) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event3
  - add(_callback: (_arg0: T0, _arg1: T1, _arg2: T2) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event4
  - add(_callback: (_arg0: T0, _arg1: T1, _arg2: T2, _arg3: T3) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event5
  - add(_callback: (_arg0: T0, _arg1: T1, _arg2: T2, _arg3: T3, _arg4: T4) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event6
  - add(_callback: (_arg0: T0, _arg1: T1, _arg2: T2, _arg3: T3, _arg4: T4, _arg5: T5) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- event7
  - add(_callback: (_arg0: T0, _arg1: T1, _arg2: T2, _arg3: T3, _arg4: T4, _arg5: T5, _arg6: T6) => R): EventRegistration
  - remove(_{eventRegistration:} EventRegistration): void
- failAsync(_error: any): void
- getDeltaTime(): number
- getRealTimeNanos(): number
- getTime(): number
- global
  - deviceInfoSystem: DeviceInfoSystem
  - hapticFeedbackSystem: HapticFeedbackSystem
  - launchParams: GeneralDataStore
  - localizationSystem: LocalizationSystem
  - persistentStorageSystem: PersistentStorageSystem
  - scene: ScriptScene
  - textInputSystem: TextInputSystem
  - touchSystem: TouchDataProvider
  - userContextSystem: UserContextSystem
- isNull(_reference: any): boolean
- mat2
  - add(_mat: mat2): mat2
  - column0: vec2
  - column1: vec2
  - description: string
  - determinant(): number
  - div(_mat: mat2): mat2
  - equal(_mat: mat2): boolean
  - identity(): mat2
  - inverse(): mat2
  - mult(_mat: mat2): mat2
  - multiplyScalar(_scalar: number): mat2
  - sub(_mat: mat2): mat2
  - toString(): string
  - transpose(): mat2
  - zero(): mat2
- mat3
  - add(_mat: mat3): mat3
  - column0: vec3
  - column1: vec3
  - column2: vec3
  - description: string
  - determinant(): number
  - div(_mat: mat3): mat3
  - equal(_mat: mat3): boolean
  - identity(): mat3
  - inverse(): mat3
  - makeFromRotation(_arg1: quat): mat3
  - mult(_mat: mat3): mat3
  - multiplyScalar(_scalar: number): mat3
  - sub(_mat: mat3): mat3
  - toString(): string
  - transpose(): mat3
  - zero(): mat3
- mat4
  - add(_mat: mat4): mat4
  - column0: vec4
  - column1: vec4
  - column2: vec4
  - column3: vec4
  - compMult(_arg1: mat4, _arg2: mat4): mat4
  - compose(_translation: vec3, _rotation: quat, _scale: vec3): mat4
  - description: string
  - determinant(): number
  - div(_mat: mat4): mat4
  - equal(_mat: mat4): boolean
  - extractEulerAngles(): vec3
  - fromColumns(_column0: vec4, _column1: vec4, _column2: vec4, _column3: vec4): mat4
  - fromEulerAngles(_euler: vec3): mat4
  - fromEulerX(_xAngle: number): mat4
  - fromEulerY(_yAngle: number): mat4
  - fromEulerZ(_zAngle: number): mat4
  - fromRotation(_rotation: quat): mat4
  - fromRows(_row0: vec4, _row1: vec4, _row2: vec4, _row3: vec4): mat4
  - fromScale(_scale: vec3): mat4
  - fromTranslation(_translation: vec3): mat4
  - identity(): mat4
  - inverse(): mat4
  - lookAt(_eye: vec3, _center: vec3, _up: vec3): mat4
  - makeBasis(_x: vec3, _y: vec3, _z: vec3): mat4
  - mult(_mat: mat4): mat4
  - multiplyDirection(_direction: vec3): vec3
  - multiplyPoint(_point: vec3): vec3
  - multiplyScalar(_scalar: number): mat4
  - multiplyVector(_vector: vec4): vec4
  - orthographic(_left: number, _right: number, _bottom: number, _top: number, _zNear: number, _zFar: number): mat4
  - outerProduct(_arg1: vec4, _arg2: vec4): mat4
  - perspective(_fovY: number, _aspect: number, _zNear: number, _zFar: number): mat4
  - sub(_mat: mat4): mat4
  - toString(): string
  - transpose(): mat4
  - zero(): mat4
- print(_message: any): void
- quat
  - angleAxis(_angle: number, _axis: vec3): quat
  - angleBetween(_a: quat, _b: quat): number
  - dot(_quat: quat): number
  - equal(_b: quat): boolean
  - fromEulerAngles(_x: number, _y: number, _z: number): quat
  - fromEulerVec(_eulerVec: vec3): quat
  - fromRotationMat(_rotationMat: mat3): quat
  - getAngle(): number
  - getAxis(): vec3
  - invert(): quat
  - lerp(_a: quat, _b: quat, _t: number): quat
  - lookAt(_forward: vec3, _up: vec3): quat
  - multiply(_b: quat): quat
  - multiplyVec3(_vec3: vec3): vec3
  - normalize(): void
  - quatIdentity(): quat
  - rotationFromTo(_from: vec3, _to: vec3): quat
  - slerp(_a: quat, _b: quat, _t: number): quat
  - toEulerAngles(): vec3
  - toString(): string
  - w: number
  - x: number
  - y: number
  - z: number
- require(_moduleName: string|ScriptAsset): any
- requireAsset(_name: string): Asset
- requireType(_name: string): string
- script: ScriptComponent
- vec2
  - add(_vec: vec2): vec2
  - angleTo(_vec: vec2): number
  - clampLength(_length: number): vec2
  - distance(_vec: vec2): number
  - distanceSquared(_vec: vec2): number
  - div(_vec: vec2): vec2
  - dot(_vec: vec2): number
  - down(): vec2
  - equal(_vec: vec2): boolean
  - g: number
  - left(): vec2
  - length: number
  - lengthSquared: number
  - lerp(_vecA: vec2, _vecB: vec2, _t: number): vec2
  - max(_vecA: vec2, _vecB: vec2): vec2
  - min(_vecA: vec2, _vecB: vec2): vec2
  - moveTowards(_point: vec2, _magnitude: number): vec2
  - mult(_vec: vec2): vec2
  - normalize(): vec2
  - one(): vec2
  - project(_vec: vec2): vec2
  - projectOnPlane(_normal: vec2): vec2
  - r: number
  - randomDirection(): vec2
  - reflect(_vec: vec2): vec2
  - right(): vec2
  - scale(_vec: vec2): vec2
  - sub(_vec: vec2): vec2
  - toString(): string
  - uniformScale(_scale: number): vec2
  - up(): vec2
  - x: number
  - y: number
  - zero(): vec2
- vec3
  - add(_vec: vec3): vec3
  - angleTo(_vec: vec3): number
  - b: number
  - back(): vec3
  - clampLength(_length: number): vec3
  - cross(_vec: vec3): vec3
  - distance(_vec: vec3): number
  - distanceSquared(_vec: vec3): number
  - div(_vec: vec3): vec3
  - dot(_vec: vec3): number
  - down(): vec3
  - equal(_vec: vec3): boolean
  - forward(): vec3
  - g: number
  - left(): vec3
  - length: number
  - lengthSquared: number
  - lerp(_vecA: vec3, _vecB: vec3, _t: number): vec3
  - max(_vecA: vec3, _vecB: vec3): vec3
  - min(_vecA: vec3, _vecB: vec3): vec3
  - moveTowards(_point: vec3, _magnitude: number): vec3
  - mult(_vec: vec3): vec3
  - normalize(): vec3
  - one(): vec3
  - orthonormalize(_vecA: vec3, _vecB: vec3): void
  - project(_vec: vec3): vec3
  - projectOnPlane(_normal: vec3): vec3
  - r: number
  - randomDirection(): vec3
  - reflect(_vec: vec3): vec3
  - right(): vec3
  - rotateTowards(_target: vec3, _step: number): vec3
  - scale(_vec: vec3): vec3
  - slerp(_vecA: vec3, _vecB: vec3, _t: number): vec3
  - sub(_vec: vec3): vec3
  - toString(): string
  - uniformScale(_scale: number): vec3
  - up(): vec3
  - x: number
  - y: number
  - z: number
  - zero(): vec3
- vec4
  - a: number
  - add(_vec: vec4): vec4
  - angleTo(_vec: vec4): number
  - b: number
  - clampLength(_length: number): vec4
  - distance(_vec: vec4): number
  - distanceSquared(_vec: vec4): number
  - div(_vec: vec4): vec4
  - dot(_vec: vec4): number
  - equal(_vec: vec4): boolean
  - g: number
  - length: number
  - lengthSquared: number
  - lerp(_vecA: vec4, _vecB: vec4, _t: number): vec4
  - max(_vecA: vec4, _vecB: vec4): vec4
  - min(_vecA: vec4, _vecB: vec4): vec4
  - moveTowards(_point: vec4, _magnitude: number): vec4
  - mult(_vec: vec4): vec4
  - normalize(): vec4
  - one(): vec4
  - project(_vec: vec4): vec4
  - projectOnPlane(_normal: vec4): vec4
  - r: number
  - reflect(_vec: vec4): vec4
  - scale(_vec: vec4): vec4
  - sub(_vec: vec4): vec4
  - toString(): string
  - uniformScale(_scale: number): vec4
  - w: number
  - x: number
  - y: number
  - z: number
  - zero(): vec4
- vec4b
  - a: boolean
  - b: boolean
  - g: boolean
  - r: boolean
  - toString(): string
  - w: boolean
  - x: boolean
  - y: boolean
  - z: boolean