## API Report File for "@dcl/playground-assets"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

import _m0 from 'protobufjs/minimal';

// @public (undocumented)
export type AlignType = 'auto' | 'flex-start' | 'center' | 'flex-end' | 'stretch' | 'baseline' | 'space-between' | 'space-around';

// Warning: (ae-missing-release-tag) "Animator" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Animator: AnimatorComponentDefinitionExtended;

// @public (undocumented)
export interface AnimatorComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBAnimator> {
    getClip(entity: Entity, clipName: string): PBAnimationState;
    getClipOrNull(entity: Entity, clipName: string): PBAnimationState | null;
    playSingleAnimation(entity: Entity, clipName: string, resetCursor?: boolean): boolean;
    stopAllAnimations(entity: Entity, resetCursor?: boolean): boolean;
}

// @public (undocumented)
export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;

// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
//
// @public
export type AppendValueMessageBody = {
    type: CrdtMessageType.APPEND_VALUE;
    entityId: Entity;
    componentId: number;
    timestamp: number;
    data: Uint8Array;
};

// @public (undocumented)
export namespace AppendValueOperation {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 16;
    // (undocumented)
    export function read(buf: ByteBuffer): AppendValueMessage | null;
    export function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
}

// Warning: (ae-missing-release-tag) "areConnected" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function areConnected(parcels: Coords[]): boolean;

// @public (undocumented)
export const AudioEvent: GrowOnlyValueSetComponentDefinition<PBAudioEvent>;

// Warning: (ae-missing-release-tag) "AudioSource" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const AudioSource: AudioSourceComponentDefinitionExtended;

// @public (undocumented)
export interface AudioSourceComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBAudioSource> {
    playSound(entity: Entity, src: string, resetCursor?: boolean): boolean;
    stopSound(entity: Entity, resetCursor?: boolean): boolean;
}

// Warning: (ae-missing-release-tag) "AudioStream" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const AudioStream: AudioStreamComponentDefinitionExtended;

// @public (undocumented)
export interface AudioStreamComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBAudioStream> {
    getAudioState(entity: Entity): PBAudioEvent | undefined;
}

// @public (undocumented)
export const enum AvatarAnchorPointType {
    // (undocumented)
    AAPT_HEAD = 4,
    // (undocumented)
    AAPT_HIP = 9,
    // (undocumented)
    AAPT_LEFT_ARM = 11,
    // (undocumented)
    AAPT_LEFT_FOOT = 20,
    // (undocumented)
    AAPT_LEFT_FOREARM = 12,
    // (undocumented)
    AAPT_LEFT_HAND = 2,
    // (undocumented)
    AAPT_LEFT_HAND_INDEX = 13,
    // (undocumented)
    AAPT_LEFT_LEG = 19,
    // (undocumented)
    AAPT_LEFT_SHOULDER = 10,
    // (undocumented)
    AAPT_LEFT_TOE_BASE = 21,
    // (undocumented)
    AAPT_LEFT_UP_LEG = 18,
    // (undocumented)
    AAPT_NAME_TAG = 1,
    // (undocumented)
    AAPT_NECK = 5,
    // @deprecated
    AAPT_POSITION = 0,
    // (undocumented)
    AAPT_RIGHT_ARM = 15,
    // (undocumented)
    AAPT_RIGHT_FOOT = 24,
    // (undocumented)
    AAPT_RIGHT_FOREARM = 16,
    // (undocumented)
    AAPT_RIGHT_HAND = 3,
    // (undocumented)
    AAPT_RIGHT_HAND_INDEX = 17,
    // (undocumented)
    AAPT_RIGHT_LEG = 23,
    // (undocumented)
    AAPT_RIGHT_SHOULDER = 14,
    // (undocumented)
    AAPT_RIGHT_TOE_BASE = 25,
    // (undocumented)
    AAPT_RIGHT_UP_LEG = 22,
    // (undocumented)
    AAPT_SPINE = 6,
    // (undocumented)
    AAPT_SPINE1 = 7,
    // (undocumented)
    AAPT_SPINE2 = 8
}

// @public (undocumented)
export const AvatarAttach: LastWriteWinElementSetComponentDefinition<PBAvatarAttach>;

// @public (undocumented)
export const AvatarBase: LastWriteWinElementSetComponentDefinition<PBAvatarBase>;

// @public (undocumented)
export const AvatarEmoteCommand: GrowOnlyValueSetComponentDefinition<PBAvatarEmoteCommand>;

// @public (undocumented)
export const AvatarEquippedData: LastWriteWinElementSetComponentDefinition<PBAvatarEquippedData>;

// @public (undocumented)
export const AvatarModifierArea: LastWriteWinElementSetComponentDefinition<PBAvatarModifierArea>;

// @public (undocumented)
export const enum AvatarModifierType {
    AMT_DISABLE_PASSPORTS = 1,
    AMT_HIDE_AVATARS = 0
}

// @public (undocumented)
export const AvatarShape: LastWriteWinElementSetComponentDefinition<PBAvatarShape>;

// @public (undocumented)
export interface AvatarTexture {
    filterMode?: TextureFilterMode | undefined;
    // (undocumented)
    userId: string;
    wrapMode?: TextureWrapMode | undefined;
}

// @public (undocumented)
export namespace AvatarTexture {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): AvatarTexture;
    // (undocumented)
    export function encode(message: AvatarTexture, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export const enum BackgroundTextureMode {
    CENTER = 1,
    NINE_SLICES = 0,
    STRETCH = 2
}

// @public (undocumented)
export interface BaseComponent<T> {
    // (undocumented)
    readonly componentId: number;
    // (undocumented)
    readonly componentName: string;
    // (undocumented)
    readonly componentType: ComponentType;
    dumpCrdtStateToBuffer(buffer: ByteBuffer, filterEntity?: (entity: Entity) => boolean): void;
    entityDeleted(entity: Entity, markAsDirty: boolean): void;
    get(entity: Entity): any;
    getCrdtUpdates(): Iterable<CrdtMessageBody>;
    has(entity: Entity): boolean;
    onChange(entity: Entity, cb: (value: T | undefined) => void): void;
    // (undocumented)
    readonly schema: ISchema<T>;
    updateFromCrdt(body: CrdtMessageBody): [null | ConflictResolutionMessage, T | undefined];
}

// @public (undocumented)
export const Billboard: LastWriteWinElementSetComponentDefinition<PBBillboard>;

// @public (undocumented)
export const enum BillboardMode {
    BM_ALL = 7,
    // (undocumented)
    BM_NONE = 0,
    // (undocumented)
    BM_X = 1,
    // (undocumented)
    BM_Y = 2,
    // (undocumented)
    BM_Z = 4
}

// @public
export interface BorderRadius {
    // (undocumented)
    bottomLeft: PositionUnit;
    // (undocumented)
    bottomRight: PositionUnit;
    // (undocumented)
    topLeft: PositionUnit;
    // (undocumented)
    topRight: PositionUnit;
}

// @public (undocumented)
export interface BorderRect {
    // (undocumented)
    bottom: number;
    // (undocumented)
    left: number;
    // (undocumented)
    right: number;
    // (undocumented)
    top: number;
}

// @public (undocumented)
export namespace BorderRect {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): BorderRect;
    // (undocumented)
    export function encode(message: BorderRect, writer?: _m0.Writer): _m0.Writer;
}

// Warning: (tsdoc-undefined-tag) The TSDoc tag "@category" is not defined in this configuration
//
// @public
export function Button(props: UiButtonProps): ReactEcs.JSX.Element;

// @public (undocumented)
export interface ByteBuffer {
    // (undocumented)
    buffer(): Uint8Array;
    // (undocumented)
    bufferLength(): number;
    // (undocumented)
    currentReadOffset(): number;
    // (undocumented)
    currentWriteOffset(): number;
    // (undocumented)
    getFloat32(offset: number): number;
    // (undocumented)
    getFloat64(offset: number): number;
    // (undocumented)
    getInt16(offset: number): number;
    // (undocumented)
    getInt32(offset: number): number;
    // (undocumented)
    getInt64(offset: number): bigint;
    // (undocumented)
    getInt8(offset: number): number;
    // (undocumented)
    getUint16(offset: number): number;
    // (undocumented)
    getUint32(offset: number): number;
    // (undocumented)
    getUint64(offset: number): bigint;
    // (undocumented)
    getUint8(offset: number): number;
    incrementReadOffset(amount: number): number;
    incrementWriteOffset(amount: number): number;
    // (undocumented)
    readBuffer(): Uint8Array;
    // (undocumented)
    readFloat32(): number;
    // (undocumented)
    readFloat64(): number;
    // (undocumented)
    readInt16(): number;
    // (undocumented)
    readInt32(): number;
    // (undocumented)
    readInt64(): bigint;
    // (undocumented)
    readInt8(): number;
    // (undocumented)
    readUint16(): number;
    // (undocumented)
    readUint32(): number;
    // (undocumented)
    readUint64(): bigint;
    // (undocumented)
    readUint8(): number;
    // (undocumented)
    readUtf8String(): string;
    // (undocumented)
    remainingBytes(): number;
    resetBuffer(): void;
    // (undocumented)
    setFloat32(offset: number, value: number): void;
    // (undocumented)
    setFloat64(offset: number, value: number): void;
    // (undocumented)
    setInt16(offset: number, value: number): void;
    // (undocumented)
    setInt32(offset: number, value: number): void;
    // (undocumented)
    setInt64(offset: number, value: bigint): void;
    // (undocumented)
    setInt8(offset: number, value: number): void;
    // (undocumented)
    setUint16(offset: number, value: number): void;
    // (undocumented)
    setUint32(offset: number, value: number): void;
    // (undocumented)
    setUint64(offset: number, value: bigint): void;
    // (undocumented)
    setUint8(offset: number, value: number): void;
    toBinary(): Uint8Array;
    toCopiedBinary(): Uint8Array;
    // (undocumented)
    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
    // (undocumented)
    writeFloat32(value: number): void;
    // (undocumented)
    writeFloat64(value: number): void;
    // (undocumented)
    writeInt16(value: number): void;
    // (undocumented)
    writeInt32(value: number): void;
    // (undocumented)
    writeInt64(value: bigint): void;
    // (undocumented)
    writeInt8(value: number): void;
    // (undocumented)
    writeUint16(value: number): void;
    // (undocumented)
    writeUint32(value: number): void;
    // (undocumented)
    writeUint64(value: bigint): void;
    // (undocumented)
    writeUint8(value: number): void;
    // (undocumented)
    writeUtf8String(value: string, writeLength?: boolean): void;
}

// @public
export type Callback = () => void;

// @public (undocumented)
export const CameraMode: LastWriteWinElementSetComponentDefinition<PBCameraMode>;

// @public (undocumented)
export const CameraModeArea: LastWriteWinElementSetComponentDefinition<PBCameraModeArea>;

// @public (undocumented)
export interface CameraTransition {
    // (undocumented)
    transitionMode?: {
        $case: "time";
        time: number;
    } | {
        $case: "speed";
        speed: number;
    } | undefined;
}

// @public (undocumented)
export namespace CameraTransition {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): CameraTransition;
    // (undocumented)
    export function encode(message: CameraTransition, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface CameraTransitionHelper {
    // (undocumented)
    Speed: (speed: number) => CameraTransition['transitionMode'];
    // (undocumented)
    Time: (time: number) => CameraTransition['transitionMode'];
}

// @public (undocumented)
export const enum CameraType {
    CT_CINEMATIC = 2,
    // (undocumented)
    CT_FIRST_PERSON = 0,
    // (undocumented)
    CT_THIRD_PERSON = 1
}

// Warning: (ae-missing-release-tag) "Children" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type Children = ReactEcs.JSX.ReactNode;

// @public (undocumented)
export const enum ColliderLayer {
    // (undocumented)
    CL_CUSTOM1 = 256,
    // (undocumented)
    CL_CUSTOM2 = 512,
    // (undocumented)
    CL_CUSTOM3 = 1024,
    // (undocumented)
    CL_CUSTOM4 = 2048,
    // (undocumented)
    CL_CUSTOM5 = 4096,
    // (undocumented)
    CL_CUSTOM6 = 8192,
    // (undocumented)
    CL_CUSTOM7 = 16384,
    // (undocumented)
    CL_CUSTOM8 = 32768,
    CL_NONE = 0,
    CL_PHYSICS = 2,
    CL_PLAYER = 4,
    CL_POINTER = 1,
    // (undocumented)
    CL_RESERVED2 = 8,
    // (undocumented)
    CL_RESERVED3 = 16,
    // (undocumented)
    CL_RESERVED4 = 32,
    // (undocumented)
    CL_RESERVED5 = 64,
    // (undocumented)
    CL_RESERVED6 = 128
}

// @public
export type Color3 = Color3.ReadonlyColor3;

// @public
export namespace Color3 {
    export function add(value: ReadonlyColor3, otherColor: ReadonlyColor3): MutableColor3;
    export function addToRef(value: ReadonlyColor3, otherColor: ReadonlyColor3, result: MutableColor3): void;
    export function asArray(value: ReadonlyColor3): number[];
    export function Black(): MutableColor3;
    export function Blue(): MutableColor3;
    export function clamp(value: ReadonlyColor3, min?: number, max?: number): MutableColor3;
    export function clampToRef(value: ReadonlyColor3, min: number | undefined, max: number | undefined, result: MutableColor3): void;
    export function clone(value: ReadonlyColor3): MutableColor3;
    export function copyFrom(source: ReadonlyColor3, dest: MutableColor3): void;
    export function create(
    r?: number,
    g?: number,
    b?: number): {
        r: number;
        g: number;
        b: number;
    };
    export function equals(value: ReadonlyColor3, otherColor: ReadonlyColor3): boolean;
    export function equalsFloats(value: ReadonlyColor3, r: number, g: number, b: number): boolean;
    export function fromArray(array: ArrayLike<number>, offset?: number): MutableColor3;
    export function fromHexString(hex: string): MutableColor3;
    export function fromInts(r: number, g: number, b: number): MutableColor3;
    export function getHashCode(value: ReadonlyColor3): number;
    export function Gray(): MutableColor3;
    export function Green(): MutableColor3;
    export function lerp(start: ReadonlyColor3, end: ReadonlyColor3, amount: number): MutableColor3;
    export function lerpToRef(left: ReadonlyColor3, right: ReadonlyColor3, amount: number, result: MutableColor3): void;
    export function Magenta(): MutableColor3;
    export function multiply(value: ReadonlyColor3, otherColor: ReadonlyColor3): MutableColor3;
    export function multiplyToRef(value: ReadonlyColor3, otherColor: ReadonlyColor3, result: MutableColor3): void;
    export type Mutable = MutableColor3;
    export type MutableColor3 = {
        r: number;
        g: number;
        b: number;
    };
    export function Purple(): MutableColor3;
    export function Random(): MutableColor3;
    export type ReadonlyColor3 = {
        readonly r: number;
        readonly g: number;
        readonly b: number;
    };
    export function Red(): MutableColor3;
    export function scale(value: ReadonlyColor3, scale: number): MutableColor3;
    export function scaleAndAddToRef(value: ReadonlyColor3, scale: number, result: MutableColor3): void;
    export function scaleToRef(value: ReadonlyColor3, scale: number, result: MutableColor3): void;
    export function set(dest: MutableColor3, r: number, g: number, b: number): void;
    export function subtract(value: ReadonlyColor3, otherColor: ReadonlyColor3): MutableColor3;
    export function subtractToRef(value: ReadonlyColor3, otherColor: ReadonlyColor3, result: MutableColor3): void;
    export function Teal(): MutableColor3;
    export function toArray(value: ReadonlyColor3, array: FloatArray, index?: number): void;
    export function toColor4(value: ReadonlyColor3, alpha?: number): Color4.MutableColor4;
    export function toGammaSpace(value: ReadonlyColor3): ReadonlyColor3;
    export function toGammaSpaceToRef(value: ReadonlyColor3, convertedColor: MutableColor3): void;
    export function toHexString(value: ReadonlyColor3): string;
    export function toLinearSpace(value: ReadonlyColor3): MutableColor3;
    export function toLinearSpaceToRef(value: ReadonlyColor3, convertedColor: MutableColor3): void;
    export function toLuminance(value: ReadonlyColor3): number;
    export function toString(value: ReadonlyColor3): string;
    export function White(): MutableColor3;
    export function Yellow(): MutableColor3;
}

// @public (undocumented)
export type Color3Type = {
    r: number;
    g: number;
    b: number;
};

// @public
export type Color4 = Color4.ReadonlyColor4;

// @public
export namespace Color4 {
    export function add(value: ReadonlyColor4, right: ReadonlyColor4): MutableColor4;
    export function addToRef(a: ReadonlyColor4, b: ReadonlyColor4, ref: MutableColor4): void;
    export function Black(): MutableColor4;
    export function Blue(): MutableColor4;
    export function checkColors4(colors: number[], count: number): number[];
    export function clampToRef(value: ReadonlyColor4, min: number | undefined, max: number | undefined, result: MutableColor4): void;
    export function Clear(): MutableColor4;
    export function clone(value: ReadonlyColor4): MutableColor4;
    export function copyFrom(source: ReadonlyColor4, dest: MutableColor4): void;
    export function copyFromFloats(r: number, g: number, b: number, a: number, dest: MutableColor4): void;
    export function create(
    r?: number,
    g?: number,
    b?: number,
    a?: number): MutableColor4;
    export function fromArray(array: ArrayLike<number>, offset?: number): ReadonlyColor4;
    export function fromColor3(color3: Color3.ReadonlyColor3, alpha?: number): MutableColor4;
    export function fromHexString(hex: string): MutableColor4;
    export function fromInts(r: number, g: number, b: number, a: number): MutableColor4;
    export function getHashCode(value: ReadonlyColor4): number;
    export function Gray(): MutableColor4;
    export function Green(): MutableColor4;
    export function lerp(left: ReadonlyColor4, right: ReadonlyColor4, amount: number): MutableColor4;
    export function lerpToRef(left: ReadonlyColor4, right: ReadonlyColor4, amount: number, result: MutableColor4): void;
    export function Magenta(): MutableColor4;
    export function multiply(value: ReadonlyColor4, color: ReadonlyColor4): ReadonlyColor4;
    export function multiplyToRef(value: ReadonlyColor4, color: ReadonlyColor4, result: MutableColor4): void;
    export type Mutable = MutableColor4;
    export type MutableColor4 = {
        r: number;
        g: number;
        b: number;
        a: number;
    };
    export function Purple(): MutableColor4;
    export type ReadonlyColor4 = {
        readonly r: number;
        readonly g: number;
        readonly b: number;
        readonly a: number;
    };
    export function Red(): MutableColor4;
    export function scale(value: ReadonlyColor4, scale: number): ReadonlyColor4;
    export function scaleAndAddToRef(value: ReadonlyColor4, scale: number, result: MutableColor4): void;
    export function scaleToRef(value: ReadonlyColor4, scale: number, result: MutableColor4): void;
    export function set(r: number, g: number, b: number, a: number, dest: MutableColor4): void;
    export function subtract(value: ReadonlyColor4, right: ReadonlyColor4): ReadonlyColor4;
    export function subtractToRef(a: ReadonlyColor4, b: ReadonlyColor4, result: MutableColor4): void;
    export function Teal(): MutableColor4;
    export function toArray(value: ReadonlyColor4, array: number[], index?: number): void;
    export function toGammaSpace(value: ReadonlyColor4): ReadonlyColor4;
    export function toGammaSpaceToRef(value: ReadonlyColor4, convertedColor: MutableColor4): void;
    export function toHexString(value: ReadonlyColor4): string;
    export function toLinearSpace(value: ReadonlyColor4): MutableColor4;
    export function toLinearSpaceToRef(value: ReadonlyColor4, ref: MutableColor4): void;
    export function toString(value: ReadonlyColor4): string;
    export function White(): MutableColor4;
    export function Yellow(): MutableColor4;
}

// @public (undocumented)
export type Color4Type = {
    r: number;
    g: number;
    b: number;
    a: number;
};

// @public (undocumented)
export interface ComponentData {
    // (undocumented)
    data?: {
        $case: "json";
        json: any | undefined;
    } | {
        $case: "binary";
        binary: Uint8Array;
    } | undefined;
}

// @public (undocumented)
export namespace ComponentData {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): ComponentData;
    // (undocumented)
    export function encode(message: ComponentData, writer?: _m0.Writer): _m0.Writer;
    // (undocumented)
    export function fromJSON(object: any): ComponentData;
    // (undocumented)
    export function toJSON(message: ComponentData): unknown;
}

// @public (undocumented)
export type ComponentDefinition<T> = LastWriteWinElementSetComponentDefinition<T> | GrowOnlyValueSetComponentDefinition<T> | ReadOnlyGrowOnlyValueSetComponentDefinition<T> | ReadOnlyLastWriteWinElementSetComponentDefinition<T>;

// Warning: (ae-missing-release-tag) "componentDefinitionByName" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export const componentDefinitionByName: {
    "core::Animator": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAnimator>>;
    "core::AudioEvent": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBAudioEvent>>;
    "core::AudioSource": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAudioSource>>;
    "core::AudioStream": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAudioStream>>;
    "core::AvatarAttach": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAvatarAttach>>;
    "core::AvatarBase": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAvatarBase>>;
    "core::AvatarEmoteCommand": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBAvatarEmoteCommand>>;
    "core::AvatarEquippedData": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAvatarEquippedData>>;
    "core::AvatarModifierArea": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAvatarModifierArea>>;
    "core::AvatarShape": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBAvatarShape>>;
    "core::Billboard": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBBillboard>>;
    "core::CameraMode": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBCameraMode>>;
    "core::CameraModeArea": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBCameraModeArea>>;
    "core::EngineInfo": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBEngineInfo>>;
    "core::GltfContainer": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBGltfContainer>>;
    "core::GltfContainerLoadingState": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBGltfContainerLoadingState>>;
    "core::GltfNodeModifiers": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBGltfNodeModifiers>>;
    "core::InputModifier": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBInputModifier>>;
    "core::LightSource": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBLightSource>>;
    "core::MainCamera": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBMainCamera>>;
    "core::Material": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBMaterial>>;
    "core::MeshCollider": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBMeshCollider>>;
    "core::MeshRenderer": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBMeshRenderer>>;
    "core::NftShape": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBNftShape>>;
    "core::PlayerIdentityData": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBPlayerIdentityData>>;
    "core::PointerEvents": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBPointerEvents>>;
    "core::PointerEventsResult": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBPointerEventsResult>>;
    "core::PointerLock": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBPointerLock>>;
    "core::PrimaryPointerInfo": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBPrimaryPointerInfo>>;
    "core::Raycast": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBRaycast>>;
    "core::RaycastResult": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBRaycastResult>>;
    "core::RealmInfo": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBRealmInfo>>;
    "core::SkyboxTime": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBSkyboxTime>>;
    "core::TextShape": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTextShape>>;
    "core::TriggerArea": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTriggerArea>>;
    "core::TriggerAreaResult": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBTriggerAreaResult>>;
    "core::Tween": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTween>>;
    "core::TweenSequence": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenSequence>>;
    "core::TweenState": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBTweenState>>;
    "core::UiBackground": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiBackground>>;
    "core::UiCanvasInformation": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiCanvasInformation>>;
    "core::UiDropdown": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiDropdown>>;
    "core::UiDropdownResult": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiDropdownResult>>;
    "core::UiInput": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiInput>>;
    "core::UiInputResult": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiInputResult>>;
    "core::UiText": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiText>>;
    "core::UiTransform": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBUiTransform>>;
    "core::VideoEvent": GSetComponentGetter<GrowOnlyValueSetComponentDefinition<PBVideoEvent>>;
    "core::VideoPlayer": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBVideoPlayer>>;
    "core::VirtualCamera": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBVirtualCamera>>;
    "core::VisibilityComponent": LwwComponentGetter<LastWriteWinElementSetComponentDefinition<PBVisibilityComponent>>;
};

// @public
export const enum ComponentType {
    // (undocumented)
    GrowOnlyValueSet = 1,
    // (undocumented)
    LastWriteWinElementSet = 0
}

// @public @deprecated (undocumented)
export type Composite = CompositeDefinition;

// @public @deprecated (undocumented)
export namespace Composite {
    // (undocumented)
    export type Definition = CompositeDefinition;
    // (undocumented)
    export function fromBinary(buffer: Uint8Array): Composite.Definition;
    // (undocumented)
    export function fromJson(object: any): Composite.Definition;
    export function instance(engine: IEngine, compositeData: Composite.Resource, compositeProvider: CompositeProvider, options?: InstanceCompositeOptions): void;
    // (undocumented)
    export type Provider = CompositeProvider;
    export function resolveAndNormalizePath(src: string, cwd?: string): string;
    // (undocumented)
    export type Resource = CompositeResource;
    // (undocumented)
    export function toBinary(composite: Composite.Definition): Uint8Array;
    // (undocumented)
    export function toJson(composite: Composite.Definition): any;
}

// @public (undocumented)
export interface CompositeComponent {
    // (undocumented)
    data: Map<number, ComponentData>;
    // (undocumented)
    jsonSchema: any | undefined;
    // (undocumented)
    name: string;
}

// @public (undocumented)
export namespace CompositeComponent {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeComponent;
    // (undocumented)
    export function encode(message: CompositeComponent, writer?: _m0.Writer): _m0.Writer;
    // (undocumented)
    export function fromJSON(object: any): CompositeComponent;
    // (undocumented)
    export function toJSON(message: CompositeComponent): unknown;
}

// @public (undocumented)
export interface CompositeComponent_DataEntry {
    // (undocumented)
    key: number;
    // (undocumented)
    value: ComponentData | undefined;
}

// @public (undocumented)
export namespace CompositeComponent_DataEntry {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeComponent_DataEntry;
    // (undocumented)
    export function encode(message: CompositeComponent_DataEntry, writer?: _m0.Writer): _m0.Writer;
    // (undocumented)
    export function fromJSON(object: any): CompositeComponent_DataEntry;
    // (undocumented)
    export function toJSON(message: CompositeComponent_DataEntry): unknown;
}

// @public (undocumented)
export interface CompositeDefinition {
    // (undocumented)
    components: CompositeComponent[];
    // (undocumented)
    version: number;
}

// @public (undocumented)
export namespace CompositeDefinition {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): CompositeDefinition;
    // (undocumented)
    export function encode(message: CompositeDefinition, writer?: _m0.Writer): _m0.Writer;
    // (undocumented)
    export function fromJSON(object: any): CompositeDefinition;
    // (undocumented)
    export function toJSON(message: CompositeDefinition): unknown;
}

// @public (undocumented)
export type CompositeProvider = {
    getCompositeOrNull(src: string): CompositeResource | null;
};

// @public (undocumented)
export type CompositeResource = {
    src: string;
    composite: CompositeDefinition;
};

// @public @deprecated (undocumented)
export type CompositeRootType = {
    src: string;
    entities: {
        src: Entity;
        dest: Entity;
    }[];
};

// @public
export type ConflictResolutionMessage = PutComponentMessageBody | DeleteComponentMessageBody;

// Warning: (ae-missing-release-tag) "Coords" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type Coords = {
    x: number;
    y: number;
};

// @public (undocumented)
export const CRDT_MESSAGE_HEADER_LENGTH = 8;

// @public (undocumented)
export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | AppendValueMessage | DeleteEntityMessage | PutNetworkComponentMessage | DeleteComponentNetworkMessage | DeleteEntityNetworkMessage;

// @public (undocumented)
export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody | CrdtNetworkMessageBody;

// @public
export type CrdtMessageHeader = {
    length: uint32;
    type: uint32;
};

// @public (undocumented)
export namespace CrdtMessageProtocol {
    export function consumeMessage(buf: ByteBuffer): boolean;
    export function getHeader(buf: ByteBuffer): CrdtMessageHeader | null;
    export function readHeader(buf: ByteBuffer): CrdtMessageHeader | null;
    export function validate(buf: ByteBuffer): boolean;
}

// @public (undocumented)
export enum CrdtMessageType {
    // (undocumented)
    APPEND_VALUE = 4,
    // (undocumented)
    DELETE_COMPONENT = 2,
    // (undocumented)
    DELETE_COMPONENT_NETWORK = 6,
    // (undocumented)
    DELETE_ENTITY = 3,
    // (undocumented)
    DELETE_ENTITY_NETWORK = 7,
    // (undocumented)
    MAX_MESSAGE_TYPE = 8,
    // (undocumented)
    PUT_COMPONENT = 1,
    // (undocumented)
    PUT_COMPONENT_NETWORK = 5,
    // (undocumented)
    RESERVED = 0
}

// @public (undocumented)
export type CrdtNetworkMessageBody = PutNetworkComponentMessageBody | DeleteComponentNetworkMessageBody | DeleteEntityNetworkMessageBody;

// @public (undocumented)
export function createEntityContainer(opts?: {
    reservedStaticEntities: number;
}): IEntityContainer;

// @public
export function createEthereumProvider(): {
    send(message: RPCSendableMessage, callback?: ((error: Error | null, result?: any) => void) | undefined): void;
    sendAsync(message: RPCSendableMessage, callback: (error: Error | null, result?: any) => void): void;
};

// @public
export function createInputSystem(engine: IEngine): IInputSystem;

// @public
export function createPointerEventsSystem(engine: IEngine, inputSystem: IInputSystem): PointerEventsSystem;

// @public (undocumented)
export function createReactBasedUiSystem(engine: IEngine, pointerSystem: PointerEventsSystem): ReactBasedUiSystem;

// @public (undocumented)
export function createTweenSystem(engine: IEngine): TweenSystem;

// Warning: (tsdoc-code-fence-closing-syntax) Unexpected characters after closing delimiter for code fence
// Warning: (tsdoc-code-span-missing-delimiter) The code span is missing its closing backtick
// Warning: (tsdoc-undefined-tag) The TSDoc tag "@params" is not defined in this configuration
//
// @public
export function cyclicParentingChecker(engine: IEngine): () => void;

// @public (undocumented)
export type DeepReadonly<T> = T extends ReadonlyPrimitive ? T : T extends Array<infer K> ? ReadonlyArray<DeepReadonly<K>> : T extends Map<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends Set<infer M> ? DeepReadonlySet<M> : DeepReadonlyObject<T>;

// @public (undocumented)
export type DeepReadonlyMap<K, V> = ReadonlyMap<K, DeepReadonly<V>>;

// @public (undocumented)
export type DeepReadonlyObject<T> = {
    readonly [K in keyof T]: DeepReadonly<T[K]>;
};

// @public (undocumented)
export type DeepReadonlySet<T> = ReadonlySet<DeepReadonly<T>>;

// @public
export const DEG2RAD: number;

// @public (undocumented)
export namespace DeleteComponent {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 12;
    // (undocumented)
    export function read(buf: ByteBuffer): DeleteComponentMessage | null;
    export function write(entity: Entity, componentId: number, timestamp: number, buf: ByteBuffer): void;
}

// @public (undocumented)
export type DeleteComponentMessage = CrdtMessageHeader & DeleteComponentMessageBody;

// @public (undocumented)
export type DeleteComponentMessageBody = {
    type: CrdtMessageType.DELETE_COMPONENT;
    entityId: Entity;
    componentId: number;
    timestamp: number;
};

// @public (undocumented)
export namespace DeleteComponentNetwork {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 16;
    // (undocumented)
    export function read(buf: ByteBuffer): DeleteComponentNetworkMessage | null;
    export function write(entity: Entity, componentId: number, timestamp: number, networkId: number, buf: ByteBuffer): void;
}

// @public (undocumented)
export type DeleteComponentNetworkMessage = CrdtMessageHeader & DeleteComponentNetworkMessageBody;

// @public (undocumented)
export type DeleteComponentNetworkMessageBody = {
    type: CrdtMessageType.DELETE_COMPONENT_NETWORK;
    entityId: Entity;
    componentId: number;
    timestamp: number;
    networkId: number;
};

// @public (undocumented)
export namespace DeleteEntity {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 4;
    // (undocumented)
    export function read(buf: ByteBuffer): DeleteEntityMessage | null;
    // (undocumented)
    export function write(entity: Entity, buf: ByteBuffer): void;
}

// @public (undocumented)
export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;

// @public (undocumented)
export type DeleteEntityMessageBody = {
    type: CrdtMessageType.DELETE_ENTITY;
    entityId: Entity;
};

// @public (undocumented)
export namespace DeleteEntityNetwork {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 8;
    // (undocumented)
    export function read(buf: ByteBuffer): DeleteEntityNetworkMessage | null;
    // (undocumented)
    export function write(entity: Entity, networkId: number, buf: ByteBuffer): void;
}

// @public (undocumented)
export type DeleteEntityNetworkMessage = CrdtMessageHeader & DeleteEntityNetworkMessageBody;

// @public (undocumented)
export type DeleteEntityNetworkMessageBody = {
    type: CrdtMessageType.DELETE_ENTITY_NETWORK;
    entityId: Entity;
    networkId: number;
};

// @public (undocumented)
export type DisplayType = 'flex' | 'none';

// Warning: (tsdoc-html-tag-missing-string) The HTML element has an invalid attribute: Expecting an HTML string starting with a single-quote or double-quote character
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-undefined-tag) The TSDoc tag "@category" is not defined in this configuration
//
// @public
export function Dropdown(props: UiDropdownProps): ReactEcs.JSX.Element;

// @public (undocumented)
export const enum EasingFunction {
    // (undocumented)
    EF_EASEBACK = 30,
    // (undocumented)
    EF_EASEBOUNCE = 15,
    // (undocumented)
    EF_EASECIRC = 27,
    // (undocumented)
    EF_EASECUBIC = 18,
    // (undocumented)
    EF_EASEELASTIC = 12,
    // (undocumented)
    EF_EASEEXPO = 9,
    // (undocumented)
    EF_EASEINBACK = 28,
    // (undocumented)
    EF_EASEINBOUNCE = 13,
    // (undocumented)
    EF_EASEINCIRC = 25,
    // (undocumented)
    EF_EASEINCUBIC = 16,
    // (undocumented)
    EF_EASEINELASTIC = 10,
    // (undocumented)
    EF_EASEINEXPO = 7,
    // (undocumented)
    EF_EASEINQUAD = 1,
    // (undocumented)
    EF_EASEINQUART = 19,
    // (undocumented)
    EF_EASEINQUINT = 22,
    // (undocumented)
    EF_EASEINSINE = 4,
    // (undocumented)
    EF_EASEOUTBACK = 29,
    // (undocumented)
    EF_EASEOUTBOUNCE = 14,
    // (undocumented)
    EF_EASEOUTCIRC = 26,
    // (undocumented)
    EF_EASEOUTCUBIC = 17,
    // (undocumented)
    EF_EASEOUTELASTIC = 11,
    // (undocumented)
    EF_EASEOUTEXPO = 8,
    // (undocumented)
    EF_EASEOUTQUAD = 2,
    // (undocumented)
    EF_EASEOUTQUART = 20,
    // (undocumented)
    EF_EASEOUTQUINT = 23,
    // (undocumented)
    EF_EASEOUTSINE = 5,
    // (undocumented)
    EF_EASEQUAD = 3,
    // (undocumented)
    EF_EASEQUART = 21,
    // (undocumented)
    EF_EASEQUINT = 24,
    // (undocumented)
    EF_EASESINE = 6,
    EF_LINEAR = 0
}

// @public (undocumented)
export interface EcsElements {
    // (undocumented)
    entity: Partial<EntityComponents> & {
        children?: ReactEcs.JSX.ReactNode;
        key?: Key;
    };
}

// @public @deprecated
export function Engine(options?: IEngineOptions): IEngine;

// Warning: (tsdoc-at-sign-in-word) The "@" character looks like part of a TSDoc tag; use a backslash to escape it
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
//
// @public
export const engine: IEngine;

// @public (undocumented)
export const EngineInfo: LastWriteWinElementSetComponentDefinition<PBEngineInfo>;

// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-malformed-html-name) Invalid HTML element: Expecting an HTML name
// Warning: (tsdoc-malformed-html-name) Invalid HTML element: A space is not allowed here
//
// @public
export type Entity = number & {
    __entity_type: '';
};

// @public (undocumented)
export type EntityComponents = {
    uiTransform: PBUiTransform;
    uiText: PBUiText;
    uiBackground: PBUiBackground;
    uiInput: PBUiInput;
    uiDropdown: PBUiDropdown;
    onMouseDown: Callback;
    onMouseUp: Callback;
    onMouseEnter: Callback;
    onMouseLeave: Callback;
};

// @public (undocumented)
export enum EntityMappingMode {
    // (undocumented)
    EMM_DIRECT_MAPPING = 2,
    // (undocumented)
    EMM_NEXT_AVAILABLE = 1,
    // (undocumented)
    EMM_NONE = 0
}

// @public
export interface EntityPropTypes extends Listeners {
    key?: Key;
    uiBackground?: UiBackgroundProps;
    uiTransform?: UiTransformProps;
}

// @public (undocumented)
export enum EntityState {
    Removed = 2,
    Reserved = 3,
    // (undocumented)
    Unknown = 0,
    UsedEntity = 1
}

// @public (undocumented)
export namespace EntityUtils {
    // (undocumented)
    export function fromEntityId(entityId: Entity): [number, number];
    // (undocumented)
    export function toEntityId(entityNumber: number, entityVersion: number): Entity;
}

// @public
export const Epsilon = 0.000001;

// @public (undocumented)
export type EventSystemCallback = (event: PBPointerEventsResult) => void;

// @public (undocumented)
export type EventSystemOptions = {
    button: InputAction;
    hoverText?: string;
    maxDistance?: number;
    showFeedback?: boolean;
    showHighlight?: boolean;
};

// @public
export type ExcludeUndefined<T> = {
    [P in keyof T]: undefined extends T[P] ? never : P;
}[keyof T];

// @public
export const executeTask: (task: Task<unknown>) => void;

// @public (undocumented)
export type FlexDirectionType = 'row' | 'column' | 'column-reverse' | 'row-reverse';

// @public (undocumented)
export type FlexWrapType = 'wrap' | 'nowrap' | 'wrap-reverse';

// @public (undocumented)
export type FloatArray = number[];

// @public (undocumented)
export const enum Font {
    // (undocumented)
    F_MONOSPACE = 2,
    // (undocumented)
    F_SANS_SERIF = 0,
    // (undocumented)
    F_SERIF = 1
}

// @public
export function getComponentEntityTree<T>(engine: Pick<IEngine, 'getEntitiesWith'>, entity: Entity, component: ComponentDefinition<T & {
    parent?: Entity;
}>): Generator<Entity>;

// @public @deprecated (undocumented)
export function getCompositeRootComponent(engine: IEngine): LastWriteWinElementSetComponentDefinition<CompositeRootType>;

// Warning: (ae-missing-release-tag) "getDefaultOpts" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const getDefaultOpts: (opts?: Partial<EventSystemOptions>) => EventSystemOptions;

// Warning: (ae-missing-release-tag) "GlobalDirectionRaycastOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type GlobalDirectionRaycastOptions = RaycastSystemOptions & GlobalDirectionRaycastSystemOptions;

// Warning: (ae-missing-release-tag) "GlobalDirectionRaycastSystemOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type GlobalDirectionRaycastSystemOptions = {
    direction?: PBVector3;
};

// Warning: (ae-missing-release-tag) "GlobalTargetRaycastOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type GlobalTargetRaycastOptions = RaycastSystemOptions & GlobalTargetRaycastSystemOptions;

// Warning: (ae-missing-release-tag) "GlobalTargetRaycastSystemOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type GlobalTargetRaycastSystemOptions = {
    target?: PBVector3;
};

// @public (undocumented)
export const GltfContainer: LastWriteWinElementSetComponentDefinition<PBGltfContainer>;

// @public (undocumented)
export const GltfContainerLoadingState: LastWriteWinElementSetComponentDefinition<PBGltfContainerLoadingState>;

// @public (undocumented)
export const GltfNodeModifiers: LastWriteWinElementSetComponentDefinition<PBGltfNodeModifiers>;

// @public (undocumented)
export interface GrowOnlyValueSetComponentDefinition<T> extends BaseComponent<T> {
    addValue(entity: Entity, val: DeepReadonly<T>): DeepReadonlySet<T>;
    // (undocumented)
    readonly componentType: ComponentType.GrowOnlyValueSet;
    get(entity: Entity): DeepReadonlySet<T>;
}

// Warning: (ae-missing-release-tag) "GSetComponentGetter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type GSetComponentGetter<T extends GrowOnlyValueSetComponentDefinition<any>> = (engine: Pick<IEngine, 'defineValueSetComponentFromSchema'>) => T;

// @public (undocumented)
export interface IEngine {
    addEntity(): Entity;
    addSystem(system: SystemFn, priority?: number, name?: string): void;
    // @alpha (undocumented)
    addTransport(transport: Transport): void;
    readonly CameraEntity: Entity;
    componentsIter(): Iterable<ComponentDefinition<unknown>>;
    defineComponent<T extends Spec>(componentName: string, spec: T, constructorDefault?: Partial<MapResult<T>>): MapComponentDefinition<MapResult<T>>;
    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): LastWriteWinElementSetComponentDefinition<T>;
    defineValueSetComponentFromSchema<T>(componentName: string, spec: ISchema<T>, options: ValueSetOptions<T>): GrowOnlyValueSetComponentDefinition<T>;
    getComponent<T>(componentId: number | string): ComponentDefinition<T>;
    getComponentOrNull<T>(componentId: number | string): ComponentDefinition<T> | null;
    getEntitiesByTag(tagName: string): Iterable<Entity>;
    getEntitiesWith<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]>(...components: T): Iterable<[Entity, ...ReadonlyComponentSchema<T>]>;
    getEntityByName<T = never, K = T>(value: K & (T extends never ? never : string)): Entity;
    // @alpha
    getEntityOrNullByName<T = string>(label: T): Entity | null;
    getEntityState(entity: Entity): EntityState;
    // (undocumented)
    _id: number;
    readonly PlayerEntity: Entity;
    registerComponentDefinition<T>(componentName: string, componentDefinition: ComponentDefinition<T>): ComponentDefinition<T>;
    // (undocumented)
    removeComponentDefinition(componentId: number | string): void;
    removeEntity(entity: Entity): void;
    removeEntityWithChildren(entity: Entity): void;
    removeSystem(selector: string | SystemFn): boolean;
    readonly RootEntity: Entity;
    seal(): void;
    // (undocumented)
    update(deltaTime: number): Promise<void>;
}

// @public (undocumented)
export interface IEngineOptions {
    // (undocumented)
    entityContainer?: IEntityContainer;
    // (undocumented)
    onChangeFunction: OnChangeFunction;
}

// @public (undocumented)
export type IEntityContainer = {
    generateEntity(networked?: boolean): Entity;
    removeEntity(entity: Entity): boolean;
    getEntityState(entity: Entity): EntityState;
    getExistingEntities(): Set<Entity>;
    releaseRemovedEntities(): Entity[];
    updateRemovedEntity(entity: Entity): boolean;
    updateUsedEntity(entity: Entity): boolean;
};

// @public (undocumented)
export type IEventNames = keyof IEvents;

// @public
export interface IEvents {
    comms: {
        sender: string;
        message: string;
    };
    onEnterScene: {
        userId: string;
    };
    onLeaveScene: {
        userId: string;
    };
    onRealmChanged: {
        domain: string;
        room: string;
        serverName: string;
        displayName: string;
    };
    playerClicked: {
        userId: string;
        ray: {
            origin: Vector3Type;
            direction: Vector3Type;
            distance: number;
        };
    };
    playerConnected: {
        userId: string;
    };
    playerDisconnected: {
        userId: string;
    };
    // (undocumented)
    playerExpression: {
        expressionId: string;
    };
    profileChanged: {
        ethAddress: string;
        version: number;
    };
    sceneStart: unknown;
    videoEvent: {
        componentId: string;
        videoClipId: string;
        videoStatus: number;
        currentOffset: number;
        totalVideoLength: number;
    };
}

// @public (undocumented)
export type IInputSystem = {
    isTriggered: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => boolean;
    isPressed: (inputAction: InputAction) => boolean;
    getInputCommand: (inputAction: InputAction, pointerEventType: PointerEventType, entity?: Entity) => PBPointerEventsResult | null;
};

// @public
export type IncludeUndefined<T> = {
    [P in keyof T]: undefined extends T[P] ? P : never;
}[keyof T];

// Warning: (ae-missing-release-tag) "INetowrkEntity" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type INetowrkEntity = LastWriteWinElementSetComponentDefinition<INetowrkEntityType>;

// Warning: (ae-missing-release-tag) "INetowrkEntityType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface INetowrkEntityType {
    // (undocumented)
    entityId: Entity;
    // (undocumented)
    networkId: number;
}

// Warning: (ae-missing-release-tag) "INetowrkParent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type INetowrkParent = LastWriteWinElementSetComponentDefinition<INetowrkParentType>;

// Warning: (ae-missing-release-tag) "INetowrkParentType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface INetowrkParentType {
    // (undocumented)
    entityId: Entity;
    // (undocumented)
    networkId: number;
}

// Warning: (tsdoc-html-tag-missing-string) The HTML element has an invalid attribute: Expecting an HTML string starting with a single-quote or double-quote character
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-undefined-tag) The TSDoc tag "@category" is not defined in this configuration
//
// @public
export function Input(props: EntityPropTypes & Partial<UiInputProps>): ReactEcs.JSX.Element;

// @public (undocumented)
export const enum InputAction {
    // (undocumented)
    IA_ACTION_3 = 10,
    // (undocumented)
    IA_ACTION_4 = 11,
    // (undocumented)
    IA_ACTION_5 = 12,
    // (undocumented)
    IA_ACTION_6 = 13,
    // (undocumented)
    IA_ANY = 3,
    // (undocumented)
    IA_BACKWARD = 5,
    // (undocumented)
    IA_FORWARD = 4,
    // (undocumented)
    IA_JUMP = 8,
    // (undocumented)
    IA_LEFT = 7,
    // (undocumented)
    IA_POINTER = 0,
    // (undocumented)
    IA_PRIMARY = 1,
    // (undocumented)
    IA_RIGHT = 6,
    // (undocumented)
    IA_SECONDARY = 2,
    // (undocumented)
    IA_WALK = 9
}

// Warning: (ae-missing-release-tag) "InputModifier" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const InputModifier: InputModifierComponentDefinitionExtended;

// @public (undocumented)
export interface InputModifierComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBInputModifier> {
    Mode: InputModifierHelper;
}

// @public (undocumented)
export interface InputModifierHelper {
    // (undocumented)
    Standard: (standard: PBInputModifier_StandardInput) => PBInputModifier['mode'];
}

// @public
export const inputSystem: IInputSystem;

// @public (undocumented)
export type InstanceCompositeOptions = {
    entityMapping?: {
        type: EntityMappingMode.EMM_NEXT_AVAILABLE;
        getNextAvailableEntity: () => Entity | null;
    } | {
        type: EntityMappingMode.EMM_DIRECT_MAPPING;
        getCompositeEntity: (compositeEntity: Entity | number) => Entity;
    };
    rootEntity?: Entity;
    alreadyRequestedSrc?: Set<string>;
};

// @public (undocumented)
export interface ISchema<T = any> {
    // (undocumented)
    create(): T;
    // (undocumented)
    deserialize(reader: ByteBuffer): T;
    // (undocumented)
    extend?: (base: Partial<DeepReadonly<T>> | undefined) => T;
    // (undocumented)
    jsonSchema: JsonSchemaExtended;
    // (undocumented)
    serialize(value: DeepReadonly<T>, builder: ByteBuffer): void;
}

// Warning: (ae-missing-release-tag) "isEqual" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export function isEqual(p1: Coords, p2: Coords): boolean;

// Warning: (ae-missing-release-tag) "ISyncComponents" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type ISyncComponents = LastWriteWinElementSetComponentDefinition<ISyncComponentsType>;

// Warning: (ae-missing-release-tag) "ISyncComponentsType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface ISyncComponentsType {
    // (undocumented)
    componentIds: number[];
}

// @public (undocumented)
export type JsonArray = Array<JsonPrimitive | JsonMap | JsonArray>;

// @public (undocumented)
export type JsonMap = {
    [key: string]: JsonPrimitive | JsonMap | JsonArray;
};

// @public (undocumented)
export type JsonPrimitive = string | number | boolean | null;

// @public
export type JsonSchemaExtended = {
    type: 'object' | 'number' | 'integer' | 'string' | 'array' | 'boolean';
    serializationType: 'boolean' | 'enum-int' | 'enum-string' | 'int8' | 'int16' | 'int32' | 'int64' | 'float32' | 'float64' | 'vector3' | 'color3' | 'quaternion' | 'color4' | 'map' | 'optional' | 'entity' | 'array' | 'utf8-string' | 'protocol-buffer' | 'transform' | 'one-of' | 'unknown';
} & JsonMap;

// Warning: (tsdoc-undefined-tag) The TSDoc tag "@hidden" is not defined in this configuration
// Warning: (ae-missing-release-tag) "JSX" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export namespace JSX {
    // (undocumented)
    export interface Component {
    }
    // (undocumented)
    export interface Element extends ReactElement<any, any> {
    }
    // (undocumented)
    export interface IntrinsicElements extends EcsElements {
    }
}

// @public (undocumented)
export type JSXElementConstructor<P> = (props: P) => ReactElement<any, any> | null;

// @public (undocumented)
export type JustifyType = 'flex-start' | 'center' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly';

// @public
export type Key = number | string;

// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-html-tag-missing-string) The HTML element has an invalid attribute: Expecting an HTML string starting with a single-quote or double-quote character
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
// Warning: (tsdoc-undefined-tag) The TSDoc tag "@category" is not defined in this configuration
//
// @public
export function Label(props: EntityPropTypes & UiLabelProps): ReactEcs.JSX.Element;

// @public (undocumented)
export interface LastWriteWinElementSetComponentDefinition<T> extends BaseComponent<T> {
    // (undocumented)
    readonly componentType: ComponentType.LastWriteWinElementSet;
    create(entity: Entity, val?: T): T;
    createOrReplace(entity: Entity, val?: T): T;
    deleteFrom(entity: Entity): T | null;
    get(entity: Entity): DeepReadonly<T>;
    getMutable(entity: Entity): T;
    getMutableOrNull(entity: Entity): T | null;
    getOrCreateMutable(entity: Entity, initialValue?: T): T;
    getOrNull(entity: Entity): DeepReadonly<T> | null;
}

// Warning: (ae-missing-release-tag) "LightSource" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const LightSource: LightSourceComponentDefinitionExtended;

// @public (undocumented)
export interface LightSourceComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBLightSource> {
    Type: LightSourceHelper;
}

// @public (undocumented)
export interface LightSourceHelper {
    // (undocumented)
    Point: (point: PBLightSource_Point) => PBLightSource['type'];
    // (undocumented)
    Spot: (spot: PBLightSource_Spot) => PBLightSource['type'];
}

// @public
export type Listeners = {
    onMouseDown?: Callback;
    onMouseUp?: Callback;
    onMouseEnter?: Callback;
    onMouseLeave?: Callback;
};

// @public (undocumented)
export const enum LoadingState {
    // (undocumented)
    FINISHED = 4,
    // (undocumented)
    FINISHED_WITH_ERROR = 3,
    // (undocumented)
    LOADING = 1,
    // (undocumented)
    NOT_FOUND = 2,
    // (undocumented)
    UNKNOWN = 0
}

// Warning: (ae-missing-release-tag) "LocalDirectionRaycastOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type LocalDirectionRaycastOptions = RaycastSystemOptions & LocalDirectionRaycastSystemOptions;

// Warning: (ae-missing-release-tag) "LocalDirectionRaycastSystemOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type LocalDirectionRaycastSystemOptions = {
    direction?: PBVector3;
};

// Warning: (ae-missing-release-tag) "LwwComponentGetter" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type LwwComponentGetter<T extends LastWriteWinElementSetComponentDefinition<any>> = (engine: Pick<IEngine, 'defineComponentFromSchema'>) => T;

// @public (undocumented)
export const MainCamera: LastWriteWinElementSetComponentDefinition<PBMainCamera>;

// @public
export interface MapComponentDefinition<T> extends LastWriteWinElementSetComponentDefinition<T> {
    create(entity: Entity, val?: Partial<T>): T;
    createOrReplace(entity: Entity, val?: Partial<T>): T;
}

// @public (undocumented)
export type MapResult<T extends Spec> = ToOptional<{
    [K in keyof T]: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? MapResult<T[K]> : never;
}>;

// Warning: (ae-missing-release-tag) "Material" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Material: MaterialComponentDefinitionExtended;

// @public (undocumented)
export interface MaterialComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBMaterial> {
    setBasicMaterial: (entity: Entity, material: PBMaterial_UnlitMaterial) => void;
    setPbrMaterial: (entity: Entity, material: PBMaterial_PbrMaterial) => void;
    Texture: TextureHelper;
}

// @public (undocumented)
export const enum MaterialTransparencyMode {
    // (undocumented)
    MTM_ALPHA_BLEND = 2,
    // (undocumented)
    MTM_ALPHA_TEST = 1,
    // (undocumented)
    MTM_ALPHA_TEST_AND_ALPHA_BLEND = 3,
    // (undocumented)
    MTM_AUTO = 4,
    // (undocumented)
    MTM_OPAQUE = 0
}

// @public
export namespace Matrix {
    export function add(self: ReadonlyMatrix, other: ReadonlyMatrix): MutableMatrix;
    export function addAtIndex(self: MutableMatrix, index: number, value: number): void;
    export function addToRef(self: ReadonlyMatrix, other: ReadonlyMatrix, result: MutableMatrix): void;
    export function addToSelf(self: MutableMatrix, other: ReadonlyMatrix): void;
    export function asArray(self: ReadonlyMatrix): Matrix4x4;
    export function clone(self: ReadonlyMatrix): MutableMatrix;
    export function compose(scale: Vector3.ReadonlyVector3, rotation: Quaternion.ReadonlyQuaternion, translation: Vector3.ReadonlyVector3): MutableMatrix;
    export function composeToRef(scale: Vector3.ReadonlyVector3, rotation: Quaternion.ReadonlyQuaternion, translation: Vector3.ReadonlyVector3, result: MutableMatrix): void;
    export function copy(from: ReadonlyMatrix, dest: MutableMatrix): void;
    export function copyToArray(self: ReadonlyMatrix, arrayDest: FloatArray, offsetDest?: number): void;
    export function create(): MutableMatrix;
    export function decompose(self: ReadonlyMatrix, scale?: Vector3.MutableVector3, rotation?: Quaternion.MutableQuaternion, translation?: Vector3.MutableVector3): boolean;
    export function decomposeLerp(startValue: ReadonlyMatrix, endValue: ReadonlyMatrix, gradient: number): MutableMatrix;
    export function decomposeLerpToRef(startValue: ReadonlyMatrix, endValue: ReadonlyMatrix, gradient: number, result: MutableMatrix): void;
    export function determinant(self: ReadonlyMatrix): number;
    export function equals(self: ReadonlyMatrix, value: ReadonlyMatrix): boolean;
    export function fromArray(array: Matrix4x4, offset?: number): MutableMatrix;
    export function fromArrayToRef(array: Matrix4x4, offset: number, result: MutableMatrix): void;
    export function fromFloatArrayToRefScaled(array: FloatArray, offset: number, scale: number, result: MutableMatrix): void;
    export function fromQuaternionToRef(quat: Quaternion.ReadonlyQuaternion, result: MutableMatrix): void;
    export function fromValues(initialM11: number, initialM12: number, initialM13: number, initialM14: number, initialM21: number, initialM22: number, initialM23: number, initialM24: number, initialM31: number, initialM32: number, initialM33: number, initialM34: number, initialM41: number, initialM42: number, initialM43: number, initialM44: number): MutableMatrix;
    export function fromValuesToRef(initialM11: number, initialM12: number, initialM13: number, initialM14: number, initialM21: number, initialM22: number, initialM23: number, initialM24: number, initialM31: number, initialM32: number, initialM33: number, initialM34: number, initialM41: number, initialM42: number, initialM43: number, initialM44: number, result: MutableMatrix): void;
    export function fromXYZAxesToRef(xaxis: Vector3.ReadonlyVector3, yaxis: Vector3.ReadonlyVector3, zaxis: Vector3.ReadonlyVector3, result: MutableMatrix): void;
    export function GetAsMatrix2x2(matrix: ReadonlyMatrix): FloatArray;
    export function GetAsMatrix3x3(matrix: ReadonlyMatrix): FloatArray;
    export function getHashCode(self: ReadonlyMatrix): number;
    export function getRotationMatrix(self: ReadonlyMatrix): MutableMatrix;
    export function getRotationMatrixToRef(self: ReadonlyMatrix, result: MutableMatrix): void;
    export function getTranslation(self: MutableMatrix): Vector3.MutableVector3;
    export function getTranslationToRef(self: MutableMatrix, result: Vector3.MutableVector3): void;
    export function Identity(): MutableMatrix;
    export function IdentityReadonly(): ReadonlyMatrix;
    export function IdentityToRef(result: MutableMatrix): void;
    export function invert(source: ReadonlyMatrix): MutableMatrix;
    export function invertToRef(source: ReadonlyMatrix, result: MutableMatrix): void;
    export function isIdentityAs3x2Update(self: MutableMatrix): boolean;
    export function isIdentityUpdate(self: MutableMatrix): boolean;
    export function lerp(startValue: ReadonlyMatrix, endValue: ReadonlyMatrix, gradient: number): MutableMatrix;
    export function lerpToRef(startValue: ReadonlyMatrix, endValue: ReadonlyMatrix, gradient: number, result: MutableMatrix): void;
    export function LookAtLH(eye: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, up: Vector3.ReadonlyVector3): MutableMatrix;
    export function lookAtLHToRef(eye: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, up: Vector3.ReadonlyVector3, result: MutableMatrix): void;
    export function lookAtRH(eye: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, up: Vector3.ReadonlyVector3): MutableMatrix;
    export function lookAtRHToRef(eye: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, up: Vector3.ReadonlyVector3, result: MutableMatrix): void;
    export function m(self: MutableMatrix): Matrix4x4;
    // (undocumented)
    export type Matrix4x4 = [
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number
    ];
    export function multiply(self: MutableMatrix, other: ReadonlyMatrix): MutableMatrix;
    export function multiplyAtIndex(self: MutableMatrix, index: number, value: number): MutableMatrix;
    export function multiplyToArray(self: ReadonlyMatrix, other: ReadonlyMatrix, result: FloatArray, offset: number): void;
    export function multiplyToRef(self: ReadonlyMatrix, other: ReadonlyMatrix, result: MutableMatrix): void;
    // (undocumented)
    export type MutableMatrix = {
        updateFlag: number;
        isIdentity: boolean;
        isIdentity3x2: boolean;
        _isIdentityDirty: boolean;
        _isIdentity3x2Dirty: boolean;
        _m: Matrix4x4;
    };
    export function normalMatrixToRef(self: ReadonlyMatrix, ref: MutableMatrix): void;
    export function orthoLH(width: number, height: number, znear: number, zfar: number): MutableMatrix;
    export function orthoLHToRef(width: number, height: number, znear: number, zfar: number, result: MutableMatrix): void;
    export function OrthoOffCenterLH(left: number, right: number, bottom: number, top: number, znear: number, zfar: number): MutableMatrix;
    export function orthoOffCenterLHToRef(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: MutableMatrix): void;
    export function orthoOffCenterRH(left: number, right: number, bottom: number, top: number, znear: number, zfar: number): MutableMatrix;
    export function orthoOffCenterRHToRef(left: number, right: number, bottom: number, top: number, znear: number, zfar: number, result: MutableMatrix): void;
    export function perspectiveFovLH(fov: number, aspect: number, znear: number, zfar: number): MutableMatrix;
    export function perspectiveFovLHToRef(fov: number, aspect: number, znear: number, zfar: number, result: MutableMatrix, isVerticalFovFixed?: boolean): void;
    export function PerspectiveFovRH(fov: number, aspect: number, znear: number, zfar: number): MutableMatrix;
    export function perspectiveFovRHToRef(fov: number, aspect: number, znear: number, zfar: number, result: MutableMatrix, isVerticalFovFixed?: boolean): void;
    export function perspectiveFovWebVRToRef(fov: {
        upDegrees: number;
        downDegrees: number;
        leftDegrees: number;
        rightDegrees: number;
    }, znear: number, zfar: number, result: MutableMatrix, rightHanded?: boolean): void;
    export function perspectiveLH(width: number, height: number, znear: number, zfar: number): MutableMatrix;
    // (undocumented)
    export type ReadonlyMatrix = {
        readonly updateFlag: number;
        readonly isIdentity: boolean;
        readonly isIdentity3x2: boolean;
        readonly _isIdentityDirty: boolean;
        readonly _isIdentity3x2Dirty: boolean;
        readonly _m: Matrix4x4;
    };
    export function reflection(plane: Plane.ReadonlyPlane): MutableMatrix;
    export function reflectionToRef(_plane: Plane.ReadonlyPlane, result: MutableMatrix): void;
    export function removeRotationAndScaling(self: MutableMatrix): MutableMatrix;
    export function reset(self: MutableMatrix): void;
    export function rotationAxis(axis: Vector3.ReadonlyVector3, angle: number): MutableMatrix;
    export function rotationAxisToRef(_axis: Vector3.ReadonlyVector3, angle: number, result: MutableMatrix): void;
    export function RotationX(angle: number): MutableMatrix;
    export function rotationXToRef(angle: number, result: MutableMatrix): void;
    export function rotationY(angle: number): MutableMatrix;
    export function rotationYawPitchRoll(yaw: number, pitch: number, roll: number): MutableMatrix;
    export function rotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: MutableMatrix): void;
    export function rotationYToRef(angle: number, result: MutableMatrix): void;
    export function rotationZ(angle: number): MutableMatrix;
    export function rotationZToRef(angle: number, result: MutableMatrix): void;
    export function scale(self: ReadonlyMatrix, scale: number): MutableMatrix;
    export function scaleAndAddToRef(self: ReadonlyMatrix, scale: number, result: MutableMatrix): void;
    export function scaleToRef(self: ReadonlyMatrix, scale: number, result: MutableMatrix): void;
    export function scaling(x: number, y: number, z: number): MutableMatrix;
    export function scalingToRef(x: number, y: number, z: number, result: MutableMatrix): void;
    export function setRowFromFloats(self: MutableMatrix, index: number, x: number, y: number, z: number, w: number): void;
    export function setTranslation(self: MutableMatrix, vector3: Vector3.ReadonlyVector3): void;
    export function setTranslationFromFloats(self: MutableMatrix, x: number, y: number, z: number): void;
    export function toArray(self: ReadonlyMatrix): Matrix4x4;
    export function toggleModelMatrixHandInPlace(self: MutableMatrix): void;
    export function toggleProjectionMatrixHandInPlace(self: MutableMatrix): void;
    export function translation(x: number, y: number, z: number): MutableMatrix;
    export function translationToRef(x: number, y: number, z: number, result: MutableMatrix): void;
    export function transpose(matrix: ReadonlyMatrix): MutableMatrix;
    export function transposeToRef(matrix: ReadonlyMatrix, result: MutableMatrix): void;
    export function Zero(): MutableMatrix;
}

// @public (undocumented)
export const enum MediaState {
    // (undocumented)
    MS_BUFFERING = 5,
    // (undocumented)
    MS_ERROR = 1,
    // (undocumented)
    MS_LOADING = 2,
    // (undocumented)
    MS_NONE = 0,
    // (undocumented)
    MS_PAUSED = 7,
    // (undocumented)
    MS_PLAYING = 4,
    // (undocumented)
    MS_READY = 3,
    // (undocumented)
    MS_SEEKING = 6
}

// Warning: (ae-missing-release-tag) "MeshCollider" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const MeshCollider: MeshColliderComponentDefinitionExtended;

// @public (undocumented)
export interface MeshColliderComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBMeshCollider> {
    setBox(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
    setCylinder(entity: Entity, radiusBottom?: number, radiusTop?: number, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
    setPlane(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
    setSphere(entity: Entity, colliderLayers?: ColliderLayer | ColliderLayer[]): void;
}

// Warning: (ae-missing-release-tag) "MeshRenderer" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const MeshRenderer: MeshRendererComponentDefinitionExtended;

// @public (undocumented)
export interface MeshRendererComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBMeshRenderer> {
    setBox(entity: Entity, uvs?: number[]): void;
    setCylinder(entity: Entity, radiusBottom?: number, radiusTop?: number): void;
    setPlane(entity: Entity, uvs?: number[]): void;
    setSphere(entity: Entity): void;
}

// @alpha @deprecated (undocumented)
export class MessageBus {
    constructor();
    // (undocumented)
    emit(message: string, payload: Record<any, any>): void;
    // (undocumented)
    on(message: string, callback: (value: any, sender: string) => void): Observer<IEvents['comms']>;
}

// @public (undocumented)
export interface Move {
    // (undocumented)
    end: PBVector3 | undefined;
    // (undocumented)
    faceDirection?: boolean | undefined;
    // (undocumented)
    start: PBVector3 | undefined;
}

// @public (undocumented)
export namespace Move {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): Move;
    // (undocumented)
    export function encode(message: Move, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface MoveContinuous {
    // (undocumented)
    direction: PBVector3 | undefined;
    // (undocumented)
    speed: number;
}

// @public (undocumented)
export namespace MoveContinuous {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): MoveContinuous;
    // (undocumented)
    export function encode(message: MoveContinuous, writer?: _m0.Writer): _m0.Writer;
}

// Warning: (ae-missing-release-tag) "Name" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Name: NameComponent;

// Warning: (ae-missing-release-tag) "NameComponent" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type NameComponent = LastWriteWinElementSetComponentDefinition<NameType>;

// Warning: (ae-missing-release-tag) "NameType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface NameType {
    // (undocumented)
    value: string;
}

// @alpha
export const NetworkEntity: INetowrkEntity;

// @alpha
export const NetworkParent: INetowrkParent;

// @public (undocumented)
export const enum NftFrameType {
    // (undocumented)
    NFT_BAROQUE_ORNAMENT = 1,
    // (undocumented)
    NFT_BLOCKY = 5,
    // (undocumented)
    NFT_CANVAS = 21,
    // (undocumented)
    NFT_CLASSIC = 0,
    // (undocumented)
    NFT_DIAMOND_ORNAMENT = 2,
    // (undocumented)
    NFT_GOLD_CARVED = 7,
    // (undocumented)
    NFT_GOLD_EDGES = 6,
    // (undocumented)
    NFT_GOLD_ROUNDED = 9,
    // (undocumented)
    NFT_GOLD_WIDE = 8,
    // (undocumented)
    NFT_METAL_MEDIUM = 10,
    // (undocumented)
    NFT_METAL_ROUNDED = 13,
    // (undocumented)
    NFT_METAL_SLIM = 12,
    // (undocumented)
    NFT_METAL_WIDE = 11,
    // (undocumented)
    NFT_MINIMAL_BLACK = 15,
    // (undocumented)
    NFT_MINIMAL_GREY = 4,
    // (undocumented)
    NFT_MINIMAL_WHITE = 16,
    // (undocumented)
    NFT_MINIMAL_WIDE = 3,
    // (undocumented)
    NFT_NONE = 22,
    // (undocumented)
    NFT_PINS = 14,
    // (undocumented)
    NFT_TAPE = 17,
    // (undocumented)
    NFT_WOOD_SLIM = 18,
    // (undocumented)
    NFT_WOOD_TWIGS = 20,
    // (undocumented)
    NFT_WOOD_WIDE = 19
}

// @public (undocumented)
export const NftShape: LastWriteWinElementSetComponentDefinition<PBNftShape>;

// @public @deprecated
export class Observable<T> {
    constructor(onObserverAdded?: (observer: Observer<T>) => void);
    add(callback: (eventData: T, eventState: ObserverEventState) => void, mask?: number, insertFirst?: boolean, scope?: any, unregisterOnFirstCall?: boolean): null | Observer<T>;
    addOnce(callback: (eventData: T, eventState: ObserverEventState) => void): null | Observer<T>;
    clear(): void;
    clone(): Observable<T>;
    hasObservers(): boolean;
    hasSpecificMask(mask?: number): boolean;
    notifyObserver(observer: Observer<T>, eventData: T, mask?: number): void;
    notifyObservers(eventData: T, mask?: number, target?: any, currentTarget?: any): boolean;
    notifyObserversWithPromise(eventData: T, mask?: number, target?: any, currentTarget?: any): Promise<T>;
    remove(observer: null | Observer<T>): boolean;
    removeCallback(callback: (eventData: T, eventState: ObserverEventState) => void, scope?: any): boolean;
}

// @public @deprecated
export class Observer<T> {
    constructor(
    callback: (eventData: T, eventState: ObserverEventState) => void,
    mask: number,
    scope?: any);
    callback: (eventData: T, eventState: ObserverEventState) => void;
    mask: number;
    scope: any;
    unregisterOnNextCall: boolean;
    _willBeUnregistered: boolean;
}

// @public @deprecated
export class ObserverEventState {
    constructor(mask: number, skipNextObservers?: boolean, target?: any, currentTarget?: any);
    currentTarget?: any;
    initalize(mask: number, skipNextObservers?: boolean, target?: any, currentTarget?: any): ObserverEventState;
    lastReturnValue?: any;
    mask: number;
    skipNextObservers: boolean;
    target?: any;
}

// @public (undocumented)
export type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>, componentValue?: any) => void;

// @public @deprecated (undocumented)
export const onEnterScene: Observable<{
    userId: string;
}>;

// @public @deprecated
export const onEnterSceneObservable: Observable<{
    userId: string;
}>;

// @public @deprecated (undocumented)
export const onLeaveScene: Observable<{
    userId: string;
}>;

// @public @deprecated
export const onLeaveSceneObservable: Observable<{
    userId: string;
}>;

// @public (undocumented)
export type OnlyNonUndefinedTypes<T> = {
    [K in ExcludeUndefined<T>]: T[K];
};

// @public (undocumented)
export type OnlyOptionalUndefinedTypes<T> = {
    [K in IncludeUndefined<T>]?: T[K];
};

// @public @deprecated (undocumented)
export const onPlayerClickedObservable: Observable<{
    userId: string;
    ray: {
        origin: Vector3Type;
        direction: Vector3Type;
        distance: number;
    };
}>;

// @public @deprecated (undocumented)
export const onPlayerConnectedObservable: Observable<{
    userId: string;
}>;

// @public @deprecated (undocumented)
export const onPlayerDisconnectedObservable: Observable<{
    userId: string;
}>;

// @public @deprecated (undocumented)
export const onPlayerExpressionObservable: Observable<{
    expressionId: string;
}>;

// @public @deprecated (undocumented)
export const onProfileChanged: Observable<{
    ethAddress: string;
    version: number;
}>;

// @public @deprecated (undocumented)
export const onRealmChangedObservable: Observable<{
    domain: string;
    room: string;
    serverName: string;
    displayName: string;
}>;

// @public @deprecated
export const onSceneReadyObservable: Observable<unknown>;

// Warning: (ae-missing-release-tag) "onUpdate" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export function onUpdate(deltaTime: number): Promise<void>;

// @public @deprecated (undocumented)
export const onVideoEvent: Observable<{
    componentId: string;
    videoClipId: string;
    videoStatus: number;
    currentOffset: number;
    totalVideoLength: number;
}>;

// @public
export type OverflowType = 'hidden' | 'scroll' | 'visible';

// @public (undocumented)
export interface PBAnimationState {
    clip: string;
    loop?: boolean | undefined;
    playing?: boolean | undefined;
    shouldReset?: boolean | undefined;
    speed?: number | undefined;
    weight?: number | undefined;
}

// @public (undocumented)
export namespace PBAnimationState {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAnimationState;
    // (undocumented)
    export function encode(message: PBAnimationState, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAnimator {
    states: PBAnimationState[];
}

// @public (undocumented)
export namespace PBAnimator {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAnimator;
    // (undocumented)
    export function encode(message: PBAnimator, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAudioEvent {
    // (undocumented)
    state: MediaState;
    timestamp: number;
}

// @public (undocumented)
export namespace PBAudioEvent {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAudioEvent;
    // (undocumented)
    export function encode(message: PBAudioEvent, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAudioSource {
    audioClipUrl: string;
    currentTime?: number | undefined;
    global?: boolean | undefined;
    loop?: boolean | undefined;
    pitch?: number | undefined;
    playing?: boolean | undefined;
    volume?: number | undefined;
}

// @public (undocumented)
export namespace PBAudioSource {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAudioSource;
    // (undocumented)
    export function encode(message: PBAudioSource, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAudioStream {
    playing?: boolean | undefined;
    spatial?: boolean | undefined;
    spatialMaxDistance?: number | undefined;
    spatialMinDistance?: number | undefined;
    url: string;
    volume?: number | undefined;
}

// @public (undocumented)
export namespace PBAudioStream {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAudioStream;
    // (undocumented)
    export function encode(message: PBAudioStream, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarAttach {
    anchorPointId: AvatarAnchorPointType;
    avatarId?: string | undefined;
}

// @public (undocumented)
export namespace PBAvatarAttach {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarAttach;
    // (undocumented)
    export function encode(message: PBAvatarAttach, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarBase {
    // (undocumented)
    bodyShapeUrn: string;
    // (undocumented)
    eyesColor: PBColor3 | undefined;
    // (undocumented)
    hairColor: PBColor3 | undefined;
    // (undocumented)
    name: string;
    // (undocumented)
    skinColor: PBColor3 | undefined;
}

// @public (undocumented)
export namespace PBAvatarBase {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarBase;
    // (undocumented)
    export function encode(message: PBAvatarBase, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarEmoteCommand {
    // (undocumented)
    emoteUrn: string;
    // (undocumented)
    loop: boolean;
    timestamp: number;
}

// @public (undocumented)
export namespace PBAvatarEmoteCommand {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarEmoteCommand;
    // (undocumented)
    export function encode(message: PBAvatarEmoteCommand, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarEquippedData {
    // (undocumented)
    emoteUrns: string[];
    // (undocumented)
    wearableUrns: string[];
}

// @public (undocumented)
export namespace PBAvatarEquippedData {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarEquippedData;
    // (undocumented)
    export function encode(message: PBAvatarEquippedData, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarModifierArea {
    area: PBVector3 | undefined;
    excludeIds: string[];
    modifiers: AvatarModifierType[];
}

// @public (undocumented)
export namespace PBAvatarModifierArea {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarModifierArea;
    // (undocumented)
    export function encode(message: PBAvatarModifierArea, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBAvatarShape {
    bodyShape?: string | undefined;
    emotes: string[];
    expressionTriggerId?: string | undefined;
    expressionTriggerTimestamp?: number | undefined;
    eyeColor?: PBColor3 | undefined;
    hairColor?: PBColor3 | undefined;
    id: string;
    name?: string | undefined;
    showOnlyWearables?: boolean | undefined;
    skinColor?: PBColor3 | undefined;
    talking?: boolean | undefined;
    wearables: string[];
}

// @public (undocumented)
export namespace PBAvatarShape {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBAvatarShape;
    // (undocumented)
    export function encode(message: PBAvatarShape, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBBillboard {
    billboardMode?: BillboardMode | undefined;
}

// @public (undocumented)
export namespace PBBillboard {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBBillboard;
    // (undocumented)
    export function encode(message: PBBillboard, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBCameraMode {
    mode: CameraType;
}

// @public (undocumented)
export namespace PBCameraMode {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraMode;
    // (undocumented)
    export function encode(message: PBCameraMode, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBCameraModeArea {
    area: PBVector3 | undefined;
    mode: CameraType;
}

// @public (undocumented)
export namespace PBCameraModeArea {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBCameraModeArea;
    // (undocumented)
    export function encode(message: PBCameraModeArea, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBColor3 {
    // (undocumented)
    b: number;
    // (undocumented)
    g: number;
    // (undocumented)
    r: number;
}

// @public (undocumented)
export namespace PBColor3 {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBColor3;
    // (undocumented)
    export function encode(message: PBColor3, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBColor4 {
    // (undocumented)
    a: number;
    // (undocumented)
    b: number;
    // (undocumented)
    g: number;
    // (undocumented)
    r: number;
}

// @public (undocumented)
export namespace PBColor4 {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBColor4;
    // (undocumented)
    export function encode(message: PBColor4, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBEngineInfo {
    frameNumber: number;
    tickNumber: number;
    totalRuntime: number;
}

// @public (undocumented)
export namespace PBEngineInfo {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBEngineInfo;
    // (undocumented)
    export function encode(message: PBEngineInfo, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBGltfContainer {
    invisibleMeshesCollisionMask?: number | undefined;
    src: string;
    visibleMeshesCollisionMask?: number | undefined;
}

// @public (undocumented)
export namespace PBGltfContainer {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfContainer;
    // (undocumented)
    export function encode(message: PBGltfContainer, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBGltfContainerLoadingState {
    // (undocumented)
    currentState: LoadingState;
}

// @public (undocumented)
export namespace PBGltfContainerLoadingState {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfContainerLoadingState;
    // (undocumented)
    export function encode(message: PBGltfContainerLoadingState, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBGltfNodeModifiers {
    // (undocumented)
    modifiers: PBGltfNodeModifiers_GltfNodeModifier[];
}

// @public (undocumented)
export namespace PBGltfNodeModifiers {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNodeModifiers;
    // (undocumented)
    export function encode(message: PBGltfNodeModifiers, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBGltfNodeModifiers_GltfNodeModifier {
    castShadows?: boolean | undefined;
    material?: PBMaterial | undefined;
    path: string;
}

// @public (undocumented)
export namespace PBGltfNodeModifiers_GltfNodeModifier {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBGltfNodeModifiers_GltfNodeModifier;
    // (undocumented)
    export function encode(message: PBGltfNodeModifiers_GltfNodeModifier, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBInputModifier {
    // (undocumented)
    mode?: {
        $case: "standard";
        standard: PBInputModifier_StandardInput;
    } | undefined;
}

// @public (undocumented)
export namespace PBInputModifier {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBInputModifier;
    // (undocumented)
    export function encode(message: PBInputModifier, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBInputModifier_StandardInput {
    // (undocumented)
    disableAll?: boolean | undefined;
    // (undocumented)
    disableEmote?: boolean | undefined;
    // (undocumented)
    disableJog?: boolean | undefined;
    // (undocumented)
    disableJump?: boolean | undefined;
    // (undocumented)
    disableRun?: boolean | undefined;
    // (undocumented)
    disableWalk?: boolean | undefined;
}

// @public (undocumented)
export namespace PBInputModifier_StandardInput {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBInputModifier_StandardInput;
    // (undocumented)
    export function encode(message: PBInputModifier_StandardInput, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBLightSource {
    active?: boolean | undefined;
    color?: PBColor3 | undefined;
    intensity?: number | undefined;
    range?: number | undefined;
    shadow?: boolean | undefined;
    shadowMaskTexture?: TextureUnion | undefined;
    // (undocumented)
    type?: {
        $case: "point";
        point: PBLightSource_Point;
    } | {
        $case: "spot";
        spot: PBLightSource_Spot;
    } | undefined;
}

// @public (undocumented)
export namespace PBLightSource {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBLightSource;
    // (undocumented)
    export function encode(message: PBLightSource, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBLightSource_Point {
}

// @public (undocumented)
export namespace PBLightSource_Point {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBLightSource_Point;
    // (undocumented)
    export function encode(_: PBLightSource_Point, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBLightSource_Spot {
    innerAngle?: number | undefined;
    outerAngle?: number | undefined;
}

// @public (undocumented)
export namespace PBLightSource_Spot {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBLightSource_Spot;
    // (undocumented)
    export function encode(message: PBLightSource_Spot, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMainCamera {
    virtualCameraEntity?: number | undefined;
}

// @public (undocumented)
export namespace PBMainCamera {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMainCamera;
    // (undocumented)
    export function encode(message: PBMainCamera, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMaterial {
    // (undocumented)
    material?: {
        $case: "unlit";
        unlit: PBMaterial_UnlitMaterial;
    } | {
        $case: "pbr";
        pbr: PBMaterial_PbrMaterial;
    } | undefined;
}

// @public (undocumented)
export namespace PBMaterial {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial;
    // (undocumented)
    export function encode(message: PBMaterial, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMaterial_PbrMaterial {
    albedoColor?: PBColor4 | undefined;
    alphaTest?: number | undefined;
    // @deprecated (undocumented)
    alphaTexture?: TextureUnion | undefined;
    bumpTexture?: TextureUnion | undefined;
    castShadows?: boolean | undefined;
    directIntensity?: number | undefined;
    emissiveColor?: PBColor3 | undefined;
    emissiveIntensity?: number | undefined;
    emissiveTexture?: TextureUnion | undefined;
    metallic?: number | undefined;
    reflectivityColor?: PBColor3 | undefined;
    roughness?: number | undefined;
    specularIntensity?: number | undefined;
    texture?: TextureUnion | undefined;
    transparencyMode?: MaterialTransparencyMode | undefined;
}

// @public (undocumented)
export namespace PBMaterial_PbrMaterial {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_PbrMaterial;
    // (undocumented)
    export function encode(message: PBMaterial_PbrMaterial, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMaterial_UnlitMaterial {
    alphaTest?: number | undefined;
    alphaTexture?: TextureUnion | undefined;
    castShadows?: boolean | undefined;
    diffuseColor?: PBColor4 | undefined;
    texture?: TextureUnion | undefined;
}

// @public (undocumented)
export namespace PBMaterial_UnlitMaterial {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMaterial_UnlitMaterial;
    // (undocumented)
    export function encode(message: PBMaterial_UnlitMaterial, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshCollider {
    collisionMask?: number | undefined;
    // (undocumented)
    mesh?: {
        $case: "box";
        box: PBMeshCollider_BoxMesh;
    } | {
        $case: "sphere";
        sphere: PBMeshCollider_SphereMesh;
    } | {
        $case: "cylinder";
        cylinder: PBMeshCollider_CylinderMesh;
    } | {
        $case: "plane";
        plane: PBMeshCollider_PlaneMesh;
    } | undefined;
}

// @public (undocumented)
export namespace PBMeshCollider {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider;
    // (undocumented)
    export function encode(message: PBMeshCollider, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshCollider_BoxMesh {
}

// @public (undocumented)
export namespace PBMeshCollider_BoxMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_BoxMesh;
    // (undocumented)
    export function encode(_: PBMeshCollider_BoxMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshCollider_CylinderMesh {
    radiusBottom?: number | undefined;
    radiusTop?: number | undefined;
}

// @public (undocumented)
export namespace PBMeshCollider_CylinderMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_CylinderMesh;
    // (undocumented)
    export function encode(message: PBMeshCollider_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshCollider_PlaneMesh {
}

// @public (undocumented)
export namespace PBMeshCollider_PlaneMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_PlaneMesh;
    // (undocumented)
    export function encode(_: PBMeshCollider_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshCollider_SphereMesh {
}

// @public (undocumented)
export namespace PBMeshCollider_SphereMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshCollider_SphereMesh;
    // (undocumented)
    export function encode(_: PBMeshCollider_SphereMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshRenderer {
    // (undocumented)
    mesh?: {
        $case: "box";
        box: PBMeshRenderer_BoxMesh;
    } | {
        $case: "sphere";
        sphere: PBMeshRenderer_SphereMesh;
    } | {
        $case: "cylinder";
        cylinder: PBMeshRenderer_CylinderMesh;
    } | {
        $case: "plane";
        plane: PBMeshRenderer_PlaneMesh;
    } | undefined;
}

// @public (undocumented)
export namespace PBMeshRenderer {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer;
    // (undocumented)
    export function encode(message: PBMeshRenderer, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshRenderer_BoxMesh {
    uvs: number[];
}

// @public (undocumented)
export namespace PBMeshRenderer_BoxMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_BoxMesh;
    // (undocumented)
    export function encode(message: PBMeshRenderer_BoxMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshRenderer_CylinderMesh {
    radiusBottom?: number | undefined;
    radiusTop?: number | undefined;
}

// @public (undocumented)
export namespace PBMeshRenderer_CylinderMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_CylinderMesh;
    // (undocumented)
    export function encode(message: PBMeshRenderer_CylinderMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshRenderer_PlaneMesh {
    uvs: number[];
}

// @public (undocumented)
export namespace PBMeshRenderer_PlaneMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_PlaneMesh;
    // (undocumented)
    export function encode(message: PBMeshRenderer_PlaneMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBMeshRenderer_SphereMesh {
}

// @public (undocumented)
export namespace PBMeshRenderer_SphereMesh {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBMeshRenderer_SphereMesh;
    // (undocumented)
    export function encode(_: PBMeshRenderer_SphereMesh, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBNftShape {
    color?: PBColor3 | undefined;
    style?: NftFrameType | undefined;
    urn: string;
}

// @public (undocumented)
export namespace PBNftShape {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBNftShape;
    // (undocumented)
    export function encode(message: PBNftShape, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPlayerIdentityData {
    address: string;
    // (undocumented)
    isGuest: boolean;
}

// @public (undocumented)
export namespace PBPlayerIdentityData {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPlayerIdentityData;
    // (undocumented)
    export function encode(message: PBPlayerIdentityData, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPointerEvents {
    pointerEvents: PBPointerEvents_Entry[];
}

// @public (undocumented)
export namespace PBPointerEvents {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents;
    // (undocumented)
    export function encode(message: PBPointerEvents, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPointerEvents_Entry {
    eventInfo: PBPointerEvents_Info | undefined;
    eventType: PointerEventType;
}

// @public (undocumented)
export namespace PBPointerEvents_Entry {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Entry;
    // (undocumented)
    export function encode(message: PBPointerEvents_Entry, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPointerEvents_Info {
    button?: InputAction | undefined;
    hoverText?: string | undefined;
    maxDistance?: number | undefined;
    showFeedback?: boolean | undefined;
    showHighlight?: boolean | undefined;
}

// @public (undocumented)
export namespace PBPointerEvents_Info {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEvents_Info;
    // (undocumented)
    export function encode(message: PBPointerEvents_Info, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPointerEventsResult {
    analog?: number | undefined;
    button: InputAction;
    // (undocumented)
    hit: RaycastHit | undefined;
    // (undocumented)
    state: PointerEventType;
    tickNumber: number;
    timestamp: number;
}

// @public (undocumented)
export namespace PBPointerEventsResult {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerEventsResult;
    // (undocumented)
    export function encode(message: PBPointerEventsResult, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPointerLock {
    isPointerLocked: boolean;
}

// @public (undocumented)
export namespace PBPointerLock {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPointerLock;
    // (undocumented)
    export function encode(message: PBPointerLock, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPosition {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
    // (undocumented)
    z: number;
}

// @public (undocumented)
export namespace PBPosition {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPosition;
    // (undocumented)
    export function encode(message: PBPosition, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBPrimaryPointerInfo {
    pointerType?: PointerType | undefined;
    screenCoordinates?: PBVector2 | undefined;
    screenDelta?: PBVector2 | undefined;
    worldRayDirection?: PBVector3 | undefined;
}

// @public (undocumented)
export namespace PBPrimaryPointerInfo {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBPrimaryPointerInfo;
    // (undocumented)
    export function encode(message: PBPrimaryPointerInfo, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBQuaternion {
    // (undocumented)
    w: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
    // (undocumented)
    z: number;
}

// @public (undocumented)
export namespace PBQuaternion {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBQuaternion;
    // (undocumented)
    export function encode(message: PBQuaternion, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBRaycast {
    collisionMask?: number | undefined;
    continuous?: boolean | undefined;
    // (undocumented)
    direction?: {
        $case: "localDirection";
        localDirection: PBVector3;
    } | {
        $case: "globalDirection";
        globalDirection: PBVector3;
    } | {
        $case: "globalTarget";
        globalTarget: PBVector3;
    } | {
        $case: "targetEntity";
        targetEntity: number;
    } | undefined;
    maxDistance: number;
    originOffset?: PBVector3 | undefined;
    queryType: RaycastQueryType;
    timestamp?: number | undefined;
}

// @public (undocumented)
export namespace PBRaycast {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycast;
    // (undocumented)
    export function encode(message: PBRaycast, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBRaycastResult {
    direction: PBVector3 | undefined;
    globalOrigin: PBVector3 | undefined;
    hits: RaycastHit[];
    tickNumber: number;
    timestamp?: number | undefined;
}

// @public (undocumented)
export namespace PBRaycastResult {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBRaycastResult;
    // (undocumented)
    export function encode(message: PBRaycastResult, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBRealmInfo {
    baseUrl: string;
    commsAdapter: string;
    isConnectedSceneRoom?: boolean | undefined;
    isPreview: boolean;
    networkId: number;
    realmName: string;
    room?: string | undefined;
}

// @public (undocumented)
export namespace PBRealmInfo {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBRealmInfo;
    // (undocumented)
    export function encode(message: PBRealmInfo, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBSkyboxTime {
    fixedTime: number;
    transitionMode?: TransitionMode | undefined;
}

// @public (undocumented)
export namespace PBSkyboxTime {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBSkyboxTime;
    // (undocumented)
    export function encode(message: PBSkyboxTime, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTextShape {
    font?: Font | undefined;
    fontAutoSize?: boolean | undefined;
    fontSize?: number | undefined;
    height?: number | undefined;
    lineCount?: number | undefined;
    lineSpacing?: number | undefined;
    outlineColor?: PBColor3 | undefined;
    outlineWidth?: number | undefined;
    paddingBottom?: number | undefined;
    paddingLeft?: number | undefined;
    paddingRight?: number | undefined;
    paddingTop?: number | undefined;
    shadowBlur?: number | undefined;
    shadowColor?: PBColor3 | undefined;
    shadowOffsetX?: number | undefined;
    shadowOffsetY?: number | undefined;
    text: string;
    textAlign?: TextAlignMode | undefined;
    textColor?: PBColor4 | undefined;
    textWrapping?: boolean | undefined;
    width?: number | undefined;
}

// @public (undocumented)
export namespace PBTextShape {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTextShape;
    // (undocumented)
    export function encode(message: PBTextShape, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTriggerArea {
    collisionMask?: number | undefined;
    mesh?: TriggerAreaMeshType | undefined;
}

// @public (undocumented)
export namespace PBTriggerArea {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTriggerArea;
    // (undocumented)
    export function encode(message: PBTriggerArea, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTriggerAreaResult {
    eventType: TriggerAreaEventType;
    timestamp: number;
    // (undocumented)
    trigger: PBTriggerAreaResult_Trigger | undefined;
    triggeredEntity: number;
    triggeredEntityPosition: PBVector3 | undefined;
    triggeredEntityRotation: PBQuaternion | undefined;
}

// @public (undocumented)
export namespace PBTriggerAreaResult {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTriggerAreaResult;
    // (undocumented)
    export function encode(message: PBTriggerAreaResult, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTriggerAreaResult_Trigger {
    entity: number;
    layers: number;
    position: PBVector3 | undefined;
    rotation: PBQuaternion | undefined;
    scale: PBVector3 | undefined;
}

// @public (undocumented)
export namespace PBTriggerAreaResult_Trigger {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTriggerAreaResult_Trigger;
    // (undocumented)
    export function encode(message: PBTriggerAreaResult_Trigger, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTween {
    currentTime?: number | undefined;
    duration: number;
    // (undocumented)
    easingFunction: EasingFunction;
    // (undocumented)
    mode?: {
        $case: "move";
        move: Move;
    } | {
        $case: "rotate";
        rotate: Rotate;
    } | {
        $case: "scale";
        scale: Scale;
    } | {
        $case: "textureMove";
        textureMove: TextureMove;
    } | {
        $case: "rotateContinuous";
        rotateContinuous: RotateContinuous;
    } | {
        $case: "moveContinuous";
        moveContinuous: MoveContinuous;
    } | {
        $case: "textureMoveContinuous";
        textureMoveContinuous: TextureMoveContinuous;
    } | undefined;
    playing?: boolean | undefined;
}

// @public (undocumented)
export namespace PBTween {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTween;
    // (undocumented)
    export function encode(message: PBTween, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTweenSequence {
    // (undocumented)
    loop?: TweenLoop | undefined;
    // (undocumented)
    sequence: PBTween[];
}

// @public (undocumented)
export namespace PBTweenSequence {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTweenSequence;
    // (undocumented)
    export function encode(message: PBTweenSequence, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBTweenState {
    currentTime: number;
    // (undocumented)
    state: TweenStateStatus;
}

// @public (undocumented)
export namespace PBTweenState {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBTweenState;
    // (undocumented)
    export function encode(message: PBTweenState, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiBackground {
    color?: PBColor4 | undefined;
    // (undocumented)
    texture?: TextureUnion | undefined;
    // (undocumented)
    textureMode: BackgroundTextureMode;
    textureSlices?: BorderRect | undefined;
    uvs: number[];
}

// @public (undocumented)
export namespace PBUiBackground {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiBackground;
    // (undocumented)
    export function encode(message: PBUiBackground, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiCanvasInformation {
    devicePixelRatio: number;
    height: number;
    interactableArea: BorderRect | undefined;
    width: number;
}

// @public (undocumented)
export namespace PBUiCanvasInformation {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiCanvasInformation;
    // (undocumented)
    export function encode(message: PBUiCanvasInformation, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiDropdown {
    // (undocumented)
    acceptEmpty: boolean;
    color?: PBColor4 | undefined;
    // (undocumented)
    disabled: boolean;
    // (undocumented)
    emptyLabel?: string | undefined;
    font?: Font | undefined;
    fontSize?: number | undefined;
    // (undocumented)
    options: string[];
    selectedIndex?: number | undefined;
    textAlign?: TextAlignMode | undefined;
}

// @public (undocumented)
export namespace PBUiDropdown {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiDropdown;
    // (undocumented)
    export function encode(message: PBUiDropdown, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiDropdownResult {
    // (undocumented)
    value: number;
}

// @public (undocumented)
export namespace PBUiDropdownResult {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiDropdownResult;
    // (undocumented)
    export function encode(message: PBUiDropdownResult, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiInput {
    color?: PBColor4 | undefined;
    // (undocumented)
    disabled: boolean;
    font?: Font | undefined;
    fontSize?: number | undefined;
    // (undocumented)
    placeholder: string;
    placeholderColor?: PBColor4 | undefined;
    textAlign?: TextAlignMode | undefined;
    // (undocumented)
    value?: string | undefined;
}

// @public (undocumented)
export namespace PBUiInput {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiInput;
    // (undocumented)
    export function encode(message: PBUiInput, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiInputResult {
    isSubmit?: boolean | undefined;
    // (undocumented)
    value: string;
}

// @public (undocumented)
export namespace PBUiInputResult {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiInputResult;
    // (undocumented)
    export function encode(message: PBUiInputResult, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiText {
    color?: PBColor4 | undefined;
    font?: Font | undefined;
    fontSize?: number | undefined;
    textAlign?: TextAlignMode | undefined;
    textWrap?: TextWrap | undefined;
    value: string;
}

// @public (undocumented)
export namespace PBUiText {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiText;
    // (undocumented)
    export function encode(message: PBUiText, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBUiTransform {
    alignContent?: YGAlign | undefined;
    alignItems?: YGAlign | undefined;
    alignSelf: YGAlign;
    // (undocumented)
    borderBottomColor?: PBColor4 | undefined;
    // (undocumented)
    borderBottomLeftRadius?: number | undefined;
    borderBottomLeftRadiusUnit?: YGUnit | undefined;
    // (undocumented)
    borderBottomRightRadius?: number | undefined;
    borderBottomRightRadiusUnit?: YGUnit | undefined;
    // (undocumented)
    borderBottomWidth?: number | undefined;
    borderBottomWidthUnit?: YGUnit | undefined;
    // (undocumented)
    borderLeftColor?: PBColor4 | undefined;
    // (undocumented)
    borderLeftWidth?: number | undefined;
    borderLeftWidthUnit?: YGUnit | undefined;
    // (undocumented)
    borderRightColor?: PBColor4 | undefined;
    // (undocumented)
    borderRightWidth?: number | undefined;
    borderRightWidthUnit?: YGUnit | undefined;
    borderTopColor?: PBColor4 | undefined;
    // (undocumented)
    borderTopLeftRadius?: number | undefined;
    borderTopLeftRadiusUnit?: YGUnit | undefined;
    // (undocumented)
    borderTopRightRadius?: number | undefined;
    borderTopRightRadiusUnit?: YGUnit | undefined;
    // (undocumented)
    borderTopWidth?: number | undefined;
    borderTopWidthUnit?: YGUnit | undefined;
    display: YGDisplay;
    // (undocumented)
    flexBasis: number;
    flexBasisUnit: YGUnit;
    flexDirection: YGFlexDirection;
    // (undocumented)
    flexGrow: number;
    flexShrink?: number | undefined;
    flexWrap?: YGWrap | undefined;
    // (undocumented)
    height: number;
    heightUnit: YGUnit;
    justifyContent: YGJustify;
    // (undocumented)
    marginBottom: number;
    marginBottomUnit: YGUnit;
    // (undocumented)
    marginLeft: number;
    marginLeftUnit: YGUnit;
    // (undocumented)
    marginRight: number;
    marginRightUnit: YGUnit;
    // (undocumented)
    marginTop: number;
    marginTopUnit: YGUnit;
    // (undocumented)
    maxHeight: number;
    maxHeightUnit: YGUnit;
    // (undocumented)
    maxWidth: number;
    maxWidthUnit: YGUnit;
    // (undocumented)
    minHeight: number;
    minHeightUnit: YGUnit;
    // (undocumented)
    minWidth: number;
    minWidthUnit: YGUnit;
    opacity?: number | undefined;
    overflow: YGOverflow;
    // (undocumented)
    paddingBottom: number;
    paddingBottomUnit: YGUnit;
    // (undocumented)
    paddingLeft: number;
    paddingLeftUnit: YGUnit;
    // (undocumented)
    paddingRight: number;
    paddingRightUnit: YGUnit;
    // (undocumented)
    paddingTop: number;
    paddingTopUnit: YGUnit;
    // (undocumented)
    parent: number;
    pointerFilter?: PointerFilterMode | undefined;
    // (undocumented)
    positionBottom: number;
    positionBottomUnit: YGUnit;
    // (undocumented)
    positionLeft: number;
    positionLeftUnit: YGUnit;
    // (undocumented)
    positionRight: number;
    positionRightUnit: YGUnit;
    // (undocumented)
    positionTop: number;
    positionTopUnit: YGUnit;
    positionType: YGPositionType;
    // (undocumented)
    rightOf: number;
    // (undocumented)
    width: number;
    widthUnit: YGUnit;
    zIndex?: number | undefined;
}

// @public (undocumented)
export namespace PBUiTransform {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBUiTransform;
    // (undocumented)
    export function encode(message: PBUiTransform, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVector2 {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public (undocumented)
export namespace PBVector2 {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVector2;
    // (undocumented)
    export function encode(message: PBVector2, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVector3 {
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
    // (undocumented)
    z: number;
}

// @public (undocumented)
export namespace PBVector3 {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVector3;
    // (undocumented)
    export function encode(message: PBVector3, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVideoEvent {
    // (undocumented)
    currentOffset: number;
    // (undocumented)
    state: VideoState;
    tickNumber: number;
    timestamp: number;
    // (undocumented)
    videoLength: number;
}

// @public (undocumented)
export namespace PBVideoEvent {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVideoEvent;
    // (undocumented)
    export function encode(message: PBVideoEvent, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVideoPlayer {
    loop?: boolean | undefined;
    playbackRate?: number | undefined;
    playing?: boolean | undefined;
    position?: number | undefined;
    spatial?: boolean | undefined;
    spatialMaxDistance?: number | undefined;
    spatialMinDistance?: number | undefined;
    src: string;
    volume?: number | undefined;
}

// @public (undocumented)
export namespace PBVideoPlayer {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVideoPlayer;
    // (undocumented)
    export function encode(message: PBVideoPlayer, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVirtualCamera {
    // (undocumented)
    defaultTransition?: CameraTransition | undefined;
    // (undocumented)
    lookAtEntity?: number | undefined;
}

// @public (undocumented)
export namespace PBVirtualCamera {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVirtualCamera;
    // (undocumented)
    export function encode(message: PBVirtualCamera, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface PBVisibilityComponent {
    visible?: boolean | undefined;
}

// @public (undocumented)
export namespace PBVisibilityComponent {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): PBVisibilityComponent;
    // (undocumented)
    export function encode(message: PBVisibilityComponent, writer?: _m0.Writer): _m0.Writer;
}

// @public
export namespace Plane {
    // (undocumented)
    export function asArray(plane: ReadonlyPlane): number[];
    // (undocumented)
    export function clone(plane: ReadonlyPlane): MutablePlane;
    export function copyFromPoints(point1: Vector3.ReadonlyVector3, point2: Vector3.ReadonlyVector3, point3: Vector3.ReadonlyVector3): MutablePlane;
    export function create(a: number, b: number, c: number, d: number): {
        normal: Vector3.MutableVector3;
        d: number;
    };
    export function dotCoordinate(plane: ReadonlyPlane, point: Vector3.ReadonlyVector3): number;
    export function fromArray(array: number[]): MutablePlane;
    export function fromPoints(_point1: Vector3.ReadonlyVector3, _point2: Vector3.ReadonlyVector3, _point3: Vector3.ReadonlyVector3): MutablePlane;
    // (undocumented)
    export function getHashCode(_plane: ReadonlyPlane): number;
    export function isFrontFacingTo(plane: ReadonlyPlane, direction: Vector3.ReadonlyVector3, epsilon: number): boolean;
    // (undocumented)
    export type MutablePlane = {
        normal: Vector3.MutableVector3;
        d: number;
    };
    export function normalize(plane: ReadonlyPlane): MutablePlane;
    // (undocumented)
    export type ReadonlyPlane = {
        normal: Vector3.ReadonlyVector3;
        d: number;
    };
    export function romPositionAndNormal(origin: Vector3.ReadonlyVector3, normal: Vector3.ReadonlyVector3): MutablePlane;
    export function signedDistanceTo(plane: ReadonlyPlane, point: Vector3.ReadonlyVector3): number;
    export function signedDistanceToPlaneFromPositionAndNormal(origin: Vector3.ReadonlyVector3, normal: Vector3.ReadonlyVector3, point: Vector3.ReadonlyVector3): number;
    export function transform(plane: ReadonlyPlane, transformation: Matrix.ReadonlyMatrix): MutablePlane;
}

// @public (undocumented)
export const PlayerIdentityData: LastWriteWinElementSetComponentDefinition<PBPlayerIdentityData>;

// @public (undocumented)
export const PointerEvents: LastWriteWinElementSetComponentDefinition<PBPointerEvents>;

// @public (undocumented)
export const PointerEventsResult: GrowOnlyValueSetComponentDefinition<PBPointerEventsResult>;

// @public (undocumented)
export interface PointerEventsSystem {
    onPointerDown(pointerData: {
        entity: Entity;
        opts?: Partial<EventSystemOptions>;
    }, cb: EventSystemCallback): void;
    // @deprecated (undocumented)
    onPointerDown(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
    onPointerHoverEnter(pointerData: {
        entity: Entity;
        opts?: Partial<EventSystemOptions>;
    }, cb: EventSystemCallback): void;
    onPointerHoverLeave(pointerData: {
        entity: Entity;
        opts?: Partial<EventSystemOptions>;
    }, cb: EventSystemCallback): void;
    onPointerUp(pointerData: {
        entity: Entity;
        opts?: Partial<EventSystemOptions>;
    }, cb: EventSystemCallback): void;
    // @deprecated (undocumented)
    onPointerUp(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
    removeOnPointerDown(entity: Entity): void;
    removeOnPointerHoverEnter(entity: Entity): void;
    removeOnPointerHoverLeave(entity: Entity): void;
    removeOnPointerUp(entity: Entity): void;
}

// @public
export const pointerEventsSystem: PointerEventsSystem;

// @public (undocumented)
export const enum PointerEventType {
    // (undocumented)
    PET_DOWN = 1,
    // (undocumented)
    PET_HOVER_ENTER = 2,
    // (undocumented)
    PET_HOVER_LEAVE = 3,
    // (undocumented)
    PET_UP = 0
}

// @public (undocumented)
export const enum PointerFilterMode {
    // (undocumented)
    PFM_BLOCK = 1,
    // (undocumented)
    PFM_NONE = 0
}

// @public
export type PointerFilterType = 'none' | 'block';

// @public (undocumented)
export const PointerLock: LastWriteWinElementSetComponentDefinition<PBPointerLock>;

// @public (undocumented)
export const enum PointerType {
    POT_MOUSE = 1,
    POT_NONE = 0
}

// @public
export interface Position {
    // (undocumented)
    bottom: PositionUnit;
    // (undocumented)
    left: PositionUnit;
    // (undocumented)
    right: PositionUnit;
    // (undocumented)
    top: PositionUnit;
}

// @public
export type PositionShorthand = PositionUnit | `${PositionUnit} ${PositionUnit}` | `${PositionUnit} ${PositionUnit} ${PositionUnit}` | `${PositionUnit} ${PositionUnit} ${PositionUnit} ${PositionUnit}`;

// @public
export type PositionType = 'absolute' | 'relative';

// @public
export type PositionUnit = `${number}px` | `${number}%` | number | `${number}` | ScaleUnit;

// @public (undocumented)
export const PrimaryPointerInfo: LastWriteWinElementSetComponentDefinition<PBPrimaryPointerInfo>;

// Warning: (ae-missing-release-tag) "ProcessMessageResultType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export enum ProcessMessageResultType {
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    EntityDeleted = 7,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    EntityWasDeleted = 6,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    NoChanges = 3,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    StateOutdatedData = 4,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    StateOutdatedTimestamp = 2,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    StateUpdatedData = 5,
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@state" is not defined in this configuration
    // Warning: (tsdoc-undefined-tag) The TSDoc tag "@reason" is not defined in this configuration
    StateUpdatedTimestamp = 1
}

// @public (undocumented)
export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;

// Warning: (tsdoc-escape-greater-than) The ">" character should be escaped using a backslash to avoid confusion with an HTML tag
//
// @public
export type PutComponentMessageBody = {
    type: CrdtMessageType.PUT_COMPONENT;
    entityId: Entity;
    componentId: number;
    timestamp: number;
    data: Uint8Array;
};

// @public (undocumented)
export namespace PutComponentOperation {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 16;
    // (undocumented)
    export function read(buf: ByteBuffer): PutComponentMessage | null;
    export function write(entity: Entity, timestamp: number, componentId: number, data: Uint8Array, buf: ByteBuffer): void;
}

// @public (undocumented)
export type PutNetworkComponentMessage = CrdtMessageHeader & PutNetworkComponentMessageBody;

// Warning: (ae-missing-release-tag) "PutNetworkComponentMessageBody" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type PutNetworkComponentMessageBody = Omit<PutComponentMessageBody, 'type'> & {
    type: CrdtMessageType.PUT_COMPONENT_NETWORK;
    networkId: number;
};

// @public (undocumented)
export namespace PutNetworkComponentOperation {
    const // (undocumented)
    MESSAGE_HEADER_LENGTH = 20;
    // (undocumented)
    export function read(buf: ByteBuffer): PutNetworkComponentMessage | null;
    export function write(entity: Entity, timestamp: number, componentId: number, networkId: number, data: Uint8Array, buf: ByteBuffer): void;
}

// @public
export type Quaternion = Quaternion.ReadonlyQuaternion;

// @public
export namespace Quaternion {
    export function add(q1: ReadonlyQuaternion, q2: ReadonlyQuaternion): MutableQuaternion;
    export function angle(quat1: ReadonlyQuaternion, quat2: ReadonlyQuaternion): number;
    export function create(
    x?: number,
    y?: number,
    z?: number,
    w?: number): MutableQuaternion;
    export function dot(left: ReadonlyQuaternion, right: ReadonlyQuaternion): number;
    // (undocumented)
    export function fromAngleAxis(degrees: number, axis: Vector3.ReadonlyVector3): MutableQuaternion;
    export function fromAxisToRotationQuaternion(axis1: Vector3.ReadonlyVector3, axis2: Vector3.ReadonlyVector3, axis3: Vector3.ReadonlyVector3): MutableQuaternion;
    export function fromAxisToRotationQuaternionToRef(axis1: Vector3.ReadonlyVector3, axis2: Vector3.ReadonlyVector3, axis3: Vector3.ReadonlyVector3, ref: MutableQuaternion): void;
    export function fromEulerDegrees(x: number, y: number, z: number): MutableQuaternion;
    export function fromLookAt(position: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, worldUp?: Vector3.ReadonlyVector3): MutableQuaternion;
    export function fromLookAtToRef(position: Vector3.ReadonlyVector3, target: Vector3.ReadonlyVector3, worldUp: Vector3.ReadonlyVector3 | undefined, result: MutableQuaternion): void;
    export function fromRotationMatrixToRef(matrix: Matrix.ReadonlyMatrix, result: Quaternion.MutableQuaternion): void;
    export function fromRotationYawPitchRoll(yaw: number, pitch: number, roll: number): MutableQuaternion;
    export function fromRotationYawPitchRollToRef(yaw: number, pitch: number, roll: number, result: Quaternion.MutableQuaternion): void;
    export function fromToRotation(from: Vector3.ReadonlyVector3, to: Vector3.ReadonlyVector3, up?: Vector3.ReadonlyVector3): MutableQuaternion;
    export function Identity(): MutableQuaternion;
    export function length(q: ReadonlyQuaternion): number;
    export function lengthSquared(q: ReadonlyQuaternion): number;
    export function lookRotation(forward: Vector3.ReadonlyVector3, up?: Vector3.ReadonlyVector3): MutableQuaternion;
    export function multiply(self: ReadonlyQuaternion, q1: ReadonlyQuaternion): MutableQuaternion;
    export function multiplyToRef(self: ReadonlyQuaternion, q1: ReadonlyQuaternion, result: MutableQuaternion): void;
    export type Mutable = MutableQuaternion;
    export type MutableQuaternion = {
        x: number;
        y: number;
        z: number;
        w: number;
    };
    export function normalize(q: ReadonlyQuaternion): MutableQuaternion;
    export type ReadonlyQuaternion = {
        readonly x: number;
        readonly y: number;
        readonly z: number;
        readonly w: number;
    };
    export function rotateTowards(from: ReadonlyQuaternion, to: ReadonlyQuaternion, maxDegreesDelta: number): MutableQuaternion;
    export function slerp(left: ReadonlyQuaternion, right: ReadonlyQuaternion, amount: number): MutableQuaternion;
    export function slerpToRef(left: ReadonlyQuaternion, right: ReadonlyQuaternion, amount: number, result: MutableQuaternion): void;
    export function toEulerAngles(q: MutableQuaternion): Vector3.Mutable;
    export function Zero(): MutableQuaternion;
}

// @public (undocumented)
export type QuaternionType = {
    x: number;
    y: number;
    z: number;
    w: number;
};

// @public
export const RAD2DEG: number;

// @public (undocumented)
export const Raycast: LastWriteWinElementSetComponentDefinition<PBRaycast>;

// @public (undocumented)
export interface RaycastHit {
    direction: PBVector3 | undefined;
    entityId?: number | undefined;
    globalOrigin: PBVector3 | undefined;
    length: number;
    meshName?: string | undefined;
    normalHit: PBVector3 | undefined;
    position: PBVector3 | undefined;
}

// @public (undocumented)
export namespace RaycastHit {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): RaycastHit;
    // (undocumented)
    export function encode(message: RaycastHit, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export const enum RaycastQueryType {
    RQT_HIT_FIRST = 0,
    RQT_NONE = 2,
    RQT_QUERY_ALL = 1
}

// @public (undocumented)
export const RaycastResult: LastWriteWinElementSetComponentDefinition<PBRaycastResult>;

// @public (undocumented)
export interface RaycastSystem {
    globalDirectionOptions(options?: Partial<GlobalDirectionRaycastOptions>): RaycastSystemOptions;
    globalTargetOptions(options?: Partial<GlobalTargetRaycastOptions>): RaycastSystemOptions;
    localDirectionOptions(options?: Partial<LocalDirectionRaycastOptions>): RaycastSystemOptions;
    registerGlobalDirectionRaycast(raycastData: {
        entity: Entity;
        opts?: Partial<GlobalDirectionRaycastOptions>;
    }, callback: RaycastSystemCallback): void;
    // @deprecated (undocumented)
    registerGlobalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalDirectionRaycastOptions>): void;
    registerGlobalTargetRaycast(raycastData: {
        entity: Entity;
        opts?: Partial<GlobalTargetRaycastOptions>;
    }, callback: RaycastSystemCallback): void;
    // @deprecated (undocumented)
    registerGlobalTargetRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<GlobalTargetRaycastOptions>): void;
    registerLocalDirectionRaycast(raycastData: {
        entity: Entity;
        opts?: Partial<LocalDirectionRaycastOptions>;
    }, callback: RaycastSystemCallback): void;
    // @deprecated (undocumented)
    registerLocalDirectionRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<LocalDirectionRaycastOptions>): void;
    registerRaycast(entity: Entity, options: RaycastSystemOptions): DeepReadonlyObject<PBRaycastResult> | null;
    registerTargetEntityRaycast(raycastData: {
        entity: Entity;
        opts?: Partial<TargetEntityRaycastOptions>;
    }, callback: RaycastSystemCallback): void;
    // @deprecated (undocumented)
    registerTargetEntityRaycast(entity: Entity, callback: RaycastSystemCallback, options?: Partial<TargetEntityRaycastOptions>): void;
    removeRaycasterEntity(entity: Entity): void;
    targetEntitytOptions(options?: Partial<TargetEntityRaycastOptions>): RaycastSystemOptions;
}

// @public
export const raycastSystem: RaycastSystem;

// @public (undocumented)
export type RaycastSystemCallback = (event: DeepReadonlyObject<PBRaycastResult>) => void;

// @public (undocumented)
export type RaycastSystemOptions = {
    originOffset?: PBVector3 | undefined;
    maxDistance: number;
    queryType: RaycastQueryType;
    continuous?: boolean | undefined;
    collisionMask?: number | undefined;
};

// @public (undocumented)
export interface ReactBasedUiSystem {
    // (undocumented)
    destroy(): void;
    // (undocumented)
    setUiRenderer(ui: UiComponent): void;
}

// @public (undocumented)
export namespace ReactEcs {
    // (undocumented)
    export type DependencyList = ReadonlyArray<any>;
    const // (undocumented)
    createElement: any;
    // (undocumented)
    export type Dispatch<T> = (action: SetStateAction<T>) => void;
    // (undocumented)
    export type EffectCallback = () => void | (() => void | undefined);
    // (undocumented)
    export type EffectHook = (effect: EffectCallback, deps?: DependencyList) => void;
    // (undocumented)
    export namespace JSX {
        export interface Component {
        }
        // (undocumented)
        export interface Element extends ReactElement<any, any> {
        }
        export interface IntrinsicElements extends EcsElements {
        }
        // (undocumented)
        export type ReactNode = Element | ReactElement | string | number | boolean | null | undefined | ReactNode[];
    }
    // (undocumented)
    export type SetStateAction<T> = T | ((prevState: T) => T);
    // (undocumented)
    export type StateHook = <T>(initialState: T | (() => T)) => [T, Dispatch<T>];
    const // (undocumented)
    useEffect: EffectHook;
    const // (undocumented)
    useState: StateHook;
        {};
}

// Warning: (tsdoc-at-sign-in-word) The "@" character looks like part of a TSDoc tag; use a backslash to escape it
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
//
// @public
export const ReactEcsRenderer: ReactBasedUiSystem;

// @public (undocumented)
export interface ReactElement<P = any, T extends string | JSXElementConstructor<any> = string | JSXElementConstructor<any>> {
    // (undocumented)
    key: Key | null;
    // (undocumented)
    props: P;
    // (undocumented)
    type: T;
}

// @public (undocumented)
export type ReadonlyComponentSchema<T extends [ComponentDefinition<unknown>, ...ComponentDefinition<unknown>[]]> = {
    [K in keyof T]: T[K] extends ComponentDefinition<unknown> ? ReturnType<T[K]['get']> : never;
};

// @public (undocumented)
export type ReadOnlyGrowOnlyValueSetComponentDefinition<T> = Omit<GrowOnlyValueSetComponentDefinition<T>, 'addValue'>;

// @public (undocumented)
export type ReadOnlyLastWriteWinElementSetComponentDefinition<T> = Omit<LastWriteWinElementSetComponentDefinition<T>, 'create' | 'createOrReplace' | 'deleteFrom' | 'getMutable' | 'getMutableOrNull' | 'getOrCreateMutable'>;

// @public (undocumented)
export type ReadonlyPrimitive = number | string | number[] | string[] | boolean | boolean[];

// @public (undocumented)
export const RealmInfo: LastWriteWinElementSetComponentDefinition<PBRealmInfo>;

// @public (undocumented)
export type ReceiveMessage = CrdtMessageBody & {
    transportId?: number;
    messageBuffer: Uint8Array;
};

// @public (undocumented)
export interface Rect {
    // (undocumented)
    height: number;
    // (undocumented)
    width: number;
    // (undocumented)
    x: number;
    // (undocumented)
    y: number;
}

// @public (undocumented)
export namespace Rect {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): Rect;
    // (undocumented)
    export function encode(message: Rect, writer?: _m0.Writer): _m0.Writer;
}

// @public
export function removeEntityWithChildren(engine: Pick<IEngine, 'getEntitiesWith' | 'defineComponentFromSchema' | 'removeEntity' | 'defineComponent'>, entity: Entity): void;

// Warning: (ae-missing-release-tag) "RESERVED_STATIC_ENTITIES" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public
export const RESERVED_STATIC_ENTITIES = 512;

// @public (undocumented)
export interface Rotate {
    // (undocumented)
    end: PBQuaternion | undefined;
    // (undocumented)
    start: PBQuaternion | undefined;
}

// @public (undocumented)
export namespace Rotate {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): Rotate;
    // (undocumented)
    export function encode(message: Rotate, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface RotateContinuous {
    // (undocumented)
    direction: PBQuaternion | undefined;
    // (undocumented)
    speed: number;
}

// @public (undocumented)
export namespace RotateContinuous {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): RotateContinuous;
    // (undocumented)
    export function encode(message: RotateContinuous, writer?: _m0.Writer): _m0.Writer;
}

// Warning: (ae-missing-release-tag) "RPCSendableMessage" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type RPCSendableMessage = {
    jsonrpc: '2.0';
    id: number;
    method: string;
    params: any[];
};

// @public
export namespace Scalar {
    const TwoPi: number;
    export function clamp(value: number, min?: number, max?: number): number;
    export function deltaAngle(current: number, target: number): number;
    export function denormalize(normalized: number, min: number, max: number): number;
    export function hermite(value1: number, tangent1: number, value2: number, tangent2: number, amount: number): number;
    export function inverseLerp(a: number, b: number, value: number): number;
    export function lerp(start: number, end: number, amount: number): number;
    export function lerpAngle(start: number, end: number, amount: number): number;
    export function log2(value: number): number;
    export function moveTowards(current: number, target: number, maxDelta: number): number;
    export function moveTowardsAngle(current: number, target: number, maxDelta: number): number;
    export function normalize(value: number, min: number, max: number): number;
    export function normalizeRadians(angle: number): number;
    export function percentToRange(percent: number, min: number, max: number): number;
    export function pingPong(tx: number, length: number): number;
    export function randomRange(min: number, max: number): number;
    export function rangeToPercent(num: number, min: number, max: number): number;
    export function repeat(value: number, length: number): number;
    export function sign(value: number): number;
    export function smoothStep(from: number, to: number, tx: number): number;
    export function toHex(i: number): string;
    export function withinEpsilon(a: number, b: number, epsilon?: number): boolean;
}

// @public (undocumented)
export interface Scale {
    // (undocumented)
    end: PBVector3 | undefined;
    // (undocumented)
    start: PBVector3 | undefined;
}

// @public (undocumented)
export namespace Scale {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): Scale;
    // (undocumented)
    export function encode(message: Scale, writer?: _m0.Writer): _m0.Writer;
}

// @public
export type ScaleContext = {
    width: number;
    height: number;
    ratio: number;
};

// Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
// Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
// Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
// Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
// Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
// Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
// Warning: (tsdoc-param-tag-with-invalid-optional-name) The @param should not include a JSDoc-style optional name; it must not be enclosed in '[ ]' brackets.
// Warning: (tsdoc-param-tag-with-invalid-type) The @param block should not include a JSDoc-style '{type}'
// Warning: (tsdoc-escape-right-brace) The "}" character should be escaped using a backslash to avoid confusion with a TSDoc inline tag
// Warning: (tsdoc-malformed-inline-tag) Expecting a TSDoc tag starting with "{@"
//
// @public
export function scaleFontSize(fontSize: number, scaleUnit?: ScaleUnit, ctx?: ScaleContext | undefined): number;

// @public
export type ScaleUnit = `${number}${ScaleUnits}` | number;

// @public
export type ScaleUnits = 'vw' | 'vh';

// @public (undocumented)
export namespace Schemas {
    // (undocumented)
    export type SchemaType = ISchema;
    const // (undocumented)
    Boolean: ISchema<boolean>;
    const // (undocumented)
    String: ISchema<string>;
    const // (undocumented)
    Float: ISchema<number>;
    const // (undocumented)
    Double: ISchema<number>;
    const // (undocumented)
    Byte: ISchema<number>;
    const // (undocumented)
    Short: ISchema<number>;
    const // (undocumented)
    Int: ISchema<number>;
    const // (undocumented)
    Int64: ISchema<number>;
    const // (undocumented)
    Number: ISchema<number>;
    const // (undocumented)
    Vector3: ISchema<Vector3Type>;
    const // (undocumented)
    Quaternion: ISchema<QuaternionType>;
    const // (undocumented)
    Color3: ISchema<Color3Type>;
    const // (undocumented)
    Color4: ISchema<Color4Type>;
    const // (undocumented)
    Entity: ISchema<Entity>;
    const // (undocumented)
    EnumNumber: <T>(enumObject: Record<any, any>, defaultValue: T) => ISchema<T>;
    const // (undocumented)
    EnumString: <T>(enumObject: Record<any, any>, defaultValue: T) => ISchema<T>;
    const // (undocumented)
    Array: <T>(type: ISchema<T>) => ISchema<T[]>;
    const // (undocumented)
    Map: <T extends Spec>(spec: T, defaultValue?: Partial<MapResult<T>> | undefined) => ISchema<MapResult<T>>;
    const // (undocumented)
    Optional: <T>(spec: ISchema<T>) => ISchema<T | undefined>;
    const // (undocumented)
    OneOf: <T extends Spec>(specs: T) => ISchema<{ [K in keyof T]: {
            readonly $case: K;
            readonly value: ReturnType<T[K]["deserialize"]>;
        }; }[keyof T]>;
    const // Warning: (tsdoc-param-tag-missing-hyphen) The @param block should be followed by a parameter name and then a hyphen
    fromJson: (json: JsonSchemaExtended) => ISchema<unknown>;
    const mutateNestedValues: (jsonSchema: JsonSchemaExtended, value: unknown, mutateFn: (value: unknown, valueType: JsonSchemaExtended) => {
        changed: boolean;
        value?: any;
    }) => void;
}

// @public (undocumented)
export const SkyboxTime: LastWriteWinElementSetComponentDefinition<PBSkyboxTime>;

// @public (undocumented)
export interface Spec {
    // (undocumented)
    [key: string]: ISchema;
}

// @alpha
export const SyncComponents: ISyncComponents;

// @public (undocumented)
export type SystemFn = (dt: number) => void;

// Warning: (ae-missing-release-tag) "SystemItem" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type SystemItem = {
    fn: SystemFn;
    priority: number;
    name?: string;
};

// Warning: (ae-missing-release-tag) "SYSTEMS_REGULAR_PRIORITY" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const SYSTEMS_REGULAR_PRIORITY = 100000;

// Warning: (ae-missing-release-tag) "Tags" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Tags: TagsComponentDefinitionExtended;

// Warning: (ae-missing-release-tag) "TagsComponentDefinitionExtended" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface TagsComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<TagsType> {
    add(entity: Entity, tagName: string): boolean;
    remove(entity: Entity, tagName: string): boolean;
}

// Warning: (ae-missing-release-tag) "TagsType" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export interface TagsType {
    // (undocumented)
    tags: string[];
}

// Warning: (ae-missing-release-tag) "TargetEntityRaycastOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type TargetEntityRaycastOptions = RaycastSystemOptions & TargetEntityRaycastSystemOptions;

// Warning: (ae-missing-release-tag) "TargetEntityRaycastSystemOptions" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type TargetEntityRaycastSystemOptions = {
    targetEntity?: number;
};

// Warning: (ae-missing-release-tag) "Task" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type Task<T = unknown> = () => Promise<T>;

// @public (undocumented)
export const enum TextAlignMode {
    // (undocumented)
    TAM_BOTTOM_CENTER = 7,
    // (undocumented)
    TAM_BOTTOM_LEFT = 6,
    // (undocumented)
    TAM_BOTTOM_RIGHT = 8,
    // (undocumented)
    TAM_MIDDLE_CENTER = 4,
    // (undocumented)
    TAM_MIDDLE_LEFT = 3,
    // (undocumented)
    TAM_MIDDLE_RIGHT = 5,
    // (undocumented)
    TAM_TOP_CENTER = 1,
    // (undocumented)
    TAM_TOP_LEFT = 0,
    // (undocumented)
    TAM_TOP_RIGHT = 2
}

// @public (undocumented)
export type TextAlignType = 'top-left' | 'top-center' | 'top-right' | 'middle-left' | 'middle-center' | 'middle-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';

// @public (undocumented)
export const TextShape: LastWriteWinElementSetComponentDefinition<PBTextShape>;

// @public (undocumented)
export interface Texture {
    filterMode?: TextureFilterMode | undefined;
    offset?: PBVector2 | undefined;
    // (undocumented)
    src: string;
    tiling?: PBVector2 | undefined;
    wrapMode?: TextureWrapMode | undefined;
}

// @public (undocumented)
export namespace Texture {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): Texture;
    // (undocumented)
    export function encode(message: Texture, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export const enum TextureFilterMode {
    // (undocumented)
    TFM_BILINEAR = 1,
    // (undocumented)
    TFM_POINT = 0,
    // (undocumented)
    TFM_TRILINEAR = 2
}

// @public (undocumented)
export type TextureFilterType = 'point' | 'bi-linear' | 'tri-linear';

// @public (undocumented)
export interface TextureHelper {
    // (undocumented)
    Avatar: (avatarTexture: AvatarTexture) => TextureUnion;
    // (undocumented)
    Common: (texture: Texture) => TextureUnion;
    // (undocumented)
    Video: (videoTexture: VideoTexture) => TextureUnion;
}

// @public
export type TextureMode = 'nine-slices' | 'center' | 'stretch';

// @public (undocumented)
export interface TextureMove {
    // (undocumented)
    end: PBVector2 | undefined;
    movementType?: TextureMovementType | undefined;
    // (undocumented)
    start: PBVector2 | undefined;
}

// @public (undocumented)
export namespace TextureMove {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMove;
    // (undocumented)
    export function encode(message: TextureMove, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export interface TextureMoveContinuous {
    // (undocumented)
    direction: PBVector2 | undefined;
    movementType?: TextureMovementType | undefined;
    // (undocumented)
    speed: number;
}

// @public (undocumented)
export namespace TextureMoveContinuous {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): TextureMoveContinuous;
    // (undocumented)
    export function encode(message: TextureMoveContinuous, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export const enum TextureMovementType {
    TMT_OFFSET = 0,
    // (undocumented)
    TMT_TILING = 1
}

// @public (undocumented)
export interface TextureUnion {
    // (undocumented)
    tex?: {
        $case: "texture";
        texture: Texture;
    } | {
        $case: "avatarTexture";
        avatarTexture: AvatarTexture;
    } | {
        $case: "videoTexture";
        videoTexture: VideoTexture;
    } | undefined;
}

// @public (undocumented)
export namespace TextureUnion {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): TextureUnion;
    // (undocumented)
    export function encode(message: TextureUnion, writer?: _m0.Writer): _m0.Writer;
}

// @public (undocumented)
export const enum TextureWrapMode {
    // (undocumented)
    TWM_CLAMP = 1,
    // (undocumented)
    TWM_MIRROR = 2,
    // (undocumented)
    TWM_REPEAT = 0
}

// @public (undocumented)
export type TextureWrapType = 'repeat' | 'clamp' | 'mirror';

// @public (undocumented)
export const enum TextWrap {
    // (undocumented)
    TW_NO_WRAP = 1,
    // (undocumented)
    TW_WRAP = 0
}

// @public
export const ToGammaSpace: number;

// @public
export const ToLinearSpace = 2.2;

// @public (undocumented)
export type ToOptional<T> = OnlyOptionalUndefinedTypes<T> & OnlyNonUndefinedTypes<T>;

// Warning: (ae-missing-release-tag) "Transform" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Transform: TransformComponentExtended;

// @public (undocumented)
export type TransformComponent = LastWriteWinElementSetComponentDefinition<TransformType>;

// @public (undocumented)
export interface TransformComponentExtended extends TransformComponent {
    // (undocumented)
    create(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
    // (undocumented)
    createOrReplace(entity: Entity, val?: TransformTypeWithOptionals): TransformType;
}

// @public (undocumented)
export type TransformType = {
    position: {
        x: number;
        y: number;
        z: number;
    };
    rotation: {
        x: number;
        y: number;
        z: number;
        w: number;
    };
    scale: {
        x: number;
        y: number;
        z: number;
    };
    parent?: Entity;
};

// @public (undocumented)
export type TransformTypeWithOptionals = Partial<TransformType>;

// @public (undocumented)
export const enum TransitionMode {
    TM_BACKWARD = 1,
    TM_FORWARD = 0
}

// @public (undocumented)
export type Transport = {
    send(message: Uint8Array | Uint8Array[]): Promise<void>;
    onmessage?(message: Uint8Array): void;
    filter(message: Omit<TransportMessage, 'messageBuffer'>): boolean;
    type?: string;
};

// @public (undocumented)
export type TransportMessage = Omit<ReceiveMessage, 'data'>;

// Warning: (ae-missing-release-tag) "TriggerArea" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const TriggerArea: TriggerAreaComponentDefinitionExtended;

// @public (undocumented)
export interface TriggerAreaComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBTriggerArea> {
    setBox(entity: Entity, collisionMask?: ColliderLayer | ColliderLayer[]): void;
    setSphere(entity: Entity, collisionMask?: ColliderLayer | ColliderLayer[]): void;
}

// @public (undocumented)
export interface TriggerAreaEventsSystem {
    onTriggerEnter(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
    onTriggerExit(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
    onTriggerStay(entity: Entity, cb: TriggerAreaEventSystemCallback): void;
    removeOnTriggerEnter(entity: Entity): void;
    removeOnTriggerExit(entity: Entity): void;
    removeOnTriggerStay(entity: Entity): void;
}

// @public
export const triggerAreaEventsSystem: TriggerAreaEventsSystem;

// @public (undocumented)
export type TriggerAreaEventSystemCallback = (result: DeepReadonlyObject<PBTriggerAreaResult>) => void;

// @public (undocumented)
export const enum TriggerAreaEventType {
    // (undocumented)
    TAET_ENTER = 0,
    // (undocumented)
    TAET_EXIT = 2,
    // (undocumented)
    TAET_STAY = 1
}

// @public (undocumented)
export const enum TriggerAreaMeshType {
    // (undocumented)
    TAMT_BOX = 0,
    // (undocumented)
    TAMT_SPHERE = 1
}

// @public (undocumented)
export const TriggerAreaResult: GrowOnlyValueSetComponentDefinition<PBTriggerAreaResult>;

// Warning: (ae-missing-release-tag) "Tween" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const Tween: TweenComponentDefinitionExtended;

// @public (undocumented)
export interface TweenComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBTween> {
    Mode: TweenHelper;
    setMove(entity: Entity, start: PBVector3, end: PBVector3, duration: number, easingFunction?: EasingFunction): void;
    setMoveContinuous(entity: Entity, direction: PBVector3, speed: number, duration?: number): void;
    setRotate(entity: Entity, start: PBQuaternion, end: PBQuaternion, duration: number, easingFunction?: EasingFunction): void;
    setRotateContinuous(entity: Entity, direction: PBQuaternion, speed: number, duration?: number): void;
    setScale(entity: Entity, start: PBVector3, end: PBVector3, duration: number, easingFunction?: EasingFunction): void;
    setTextureMove(entity: Entity, start: PBVector2, end: PBVector2, duration: number, movementType?: TextureMovementType, easingFunction?: EasingFunction): void;
    setTextureMoveContinuous(entity: Entity, direction: PBVector2, speed: number, movementType?: TextureMovementType, duration?: number): void;
}

// @public (undocumented)
export interface TweenHelper {
    // (undocumented)
    Move: (move: Move) => PBTween['mode'];
    // (undocumented)
    MoveContinuous: (move: MoveContinuous) => PBTween['mode'];
    // (undocumented)
    Rotate: (rotate: Rotate) => PBTween['mode'];
    // (undocumented)
    RotateContinuous: (rotate: RotateContinuous) => PBTween['mode'];
    // (undocumented)
    Scale: (scale: Scale) => PBTween['mode'];
    // (undocumented)
    TextureMove: (textureMove: TextureMove) => PBTween['mode'];
    // (undocumented)
    TextureMoveContinuous: (textureMove: TextureMoveContinuous) => PBTween['mode'];
}

// @public (undocumented)
export const enum TweenLoop {
    // (undocumented)
    TL_RESTART = 0,
    // (undocumented)
    TL_YOYO = 1
}

// @public (undocumented)
export const TweenSequence: LastWriteWinElementSetComponentDefinition<PBTweenSequence>;

// @public (undocumented)
export const TweenState: LastWriteWinElementSetComponentDefinition<PBTweenState>;

// @public (undocumented)
export const enum TweenStateStatus {
    // (undocumented)
    TS_ACTIVE = 0,
    // (undocumented)
    TS_COMPLETED = 1,
    // (undocumented)
    TS_PAUSED = 2
}

// Warning: (ae-missing-release-tag) "TweenSystem" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export type TweenSystem = {
    tweenCompleted(entity: Entity): boolean;
};

// @public
export const tweenSystem: TweenSystem;

// @public
export interface UiAvatarTexture {
    // (undocumented)
    filterMode?: TextureFilterType;
    // (undocumented)
    userId: string;
    // (undocumented)
    wrapMode?: TextureWrapType;
}

// @public (undocumented)
export const UiBackground: LastWriteWinElementSetComponentDefinition<PBUiBackground>;

// @public
export interface UiBackgroundProps {
    avatarTexture?: UiAvatarTexture;
    color?: PBColor4 | undefined;
    texture?: UiTexture;
    // (undocumented)
    textureMode?: TextureMode;
    textureSlices?: BorderRect | undefined;
    uvs?: number[];
}

// @public
export interface UiButtonProps extends UiLabelProps, EntityPropTypes {
    disabled?: boolean;
    variant?: 'primary' | 'secondary';
}

// @public (undocumented)
export const UiCanvasInformation: LastWriteWinElementSetComponentDefinition<PBUiCanvasInformation>;

// @public (undocumented)
export type UiComponent = () => ReactEcs.JSX.ReactNode;

// @public (undocumented)
export const UiDropdown: LastWriteWinElementSetComponentDefinition<PBUiDropdown>;

// @public
export interface UiDropdownProps extends EntityPropTypes, Omit<Partial<PBUiDropdown>, 'textAlign' | 'font' | 'fontSize'> {
    // (undocumented)
    font?: UiFontType;
    // (undocumented)
    fontSize?: ScaleUnit;
    // (undocumented)
    onChange?(value: number): void;
    // (undocumented)
    textAlign?: TextAlignType;
}

// @public (undocumented)
export const UiDropdownResult: LastWriteWinElementSetComponentDefinition<PBUiDropdownResult>;

// Warning: (tsdoc-undefined-tag) The TSDoc tag "@category" is not defined in this configuration
//
// @public
export function UiEntity(props: EntityPropTypes & {
    uiText?: UiLabelProps;
}): ReactEcs.JSX.Element;

// @public (undocumented)
export type UiFontType = 'sans-serif' | 'serif' | 'monospace';

// @public (undocumented)
export const UiInput: LastWriteWinElementSetComponentDefinition<PBUiInput>;

// @public (undocumented)
export interface UiInputProps extends Omit<PBUiInput, 'font' | 'textAlign' | 'fontSize'> {
    // (undocumented)
    font?: UiFontType;
    // (undocumented)
    fontSize?: ScaleUnit;
    onChange?(value: string): void;
    onSubmit?(value: string): void;
    // (undocumented)
    textAlign?: TextAlignType;
}

// @public (undocumented)
export const UiInputResult: LastWriteWinElementSetComponentDefinition<PBUiInputResult>;

// @public
export interface UiLabelProps {
    color?: PBColor4 | undefined;
    font?: UiFontType | undefined;
    fontSize?: ScaleUnit | undefined;
    textAlign?: TextAlignType | undefined;
    textWrap?: UiTextWrapType | undefined;
    value: string;
}

// @public
export type uint32 = number;

// @public (undocumented)
export const UiText: LastWriteWinElementSetComponentDefinition<PBUiText>;

// @public
export type UiTexture = {
    src: string;
    wrapMode?: TextureWrapType;
    filterMode?: TextureFilterType;
};

// @public (undocumented)
export type UiTextWrapType = 'wrap' | 'nowrap';

// @public (undocumented)
export const UiTransform: LastWriteWinElementSetComponentDefinition<PBUiTransform>;

// @public
export interface UiTransformProps {
    alignContent?: AlignType;
    alignItems?: AlignType;
    alignSelf?: AlignType;
    // (undocumented)
    borderColor?: Record<keyof Partial<Position>, PBColor4> | PBColor4 | undefined;
    // (undocumented)
    borderRadius?: Partial<BorderRadius> | PositionUnit;
    // (undocumented)
    borderWidth?: Partial<Position> | PositionUnit;
    display?: DisplayType;
    flex?: number;
    flexBasis?: number;
    flexDirection?: FlexDirectionType;
    flexGrow?: number;
    flexShrink?: number;
    flexWrap?: FlexWrapType;
    height?: PositionUnit | 'auto';
    justifyContent?: JustifyType;
    margin?: Partial<Position> | PositionShorthand;
    maxHeight?: PositionUnit;
    maxWidth?: PositionUnit;
    minHeight?: PositionUnit;
    minWidth?: PositionUnit;
    opacity?: number;
    overflow?: OverflowType;
    padding?: Partial<Position> | PositionShorthand;
    pointerFilter?: PointerFilterType;
    position?: Partial<Position> | PositionShorthand;
    positionType?: PositionType;
    width?: PositionUnit | 'auto';
    zIndex?: number;
}

// @public (undocumented)
export type Unpacked<T> = T extends (infer U)[] ? U : T;

// @public (undocumented)
export type ValueSetOptions<T> = {
    timestampFunction: (value: DeepReadonly<T>) => number;
    maxElements: number;
};

// @public
export type Vector2 = Vector2.ReadonlyVector2;

// @public
export namespace Vector2 {
    export function create(
    x?: number,
    y?: number): MutableVector2;
    export type Mutable = MutableVector2;
    export type MutableVector2 = {
        x: number;
        y: number;
    };
    export function One(): MutableVector2;
    export type ReadonlyVector2 = {
        readonly x: number;
        readonly y: number;
    };
    export function Zero(): MutableVector2;
}

// @public
export type Vector3 = Vector3.ReadonlyVector3;

// @public
export namespace Vector3 {
    export function add(vector1: ReadonlyVector3, vector2: ReadonlyVector3): MutableVector3;
    export function addToRef(vectorA: ReadonlyVector3, vectorB: ReadonlyVector3, result: MutableVector3): void;
    export function applyMatrix4(vector: ReadonlyVector3, matrix: Matrix.ReadonlyMatrix): MutableVector3;
    export function applyMatrix4ToRef(vector: ReadonlyVector3, matrix: Matrix.ReadonlyMatrix, result: MutableVector3): void;
    export function Backward(): MutableVector3;
    export function catmullRom(value1: ReadonlyVector3, value2: ReadonlyVector3, value3: ReadonlyVector3, value4: ReadonlyVector3, amount: number): MutableVector3;
    export function center(value1: ReadonlyVector3, value2: ReadonlyVector3): MutableVector3;
    export function clamp(value: ReadonlyVector3, min: ReadonlyVector3, max: ReadonlyVector3): MutableVector3;
    export function clampToRef(value: ReadonlyVector3, min: ReadonlyVector3, max: ReadonlyVector3, result: MutableVector3): void;
    export function clone(source: ReadonlyVector3): MutableVector3;
    export function copyFrom(source: ReadonlyVector3, dest: MutableVector3): void;
    export function copyFromFloats(x: number, y: number, z: number, dest: MutableVector3): void;
    export function create(
    x?: number,
    y?: number,
    z?: number): MutableVector3;
    export function cross(left: ReadonlyVector3, right: ReadonlyVector3): MutableVector3;
    export function crossToRef(left: ReadonlyVector3, right: ReadonlyVector3, result: MutableVector3): void;
    export function distance(value1: ReadonlyVector3, value2: ReadonlyVector3): number;
    export function distanceSquared(value1: ReadonlyVector3, value2: ReadonlyVector3): number;
    export function divide(vector1: ReadonlyVector3, vector2: ReadonlyVector3): MutableVector3;
    export function divideToRef(vector1: ReadonlyVector3, vector2: ReadonlyVector3, result: MutableVector3): void;
    export function dot(left: ReadonlyVector3, right: ReadonlyVector3): number;
    export function Down(): MutableVector3;
    export function equals(vector1: ReadonlyVector3, vector2: ReadonlyVector3): boolean;
    export function equalsToFloats(vector: ReadonlyVector3, x: number, y: number, z: number): boolean;
    export function equalsWithEpsilon(vector1: ReadonlyVector3, vector2: ReadonlyVector3, epsilon?: number): boolean;
    export function floor(vector1: ReadonlyVector3): MutableVector3;
    export function Forward(): MutableVector3;
    export function fract(vector1: ReadonlyVector3): MutableVector3;
    export function fromArray(array: FloatArray, offset?: number): MutableVector3;
    export function fromArrayToRef(array: number[], offset: number, result: MutableVector3): void;
    export function fromFloatArray(array: FloatArray, offset?: number): MutableVector3;
    export function fromFloatArrayToRef(array: FloatArray, offset: number, result: MutableVector3): void;
    export function getAngleBetweenVectors(vector0: ReadonlyVector3, vector1: ReadonlyVector3, normal: ReadonlyVector3): number;
    export function getClipFactor(vector0: ReadonlyVector3, vector1: ReadonlyVector3, axis: ReadonlyVector3, size: number): number;
    export function getHashCode(vector: ReadonlyVector3): number;
    export function hermite(value1: ReadonlyVector3, tangent1: ReadonlyVector3, value2: ReadonlyVector3, tangent2: ReadonlyVector3, amount: number): MutableVector3;
    export function isNonUniform(vector: ReadonlyVector3): boolean;
    export function Left(): MutableVector3;
    export function length(vector: ReadonlyVector3): number;
    export function lengthSquared(vector: ReadonlyVector3): number;
    export function lerp(start: ReadonlyVector3, end: ReadonlyVector3, amount: number): MutableVector3;
    export function lerpToRef(start: ReadonlyVector3, end: ReadonlyVector3, amount: number, result: MutableVector3): void;
    export function maximize(left: MutableVector3, right: MutableVector3): MutableVector3;
    export function maximizeInPlaceFromFloatsToRef(vector1: ReadonlyVector3, x: number, y: number, z: number, result: MutableVector3): void;
    export function minimize(left: ReadonlyVector3, right: ReadonlyVector3): MutableVector3;
    export function minimizeInPlaceFromFloatsToRef(vector1: ReadonlyVector3, x: number, y: number, z: number, result: MutableVector3): void;
    export function multiply(vector1: ReadonlyVector3, vector2: ReadonlyVector3): MutableVector3;
    export function multiplyByFloats(vector1: ReadonlyVector3, x: number, y: number, z: number): MutableVector3;
    export function multiplyByFloatsToRef(vector1: ReadonlyVector3, x: number, y: number, z: number, result: MutableVector3): void;
    export function multiplyToRef(vector1: ReadonlyVector3, vector2: ReadonlyVector3, result: MutableVector3): void;
    export type Mutable = MutableVector3;
    export type MutableVector3 = {
        x: number;
        y: number;
        z: number;
    };
    export function negate(value: ReadonlyVector3): MutableVector3;
    export function normalize(vector: ReadonlyVector3): MutableVector3;
    export function normalizeFromLength(vector: ReadonlyVector3, len: number): MutableVector3;
    export function normalizeFromLengthToRef(vector: ReadonlyVector3, len: number, result: MutableVector3): void;
    export function normalizeToRef(vector: ReadonlyVector3, result: MutableVector3): void;
    export function One(): MutableVector3;
    export function Random(): MutableVector3;
    export type ReadonlyVector3 = {
        readonly x: number;
        readonly y: number;
        readonly z: number;
    };
    export function Right(): MutableVector3;
    export function rotate(vector: ReadonlyVector3, q: Quaternion.ReadonlyQuaternion): MutableVector3;
    export function rotateToRef(vector: ReadonlyVector3, q: Quaternion.ReadonlyQuaternion, result: MutableVector3): void;
    export function rotationFromAxis(axis1: MutableVector3, axis2: MutableVector3, axis3: MutableVector3): MutableVector3;
    export function rotationFromAxisToRef(axis1: MutableVector3, axis2: MutableVector3, axis3: MutableVector3, result: MutableVector3): void;
    export function scale(vector: ReadonlyVector3, scale: number): MutableVector3;
    export function scaleToRef(vector: ReadonlyVector3, scale: number, result: MutableVector3): void;
    export function subtract(vector1: ReadonlyVector3, vector2: ReadonlyVector3): MutableVector3;
    export function subtractFromFloatsToRef(vector1: ReadonlyVector3, x: number, y: number, z: number, result: MutableVector3): void;
    export function subtractToRef(vectorA: ReadonlyVector3, vectorB: ReadonlyVector3, result: MutableVector3): void;
    export function toString(vector: ReadonlyVector3): string;
    export function transformCoordinates(vector: ReadonlyVector3, transformation: Matrix.ReadonlyMatrix): MutableVector3;
    export function transformCoordinatesFromFloatsToRef(x: number, y: number, z: number, transformation: Matrix.ReadonlyMatrix, result: MutableVector3): void;
    export function transformCoordinatesToRef(vector: ReadonlyVector3, transformation: Matrix.ReadonlyMatrix, result: MutableVector3): void;
    export function transformNormal(vector: ReadonlyVector3, transformation: Matrix.ReadonlyMatrix): MutableVector3;
    export function transformNormalFromFloatsToRef(x: number, y: number, z: number, transformation: Matrix.ReadonlyMatrix, result: MutableVector3): void;
    export function transformNormalToRef(vector: ReadonlyVector3, transformation: Matrix.ReadonlyMatrix, result: MutableVector3): void;
    export function Up(): MutableVector3;
    export function Zero(): MutableVector3;
}

// @public (undocumented)
export type Vector3Type = {
    x: number;
    y: number;
    z: number;
};

// @public (undocumented)
export const VideoEvent: GrowOnlyValueSetComponentDefinition<PBVideoEvent>;

// @public (undocumented)
export interface VideoEventsSystem {
    getVideoState(entity: Entity): DeepReadonlyObject<PBVideoEvent> | undefined;
    // (undocumented)
    hasVideoEventsEntity(entity: Entity): boolean;
    // (undocumented)
    registerVideoEventsEntity(entity: Entity, callback: VideoEventsSystemCallback): void;
    // (undocumented)
    removeVideoEventsEntity(entity: Entity): void;
}

// @public
export const videoEventsSystem: VideoEventsSystem;

// @public (undocumented)
export type VideoEventsSystemCallback = (event: DeepReadonlyObject<PBVideoEvent>) => void;

// @public (undocumented)
export const VideoPlayer: LastWriteWinElementSetComponentDefinition<PBVideoPlayer>;

// @public (undocumented)
export const enum VideoState {
    // (undocumented)
    VS_BUFFERING = 5,
    // (undocumented)
    VS_ERROR = 1,
    // (undocumented)
    VS_LOADING = 2,
    // (undocumented)
    VS_NONE = 0,
    // (undocumented)
    VS_PAUSED = 7,
    // (undocumented)
    VS_PLAYING = 4,
    // (undocumented)
    VS_READY = 3,
    // (undocumented)
    VS_SEEKING = 6
}

// @public (undocumented)
export interface VideoTexture {
    filterMode?: TextureFilterMode | undefined;
    // (undocumented)
    videoPlayerEntity: number;
    wrapMode?: TextureWrapMode | undefined;
}

// @public (undocumented)
export namespace VideoTexture {
    // (undocumented)
    export function decode(input: _m0.Reader | Uint8Array, length?: number): VideoTexture;
    // (undocumented)
    export function encode(message: VideoTexture, writer?: _m0.Writer): _m0.Writer;
}

// Warning: (ae-missing-release-tag) "VirtualCamera" is part of the package's API, but it is missing a release tag (@alpha, @beta, @public, or @internal)
//
// @public (undocumented)
export const VirtualCamera: VirtualCameraComponentDefinitionExtended;

// @public (undocumented)
export interface VirtualCameraComponentDefinitionExtended extends LastWriteWinElementSetComponentDefinition<PBVirtualCamera> {
    Transition: CameraTransitionHelper;
}

// @public (undocumented)
export const VisibilityComponent: LastWriteWinElementSetComponentDefinition<PBVisibilityComponent>;

// @public (undocumented)
export const enum YGAlign {
    // (undocumented)
    YGA_AUTO = 0,
    // (undocumented)
    YGA_BASELINE = 5,
    // (undocumented)
    YGA_CENTER = 2,
    // (undocumented)
    YGA_FLEX_END = 3,
    // (undocumented)
    YGA_FLEX_START = 1,
    // (undocumented)
    YGA_SPACE_AROUND = 7,
    // (undocumented)
    YGA_SPACE_BETWEEN = 6,
    // (undocumented)
    YGA_STRETCH = 4
}

// @public (undocumented)
export const enum YGDisplay {
    // (undocumented)
    YGD_FLEX = 0,
    // (undocumented)
    YGD_NONE = 1
}

// @public (undocumented)
export const enum YGEdge {
    // (undocumented)
    YGE_ALL = 8,
    // (undocumented)
    YGE_BOTTOM = 3,
    // (undocumented)
    YGE_END = 5,
    // (undocumented)
    YGE_HORIZONTAL = 6,
    // (undocumented)
    YGE_LEFT = 0,
    // (undocumented)
    YGE_RIGHT = 2,
    // (undocumented)
    YGE_START = 4,
    // (undocumented)
    YGE_TOP = 1,
    // (undocumented)
    YGE_VERTICAL = 7
}

// @public (undocumented)
export const enum YGFlexDirection {
    // (undocumented)
    YGFD_COLUMN = 1,
    // (undocumented)
    YGFD_COLUMN_REVERSE = 2,
    // (undocumented)
    YGFD_ROW = 0,
    // (undocumented)
    YGFD_ROW_REVERSE = 3
}

// @public (undocumented)
export const enum YGJustify {
    // (undocumented)
    YGJ_CENTER = 1,
    // (undocumented)
    YGJ_FLEX_END = 2,
    // (undocumented)
    YGJ_FLEX_START = 0,
    // (undocumented)
    YGJ_SPACE_AROUND = 4,
    // (undocumented)
    YGJ_SPACE_BETWEEN = 3,
    // (undocumented)
    YGJ_SPACE_EVENLY = 5
}

// @public (undocumented)
export const enum YGOverflow {
    // (undocumented)
    YGO_HIDDEN = 1,
    // (undocumented)
    YGO_SCROLL = 2,
    // (undocumented)
    YGO_VISIBLE = 0
}

// @public (undocumented)
export const enum YGPositionType {
    // (undocumented)
    YGPT_ABSOLUTE = 1,
    // (undocumented)
    YGPT_RELATIVE = 0
}

// @public (undocumented)
export const enum YGUnit {
    // (undocumented)
    YGU_AUTO = 3,
    // (undocumented)
    YGU_PERCENT = 2,
    // (undocumented)
    YGU_POINT = 1,
    // (undocumented)
    YGU_UNDEFINED = 0
}

// @public (undocumented)
export const enum YGWrap {
    // (undocumented)
    YGW_NO_WRAP = 0,
    // (undocumented)
    YGW_WRAP = 1,
    // (undocumented)
    YGW_WRAP_REVERSE = 2
}

// (No @packageDocumentation comment for this package)

```
