roavatar-renderer 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2217 @@
+import { EffectComposer } from 'three/examples/jsm/Addons.js';
+import { OrbitControls } from 'three/examples/jsm/Addons.js';
+import * as THREE from 'three';
+
+export declare const AbbreviationToFaceControlProperty: {
+    [K in string]: string;
+};
+
+export declare const AccessoryAssetTypes: string[];
+
+export declare class AccessoryDescriptionWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
+export declare const accessoryRefinementLowerBounds: {
+    [K in string]: {
+        "position": {
+            [K in string]: number;
+        };
+        "rotation": {
+            [K in string]: number;
+        };
+        "scale": {
+            [K in string]: number;
+        };
+    };
+};
+
+export declare const accessoryRefinementTypes: number[];
+
+export declare const accessoryRefinementUpperBounds: typeof accessoryRefinementLowerBounds;
+
+export declare const AccessoryType: {
+    Unknown: number;
+    Hat: number;
+    Hair: number;
+    Face: number;
+    Neck: number;
+    Shoulder: number;
+    Front: number;
+    Back: number;
+    Waist: number;
+    TShirt: number;
+    Shirt: number;
+    Pants: number;
+    Jacket: number;
+    Sweater: number;
+    Shorts: number;
+    LeftShoe: number;
+    RightShoe: number;
+    DressSkirt: number;
+    Eyebrow: number;
+    Eyelash: number;
+};
+
+export declare const ActualBundleTypes: string[];
+
+export declare const AllAccessorySorts: ItemSort[];
+
+export declare const AllAnimations: AnimationProp[];
+
+export declare const AllAnimationSorts: ItemSort[];
+
+export declare const AllBodyParts: number[];
+
+export declare const AllBodyPartsSorts: ItemSort[];
+
+export declare const AllCharacterSorts: ItemSort[];
+
+export declare const AllClothingSorts: ItemSort[];
+
+export declare const AlphaMode: {
+    Overlay: number;
+    Transparency: number;
+    TintMask: number;
+};
+
+export declare type AnimationProp = "ClimbAnimation" | "FallAnimation" | "IdleAnimation" | "JumpAnimation" | "MoodAnimation" | "RunAnimation" | "SwimAnimation" | "WalkAnimation" | "dance1" | "dance2" | "dance3" | "toolnone";
+
+export declare const AnimationPropToName: {
+    [K in AnimationProp]: string;
+};
+
+export declare type AnimationSet = {
+    [K in string]: AnimationSetEntry[];
+};
+
+export declare type AnimationSetEntry = {
+    id: string;
+    weight: number;
+    isEmote?: boolean;
+};
+
+export declare class AnimationTrack {
+    trackType: AnimationTrackType;
+    keyframeGroups: (PartKeyframeGroup | FaceKeyframeGroup)[];
+    curves: (PartCurve | FaceCruve)[];
+    isPlaying: boolean;
+    timePosition: number;
+    weight: number;
+    finished: boolean;
+    rig?: Instance;
+    length: number;
+    looped: boolean;
+    priority: number;
+    pOriginalWeight: number;
+    pTargetWeight: number;
+    pSpeed: number;
+    pFadedTime: number;
+    pFadeTime: number;
+    getNamedMotor(motorName: string, parentName: string): Instance | undefined;
+    findMotor6D(part0: Instance, part1: Instance): Instance | undefined;
+    findPartKeyframeGroup(motorName: string, motorParentName: string): PartKeyframeGroup | undefined;
+    findFaceKeyframeGroup(controlName: string): FaceKeyframeGroup | undefined;
+    addPartKeyframe(motorName: string, motorParentName: string, keyframe: PartKeyframe): void;
+    createPartKeyframe(keyframe: Instance, pose: Instance): [string, string, PartKeyframe] | [undefined, undefined, undefined];
+    addFaceKeyframe(controlName: string, parentName: string, keyframe: FaceKeyframe): void;
+    createFaceKeyframe(keyframe: Instance, pose: Instance): FaceKeyframe | undefined;
+    createPartCurve(motor: string, motorParent: string, child: Instance): PartCurve;
+    createFaceCurve(controlName: string, parentName: string, control: Instance): FaceCruve;
+    addKeyframe(keyframe: Instance): void;
+    loadAnimation(rig: Instance, animation: Instance): this;
+    /**
+     * @deprecated, reset inside Animator instead
+     */
+    resetMotorTransforms(): void;
+    renderPose(): void;
+    setTime(time: number): void;
+    /**
+     * Remember to call tick() on each frame
+     */
+    Play(fadeTime?: number, weight?: number, speed?: number): void;
+    /**
+     * Remember to call tick() on each frame
+     */
+    Stop(fadeTime?: number): void;
+    /**
+     *
+     * @returns looped
+     */
+    tick(deltaTime?: number): boolean;
+}
+
+declare type AnimationTrackType = "Sequence" | "Curve";
+
+export declare class AnimatorWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    get data(): AnimatorWrapperData;
+    _pickRandom(entries: AnimationSetEntry[]): AnimationSetEntry;
+    _getTrack(id: string): AnimationTrack | undefined;
+    _switchAnimation(name: string): boolean;
+    stopMoodAnimation(): void;
+    _switchMoodAnimation(name: string): boolean;
+    isValidTrackForSet(track: AnimationTrack, name: string): boolean;
+    _fixUnloaded(): void;
+    restPose(includeMotors?: boolean, includeFACS?: boolean): void;
+    renderAnimation(addTime?: number): void;
+    loadAvatarAnimation(id: bigint, isEmote?: boolean, forceLoop?: boolean): Promise<Response | undefined>;
+    playAnimation(name: string, type?: "main" | "mood" | "tool"): boolean;
+}
+
+declare class AnimatorWrapperData {
+    animationSet: AnimationSet;
+    emotes: Map<bigint, AnimationSetEntry>;
+    animationTracks: Map<bigint, AnimationTrack>;
+    currentAnimation?: string;
+    currentAnimationTrack?: AnimationTrack;
+    currentToolAnimation?: string;
+    currentToolAnimationTrack?: AnimationTrack;
+    currentMoodAnimation?: string;
+    currentMoodAnimationTrack?: AnimationTrack;
+    moodTracks: AnimationTrack[];
+}
+
+export declare const animNamesR15: AnimationSet;
+
+export declare const animNamesR6: AnimationSet;
+
+export declare const API: {
+    Misc: {
+        startCurrentlyLoadingAssets: () => void;
+        stopCurrentlyLoadingAssets: () => void;
+        idFromStr: (str: string) => number;
+        parseAssetString: (str: string) => string | undefined;
+    };
+    Events: {
+        OnLoadingAssets: Event_2;
+    };
+    Generic: {
+        LoadImage: (url: string) => Promise<HTMLImageElement | undefined>;
+        GetManifestVersion: () => string;
+        IsDevMode: () => boolean;
+        GetBrowser: () => RoAvatarBrowser;
+        GetRoAvatarData: () => Promise<RoAvatarData | Response | undefined>;
+        JoinPlace: (placeId: number) => void;
+    };
+    Auth: {
+        GetAuth: () => Promise<Authentication>;
+    };
+    Economy: {
+        GetAssetDetails: (assetId: number) => Promise<Response>;
+    };
+    Avatar: {
+        WearOutfit: (auth: Authentication, outfit: Outfit, onlyItems: boolean) => Promise<[boolean, boolean]>;
+        SaveOutfitNoRetry: (auth: Authentication, outfit: Outfit) => Promise<Response>;
+        GetAvatarDetails: (userId: number) => Promise<Response | Outfit>;
+        GetAvatarInventory: (sortOption: string, pageToken: string | null | undefined, itemInfos?: ItemSort[]) => Promise<AvatarInventory_Result | Response>;
+        GetOutfitDetails: (outfitId: number | string, userId: number) => Promise<Response | Outfit>;
+        SaveOutfit: (auth: Authentication, outfit: Outfit) => Promise<Response>;
+        UpdateOutfit: (auth: Authentication, outfitId: number | string, newOutfit: Outfit) => Promise<Response>;
+        PatchOutfit: (auth: Authentication, outfitId: number | string, patchData: any) => Promise<Response>;
+        DeleteOutfit: (auth: Authentication, outfitId: number | string) => Promise<Response>;
+        GetEmotes: () => Promise<Response>;
+        EquipEmote: (auth: Authentication, assetId: number | string, slot: number) => Promise<Response>;
+        UnequipEmote: (auth: Authentication, slot: number) => Promise<Response>;
+        GetAvatarRules: () => Promise<Response>;
+        RedrawThumbnail: (auth: Authentication) => Promise<Response>;
+        GetThumbnailCustomization: () => Promise<Response>;
+        SetThumbnailCustomization: (auth: Authentication, body: ThumbnailsCustomization_Payload) => Promise<Response>;
+    };
+    Asset: {
+        GetAssetBuffer: (url: string, headers?: HeadersInit) => Promise<ArrayBuffer | Response>;
+        GetRBX: (url: string, headers?: HeadersInit) => Promise<RBX | Response>;
+        GetMesh: (url: string, headers?: HeadersInit, readOnly?: boolean) => Promise<FileMesh | Response>;
+        IsLayered: (id: number) => Promise<boolean | Response>;
+    };
+    Catalog: {
+        GetNavigationMenuItems: () => Promise<NavigationMenuItems | Response>;
+        GetTopics: (auth: Authentication, body: GetTopics_Payload) => Promise<GetTopics_Result | Response>;
+        Search: ({ taxonomy, salesTypeFilter, sortType, categoryFilter, keyword, topics, creatorName, minPrice, maxPrice, includeNotForSale, limit }: Search_Payload, cursor?: string) => Promise<Search_Result | Response>;
+        GetBundleDetails: (bundleId: number | string) => Promise<BundleDetails_Result | Response>;
+        GetItemDetails: (auth: Authentication, items: {
+            itemType: "Asset" | "Bundle";
+            id: number;
+        }[]) => Promise<ItemDetails_Result | Response>;
+        GetMarketplaceWidgetsSearch: (query: string) => Promise<MarketplaceWidgets_Result | Response>;
+        GetMarketplaceWidgets: (context?: string) => Promise<MarketplaceWidgets_Result | Response>;
+    };
+    Inventory: {
+        GetInventory: (userId: number, assetType: number, cursor?: string) => Promise<Response>;
+        IsItemOwned: (userId: number, itemType: string, assetId: number) => Promise<any>;
+    };
+    Users: {
+        GetUserInfo: () => Promise<UserInfo | undefined>;
+    };
+    Thumbnails: {
+        GetThumbnail: (auth: Authentication, type: string, id: number | string, size?: string) => Promise<string | undefined>;
+        UncacheThumbnail: (type: string, id: number | string, size?: string) => void;
+        RenderOutfit: (auth: Authentication, outfit: Outfit, attempt?: number) => Promise<string | undefined>;
+    };
+    LocalOutfit: {
+        GetLocalOutfits: () => Promise<LocalOutfit[]>;
+        SetLocalOutfits: (localOutfits: LocalOutfit[]) => Promise<undefined>;
+    };
+    Looks: {
+        GetLook: (lookId: string) => Promise<Response | Look_Result>;
+        GetUserLooks: (userId: number, cursor?: string) => Promise<Response | UserLooks_Result>;
+        CreateLook: (auth: Authentication, outfit: Outfit, name: string, description: string) => Promise<Response>;
+        DeleteLook: (auth: Authentication, lookId: string) => Promise<Response>;
+    };
+    PremiumFeatures: {
+        GetSubscription: (userId: number) => Promise<Response | GetSubscription_Result>;
+    };
+};
+
+export declare function arrayBufferToBase64(buffer: ArrayBuffer): string;
+
+export declare class Asset {
+    id: number;
+    name: string;
+    assetType: AssetType;
+    currentVersionId?: number;
+    meta?: AssetMeta;
+    supportsHeadShapes?: boolean;
+    notOwned?: boolean;
+    _uuid: number;
+    clone(): Asset;
+    toJson(): AssetJson;
+    fromJson(assetJson: AssetJson): void;
+    setOrder(order: number): void;
+}
+
+export declare type AssetJson = {
+    id?: number;
+    name?: string;
+    assetType?: AssetTypeJson;
+    currentVersionId?: number;
+    meta?: AssetMetaJson;
+    supportsHeadShapes?: boolean;
+};
+
+export declare class AssetMeta {
+    version: number;
+    order?: number;
+    puffiness?: number;
+    position?: VecXYZ;
+    rotation?: VecXYZ;
+    scale?: VecXYZ;
+    headShape?: number;
+    constructor();
+    clone(): AssetMeta;
+    toJson(): AssetMetaJson;
+    fromJson(assetMetaJson: AssetMetaJson): void;
+}
+
+export declare type AssetMetaJson = {
+    version?: number;
+    position?: VecXYZ | Vecxyz | null;
+    rotation?: VecXYZ | Vecxyz | null;
+    scale?: VecXYZ | Vecxyz | null;
+    order?: number | null;
+    puffiness?: number | null;
+    headShape?: "Invalid" | number;
+};
+
+export declare class AssetType {
+    _id: number;
+    name: string;
+    constructor();
+    clone(): AssetType;
+    toJson(): {
+        id: number;
+        name: string;
+    };
+    fromJson(assetTypeJson: AssetTypeJson): void;
+    set id(newId: number);
+    get id(): number;
+}
+
+export declare type AssetTypeJson = {
+    id?: number;
+    name?: string;
+};
+
+export declare const AssetTypeNameToId: Map<string, number>;
+
+export declare const AssetTypes: string[];
+
+export declare const AssetTypeToAccessoryType: {
+    Hat: number;
+    HairAccessory: number;
+    FaceAccessory: number;
+    NeckAccessory: number;
+    ShoulderAccessory: number;
+    FrontAccessory: number;
+    BackAccessory: number;
+    WaistAccessory: number;
+    TShirtAccessory: number;
+    ShirtAccessory: number;
+    PantsAccessory: number;
+    JacketAccessory: number;
+    SweaterAccessory: number;
+    ShortsAccessory: number;
+    LeftShoeAccessory: number;
+    RightShoeAccessory: number;
+    DressSkirtAccessory: number;
+    EyebrowAccessory: number;
+    EyelashAccessory: number;
+};
+
+export declare const AssetTypeToMakeupType: {
+    FaceMakeup: number;
+    LipMakeup: number;
+    EyeMakeup: number;
+};
+
+export declare class Authentication {
+    TOKEN?: string;
+    SessionUUID?: string;
+    info?: {
+        id: number;
+        name: string;
+        displayName: string;
+    };
+    lastRefreshed: number;
+    getUserInfo(): Promise<{
+        id: number;
+        name: string;
+        displayName: string;
+    } | undefined>;
+    getToken(): Promise<void>;
+    getCachedToken(): string | undefined;
+    getSessionUUID(): string;
+}
+
+export declare interface AvatarInventory_Result {
+    avatarInventoryItems: {
+        itemId: number;
+        itemName: string;
+        itemCategory: {
+            itemType: number;
+            itemSubType: number;
+        };
+        availabilityStatus: string;
+        acquisitionTime: string;
+        outfitDetail?: {
+            assets: {
+                id: number;
+            }[];
+            bodyColor3s: {
+                headColor3: string;
+                leftArmColor3: string;
+                leftLegColor3: string;
+                rightArmColor3: string;
+                rightLegColor3: string;
+                torsoColor3: string;
+            };
+            playerAvatarType: "R6" | "R15";
+            scales: {
+                bodyType: number;
+                depth: number;
+                head: number;
+                height: number;
+                proportion: number;
+                width: number;
+            };
+        };
+    }[];
+    nextPageToken: string | null;
+}
+
+export declare type AvatarType = "R6" | "R15";
+
+export declare const AvatarType: {
+    [K in AvatarType]: AvatarType;
+};
+
+export declare function base64ToArrayBuffer(base64: string): ArrayBuffer;
+
+declare class BaseKeyframe {
+    time: number;
+    easingDirection: number;
+    easingStyle: number;
+    constructor(time: number);
+}
+
+declare class BaseKeyframeGroup {
+    keyframes: BaseKeyframe[];
+    getLowerKeyframe(time: number): BaseKeyframe | null;
+    getHigherKeyframe(time: number): BaseKeyframe | null;
+}
+
+export declare class BodyColor3s {
+    colorType: ColorType;
+    headColor3: string;
+    torsoColor3: string;
+    rightArmColor3: string;
+    leftArmColor3: string;
+    rightLegColor3: string;
+    leftLegColor3: string;
+    constructor();
+    clone(): BodyColor3s;
+    setAll(color: string): void;
+    toJson(): BodyColor3sJson;
+    toHexJson(): {
+        headColor: string;
+        torsoColor: string;
+        rightArmColor: string;
+        leftArmColor: string;
+        rightLegColor: string;
+        leftLegColor: string;
+    };
+    fromJson(bodyColorsJson: BodyColor3sJson): void;
+}
+
+declare type BodyColor3sJson = {
+    headColor3?: string;
+    torsoColor3?: string;
+    rightArmColor3?: string;
+    leftArmColor3?: string;
+    rightLegColor3?: string;
+    leftLegColor3?: string;
+};
+
+export declare class BodyColors {
+    colorType: ColorType;
+    headColorId: number;
+    torsoColorId: number;
+    rightArmColorId: number;
+    leftArmColorId: number;
+    rightLegColorId: number;
+    leftLegColorId: number;
+    constructor();
+    clone(): BodyColors;
+    setAll(colorId: number): void;
+    toJson(): BodyColorsJson;
+    toHexJson(): {
+        headColor: string;
+        torsoColor: string;
+        rightArmColor: string;
+        leftArmColor: string;
+        rightLegColor: string;
+        leftLegColor: string;
+    };
+    fromJson(bodyColorsJson: BodyColorsJson): void;
+    toColor3(): BodyColor3s;
+}
+
+declare type BodyColorsJson = {
+    headColorId?: number;
+    torsoColorId?: number;
+    rightArmColorId?: number;
+    leftArmColorId?: number;
+    rightLegColorId?: number;
+    leftLegColorId?: number;
+};
+
+export declare const BodyPart: {
+    Head: number;
+    Torso: number;
+    LeftArm: number;
+    RightArm: number;
+    LeftLeg: number;
+    RightLeg: number;
+};
+
+export declare class BodyPartDescriptionWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
+export declare const BodyPartEnumToNames: {
+    [K in number]: string[];
+};
+
+export declare const BodyPartNameToEnum: {
+    [K in string]: number;
+};
+
+export declare const BrickColors: {
+    [K in number]: string;
+};
+
+export declare function browserOpenURL(url: string): void;
+
+export declare function browserSendMessage(data: {
+    [K in string]: string;
+}): Promise<any>;
+
+export declare function BuildJoints(self: RigData): void;
+
+export declare interface BundleDetails_Result {
+    bundleType: number;
+    bundledItems: {
+        id: number;
+        name: string;
+        owned: boolean;
+        type: "Asset" | "UserOutfit";
+    }[];
+    collectibleItemId: string;
+    creatorHasVerifiedBadge: boolean;
+    creatorName: string;
+    creatorTargetId: number;
+    creatorType: "User" | "Group";
+    description: string;
+    expectedSellerId: number;
+    favoriteCount: number;
+    hasResellers: boolean;
+    id: number;
+    isPBR: boolean;
+    isPurchasable: boolean;
+    isRecolorable: boolean;
+    itemCreatedUtc: string;
+    itemRestrictions: string[];
+    itemStatus: unknown[];
+    itemType: "Asset" | "Bundle";
+    lowestPrice: number;
+    lowestResalePrice: number;
+    name: string;
+    offSaleDeadline: null | unknown;
+    owned: boolean;
+    price: number;
+    productId: number;
+    saleLocationType: SaleLocationType;
+    totalQuantity: number;
+    unitsAvailableForConsumption: number;
+}
+
+export declare const BundleTypes: string[];
+
+export declare function calculateMotor6Doffset(motor: Instance, includeTransform?: boolean): CFrame;
+
+export declare const CatalogBundleTypes: string[];
+
+export declare const CategoryDictionary: {
+    [K in string]: {
+        [K in string]: {
+            [K in string]: SortInfo | SpecialInfo;
+        };
+    };
+};
+
+export declare class CFrame {
+    Position: Vec3;
+    Orientation: Vec3;
+    constructor(x?: number, y?: number, z?: number);
+    clone(): CFrame;
+    getTHREEMatrix(): THREE.Matrix4;
+    getMatrix(): THREE.Matrix4Tuple;
+    fromMatrix(m: Mat4x4): this;
+    fromRotationMatrix(r00: number, r01: number, r02: number, r10: number, r11: number, r12: number, r20: number, r21: number, r22: number, order?: string): void;
+    inverse(): CFrame;
+    multiply(cf: CFrame): CFrame;
+    isSame(other: CFrame): boolean;
+}
+
+export declare function clonePrimitiveArray<T>(arr: T[]): T[];
+
+export declare function cloneSearch_Payload(data: Search_Payload): Search_Payload;
+
+declare type ClothingDiffType = "Shirt" | "Pants" | "GraphicTShirt";
+
+export declare class Color3 {
+    R: number;
+    G: number;
+    B: number;
+    constructor(R?: number, G?: number, B?: number);
+    clone(): Color3;
+    toColor3uint8(): Color3uint8;
+    multiply(vec3: Color3): Color3;
+    divide(vec3: Color3): Color3;
+    add(vec3: Color3): Color3;
+    minus(vec3: Color3): Color3;
+}
+
+export declare class Color3uint8 {
+    R: number;
+    G: number;
+    B: number;
+    constructor(R?: number, G?: number, B?: number);
+    clone(): Color3uint8;
+    toColor3(): Color3;
+}
+
+export declare class ColorSequence {
+    keypoints: ColorSequenceKeypoint[];
+    static fromColor(color: Color3): ColorSequence;
+    clone(): ColorSequence;
+    getLowerKey(time: number): ColorSequenceKeypoint | null;
+    getHigherKey(time: number): ColorSequenceKeypoint | null;
+    getValue(time: number): Color3;
+}
+
+export declare class ColorSequenceKeypoint {
+    time: number;
+    value: Color3;
+    constructor(time: number, r: number, g: number, b: number);
+    clone(): ColorSequenceKeypoint;
+}
+
+export declare type ColorType = "BrickColor" | "Color3";
+
+export declare class Connection {
+    Connected: boolean;
+    _callback: (...args: unknown[]) => unknown;
+    _event: Event_2 | undefined;
+    constructor(callback: (...args: unknown[]) => unknown, event: Event_2);
+    Disconnect(): void;
+}
+
+export declare class Content {
+    sourceType: number;
+    uri?: string;
+    object?: Instance;
+    externalObject?: Instance;
+}
+
+declare class COREMESH {
+    numverts: number;
+    verts: FileMeshVertex[];
+    numfaces: number;
+    faces: FileMeshFace[];
+    clone(): COREMESH;
+    getTriangle(index: number): Triangle;
+    getTouchingVerts(index: number): number[];
+}
+
+export declare const DataType: {
+    String: number;
+    Bool: number;
+    Int32: number;
+    Float32: number;
+    Float64: number;
+    UDim: number;
+    UDim2: number;
+    Ray: number;
+    Faces: number;
+    Axes: number;
+    BrickColor: number;
+    Color3: number;
+    Vector2: number;
+    Vector3: number;
+    CFrame: number;
+    Enum: number;
+    Referent: number;
+    NumberSequence: number;
+    ColorSequence: number;
+    NumberRange: number;
+    Color3uint8: number;
+    Int64: number;
+    SharedString: number;
+    Bytecode: number;
+    Capabilites: number;
+    Content: number;
+    NonSerializable: number;
+};
+
+/**
+ * @deprecated
+ */
+export declare const DefaultAnimations: {
+    [K in AnimationProp]: [string, [string, bigint][]];
+};
+
+/**
+ * @deprecated
+ */
+export declare const DefaultAnimationsR6: typeof DefaultAnimations;
+
+export declare const defaultPantAssetIds: number[];
+
+export declare const defaultPantTemplateAssetIds: number[];
+
+export declare const DefaultSearchData: {
+    [K in string]: {
+        [K in string]: unknown;
+    };
+};
+
+export declare const defaultShirtAssetIds: number[];
+
+export declare const defaultShirtTemplateAssetIds: number[];
+
+export declare function deg(radians: number): number;
+
+declare class DisposableDesc {
+    disposeMesh(scene: THREE.Scene, mesh: THREE.Mesh): void;
+    disposeMeshes(scene: THREE.Scene, meshes: THREE.Mesh[]): void;
+    disposeRenderLists(renderer: THREE.WebGLRenderer): void;
+    dispose(_renderer: THREE.WebGLRenderer, _scene: THREE.Scene): void;
+}
+
+export declare function download(filename: string, text: string): void;
+
+export declare const EmitterGroupDescClassTypes: string[];
+
+declare class Event_2 {
+    _callbacks: ((...args: unknown[]) => unknown)[];
+    Connect(callback: (...args: unknown[]) => unknown): Connection;
+    Fire(...args: unknown[]): void;
+    Disconnect(callback: (...args: unknown[]) => unknown): void;
+    Clear(): void;
+}
+export { Event_2 as Event }
+
+export declare const FaceControlNames: string[];
+
+export declare class FaceControlsWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
+declare class FaceCruve {
+    controlName: string;
+    parentName: string;
+    value?: FloatCurve;
+}
+
+declare class FaceKeyframe extends BaseKeyframe {
+    value: number;
+    constructor(time: number, value: number);
+}
+
+declare class FaceKeyframeGroup extends BaseKeyframeGroup {
+    controlName: string;
+    parentName: string;
+    keyframes: FaceKeyframe[];
+    getHigherKeyframe(time: number): FaceKeyframe | null;
+    getLowerKeyframe(time: number): FaceKeyframe | null;
+}
+
+declare class FACS {
+    faceBoneNames: string[];
+    faceControlNames: string[];
+    quantizedTransforms?: QuantizedTransform;
+    twoPoseCorrectives: TwoPoseCorrective[];
+    threePoseCorrectives: ThreePoseCorrective[];
+    clone(): FACS;
+}
+
+declare class FileMesh {
+    version: string;
+    facsDataFormat: number;
+    sizeOfFacsData: number;
+    coreMesh: COREMESH;
+    lods: LODS;
+    skinning: SKINNING;
+    facs?: FACS;
+    hsrAvis?: HSRAVIS;
+    _bounds?: [Vec3, Vec3];
+    _size?: Vec3;
+    get bounds(): [Vec3, Vec3];
+    get size(): Vec3;
+    constructor();
+    clone(): FileMesh;
+    reset(): void;
+    recalculateNormals(): void;
+    readChunk(view: SimpleView): Promise<void>;
+    readChunkLODS(view: SimpleView, version: number): void;
+    readChunkSKINNING(view: SimpleView, version: number): void;
+    readChunkHSRAVIS(view: SimpleView, version: number): void;
+    readChunkCOREMESH(view: SimpleView, version: number): Promise<void>;
+    readChunkFACS(view: SimpleView, version: number): void;
+    fromBuffer(buffer: ArrayBuffer): Promise<void>;
+    stripLODS(): void;
+    padSkinnings(): void;
+    combine(other: FileMesh): void;
+    /**
+     * @deprecated it doesnt work with LODS
+     */
+    deleteVert(i: number): void;
+    removeDuplicateVertices(distance?: number): number;
+    basicSkin(boneNames: string[]): void;
+    getValidationIssue(): "subsetLengthMismatch" | undefined;
+}
+
+declare class FileMeshBone {
+    boneNameIndex: number;
+    parentIndex: number;
+    lodParentIndex: number;
+    culling: number;
+    rotationMatrix: Mat3x3;
+    position: Vec3;
+    clone(): FileMeshBone;
+}
+
+declare class FileMeshFace {
+    a: number;
+    b: number;
+    c: number;
+    constructor(a: number, b: number, c: number);
+    clone(): FileMeshFace;
+}
+
+declare class FileMeshSkinning {
+    subsetIndices: Vec4;
+    boneWeights: Vec4;
+    clone(): FileMeshSkinning;
+}
+
+declare class FileMeshSubset {
+    facesBegin: number;
+    facesLength: number;
+    vertsBegin: number;
+    vertsLength: number;
+    numBoneIndices: number;
+    boneIndices: number[];
+    clone(): FileMeshSubset;
+}
+
+declare class FileMeshVertex {
+    position: Vec3;
+    normal: Vec3;
+    uv: Vec2;
+    tangent: Vec4;
+    color: Vec4;
+    constructor(position?: Vec3, normal?: Vec3, uv?: Vec2, tangent?: Vec4, color?: Vec4);
+    clone(): FileMeshVertex;
+}
+
+export declare const FLAGS: {
+    HAIR_IS_BODYPART: boolean;
+    BODYCOLOR3: boolean;
+    ENABLE_API_CACHE: boolean;
+    ROAVATAR_DATA_URL: string;
+    ROAVATAR_TRYON_PLACE: number;
+    ENABLE_LC_WEIGHT_CACHE: boolean;
+    INFLATE_LAYERED_CLOTHING: number;
+    LAYERED_CLOTHING_ALGORITHM: "linear" | "linearnormal" | "linearnormal2" | "rbf";
+    RBF_PATCH_COUNT: number;
+    RBF_PATCH_DETAIL_SAMPLES: 48;
+    RBF_PATCH_SHAPE_SAMPLES: 32;
+    USE_VERTEX_COLOR: boolean;
+    USE_POST_PROCESSING: boolean;
+    POST_PROCESSING_IS_DOUBLE_SIZE: boolean;
+    GEAR_ENABLED: boolean;
+    SHOW_SKELETON_HELPER: boolean;
+    UPDATE_SKELETON: boolean;
+    ANIMATE_SKELETON: boolean;
+    AUTO_SKIN_EVERYTHING: boolean;
+    SEARCH_FOR_STRING: string | undefined;
+    LOAD_TEST_PLACE: string | undefined;
+};
+
+declare class FloatCurve {
+    keys: FloatCurveKey[];
+    maxTime: number;
+    fromBuffer(arrayBuffer: ArrayBuffer): this;
+    getLowerKey(time: number): FloatCurveKey | null;
+    getHigherKey(time: number): FloatCurveKey | null;
+}
+
+declare type FloatCurve3 = [FloatCurve, FloatCurve, FloatCurve];
+
+declare class FloatCurveKey {
+    time: number;
+    value: number;
+    interpolation: number;
+    leftTangent?: number;
+    rightTangent?: number;
+}
+
+export declare const FullBodyColors: string[];
+
+export declare function generateUUIDv4(): string;
+
+export declare function GetAttachedPart(accessory: Instance, rig: Instance): Instance | undefined;
+
+export declare function getOriginalSize(part: Instance): Vector3;
+
+export declare function getRandomBetweenInclusive(min: number, max: number): number;
+
+export declare interface GetSubscription_Result {
+    "subscriptionProductModel": {
+        "premiumFeatureId": number;
+        "subscriptionTypeName": string;
+        "robuxStipendAmount": number;
+        "isLifetime": boolean;
+        "expiration": string;
+        "renewal": string;
+        "renewedSince": string;
+        "created": string;
+        "purchasePlatform": string;
+        "subscriptionName": string;
+    };
+}
+
+export declare interface GetTopics_Payload {
+    items: unknown[];
+    maxResult: 40;
+    selectTopics: string[];
+}
+
+export declare interface GetTopics_Result {
+    error: null | unknown;
+    topics: {
+        displayName: string;
+        originalTopicName: string;
+    }[];
+}
+
+export declare function hasSameVal(instance0: Instance, instance1: Instance, propertyName: string): boolean;
+
+export declare function hasSameValFloat(instance0: Instance, instance1: Instance, propertyName: string): boolean;
+
+export declare function hexToColor3(hex: string): Color3;
+
+export declare function hexToRgb(hex: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+
+declare class HSRAVIS {
+    bitFlags: boolean[];
+    clone(): HSRAVIS;
+}
+
+declare type HumanoidDescriptionDiff = "scale" | "bodyColor" | "animation" | "bodyPart" | "clothing" | "face" | "accessory" | "makeup" | "gear";
+
+export declare class HumanoidDescriptionWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    cancelApply: boolean;
+    setup(): void;
+    reset(): void;
+    /**
+     * @returns [diffs, addedAccessories, removedAccessories]
+     */
+    compare(originalW: HumanoidDescriptionWrapper): [HumanoidDescriptionDiff[], bigint[], bigint[], bigint[], bigint[]];
+    getMakeupDescriptions(): Instance[];
+    getMakeupIds(): bigint[];
+    getMakeupDescriptionWithId(id: bigint): Instance | undefined;
+    getAccessoryDescriptions(): Instance[];
+    getAccessoryIds(): bigint[];
+    getAccessoryDescriptionWithId(id: bigint): Instance | undefined;
+    getBodyPartDescription(bodyPart: number): Instance | undefined;
+    getBodyPartColor(bodyPart: number): Color3;
+    setBodyPartId(bodyPart: number, id: bigint): void;
+    getBodyPartId(bodyPart: number): bigint;
+    createRigData(): RigData | undefined;
+    fromOutfit(outfit: Outfit): Promise<Instance | Response>;
+    _applyScale(humanoid: Instance): void;
+    _applyBodyColors(humanoid: Instance): void;
+    /**
+     * @returns undefined on success
+     */
+    _applyBodyParts(humanoid: Instance, toChange?: number[]): Promise<Response | undefined>;
+    /**
+     * @returns undefined on success
+     */
+    _applyClothing(humanoid: Instance, toChange?: ClothingDiffType[]): Promise<undefined | Response>;
+    /**
+     * @returns undefined on success
+     */
+    _applyFace(humanoid: Instance): Promise<undefined | Response>;
+    /**
+     * @returns undefined on success
+     */
+    _applyGear(humanoid: Instance): Promise<undefined | Response>;
+    _inheritAccessoryReferences(originalW: HumanoidDescriptionWrapper): void;
+    _inheritMakeupReferences(originalW: HumanoidDescriptionWrapper): void;
+    /**
+     * @returns undefined on success
+     */
+    _applyAccessories(humanoid: Instance, originalW?: HumanoidDescriptionWrapper, addedIds?: bigint[], removedIds?: bigint[]): Promise<undefined | Response>;
+    _applyMakeup(humanoid: Instance, originalW?: HumanoidDescriptionWrapper, addedIds?: bigint[], removedIds?: bigint[]): Promise<undefined | Response>;
+    /**
+     * @returns undefined on success
+     */
+    _applyAnimations(humanoid: Instance, toChange?: AnimationProp[]): Promise<undefined | Response>;
+    /**
+     * @returns undefined on success
+     */
+    _applyAll(humanoid: Instance): Promise<undefined | Response>;
+    /**
+     * @returns Instance on success
+     */
+    applyDescription(humanoid: Instance): Promise<Instance | Response | undefined>;
+}
+
+export declare const HumanoidRigType: {
+    R6: number;
+    R15: number;
+};
+
+export declare function imageUrlToDataUrl(imageUrl: string): Promise<string>;
+
+declare class INST {
+    classID: number;
+    className: string;
+    objectFormat: number;
+    instanceCount: number;
+    referents: number[];
+    clone(): INST;
+}
+
+export declare class Instance {
+    _id: number;
+    _name?: string;
+    className: string;
+    _properties: Map<string, Property>;
+    _referencedBy: Instance[];
+    _connectionReferences: Connection[];
+    children: Instance[];
+    parent?: Instance;
+    destroyed: boolean;
+    hasWrappered: boolean;
+    classID?: number;
+    objectFormat?: number;
+    ChildAdded: Event_2;
+    Destroying: Event_2;
+    Changed: Event_2;
+    AncestryChanged: Event_2;
+    constructor(className: string, notComplete?: boolean);
+    get id(): string;
+    set name(value: string);
+    get name(): string;
+    createWrapper(): void;
+    addConnectionReference(connection: Connection): void;
+    removeConnectionReference(connection: Connection): void;
+    addReferencedBy(instance: Instance): void;
+    removeReferencedBy(instance: Instance): void;
+    addProperty(property: Property, value?: unknown): void;
+    fixPropertyName(name: string): string;
+    setProperty(name: string, value: unknown): void;
+    HasProperty(name: string): boolean;
+    Property(name: string): unknown;
+    Prop(name: string): unknown;
+    PropOrDefault(name: string, def: unknown): unknown;
+    PropertyType(name: string): number | undefined;
+    getPropertyNames(): string[];
+    setParent(instance: Instance | undefined | null): void;
+    Destroy(): void;
+    GetFullName(): string;
+    GetChildren(): Instance[];
+    GetDescendants(): Instance[];
+    FindFirstChild(name: string): Instance | undefined;
+    FindFirstDescendant(name: string): Instance | undefined;
+    Child(name: string): Instance | undefined;
+    FindFirstChildOfClass(className: string): Instance | undefined;
+    FindLastChildOfClass(className: string): Instance | undefined;
+    AccessoryBuildWeld(): void;
+}
+
+declare class InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    instance: Instance;
+    constructor(instance: Instance);
+    setup(): void;
+    static(): typeof InstanceWrapper;
+    static register(): void;
+    created(): void;
+    destroy(): void;
+}
+
+export declare interface Inventory_Result {
+    data: {
+        assetId: number;
+        assetName: string;
+        collectibleItemId: string | null;
+        collectibleItemInstanceId: string | null;
+        created: string;
+        owner: {
+            buildersClubMembershipType: string | "None";
+            userId: number;
+            username: string;
+        };
+        serialNumber: number;
+        updated: string;
+        userAssetId: number;
+    }[];
+    nextPageCursor: string | null;
+    previousPageCursor: string | null;
+}
+
+export declare function isAffectedByHumanoid(child: Instance): boolean;
+
+export declare function isSameColor(color0: Color3, color1: Color3): boolean;
+
+export declare function isSameFloat(num0: number, num1: number): boolean;
+
+export declare function isSameVector3(vec0: Vector3, vec1: Vector3): boolean;
+
+export declare interface ItemDetail_Result {
+    assetType: number;
+    bundledItems: [];
+    collectibleItemId: string | null;
+    creatorHasVerifiedBadge: boolean;
+    creatorName: string;
+    creatorTargetId: number;
+    creatorType: "User" | "Group";
+    description: string;
+    favoriteCount: number;
+    id: number;
+    isOffSale: boolean;
+    itemRestrictions: string[];
+    itemStatus: string[];
+    itemType: "Asset" | "Bundle";
+    lowestPrice?: number;
+    name: string;
+    offsaleDeadline: null;
+    saleLocationType: SaleLocationType;
+    taxonomy: {
+        taxonomyId: string;
+        taxonomyName: string;
+    };
+}
+
+export declare interface ItemDetails_Result {
+    data: ItemDetail_Result[];
+}
+
+export declare class ItemInfo {
+    itemType: ItemType;
+    type: string;
+    id: number | string;
+    name: string;
+    bundledAssets: number[];
+    price?: number;
+    limitedType?: "Limited" | "LimitedUnique";
+    offsale?: boolean;
+    constructor(itemType: ItemType, type: string, id: number | string, name: string);
+}
+
+export declare class ItemSort {
+    subType: number;
+    itemType: string;
+    constructor(subType: number, itemType?: string);
+}
+
+declare type ItemType = "Asset" | "Bundle" | "Outfit" | "Look" | "None";
+
+export declare const LayeredAssetTypes: string[];
+
+export declare const LayeredClothingAssetOrder: {
+    [K in number]: number;
+};
+
+export declare function lerp(a: number, b: number, t: number): number;
+
+export declare function lerpVec3(a: Vector3, b: Vector3, t: number): Vector3;
+
+export declare class LocalOutfit {
+    name: string;
+    id: number;
+    creator?: number;
+    date: number;
+    image?: string;
+    buffer: string;
+    constructor(outfit: Outfit);
+    toJson(): LocalOutfitJson;
+    fromJson(data: LocalOutfitJson): this;
+    update(outfit: Outfit): void;
+    toOutfit(): Promise<Outfit>;
+}
+
+export declare interface LocalOutfitJson {
+    name: string;
+    id: number;
+    creator: number | undefined;
+    date: number;
+    image: string | undefined;
+    buffer: string;
+}
+
+declare class LODS {
+    lodType: number;
+    numHighQualityLODs: number;
+    numLodOffsets: number;
+    lodOffsets: number[];
+    clone(): LODS;
+}
+
+export declare interface Look_Result {
+    look: {
+        avatarProperties: {
+            playerAvatarType: "R6" | "R15";
+            scale: {
+                head: number;
+                height: number;
+                depth: number;
+                width: number;
+                bodyType: number;
+                proportion: number;
+            };
+            bodyColor3s: {
+                headColor3: string;
+                leftArmColor3: string;
+                leftLegColor3: string;
+                rightArmColor3: string;
+                rightLegColor3: string;
+                torsoColor3: string;
+            };
+        };
+        createdTime: string;
+        curator: {
+            hasVerifiedBadge: boolean;
+            id: number;
+            name: string;
+            type: "User" | "Group";
+        };
+        description: string;
+        displayProperties: null;
+        favoriteCount: number;
+        items: {
+            assetType: number | null;
+            assetsInBundle: {
+                assetType: number;
+                id: number;
+                isIncluded: boolean;
+                supportsHeadshapes?: boolean;
+            }[];
+            bundleType: number | null;
+            collectibleItemId: string;
+            collectibleProductId: string;
+            creator: {
+                hasVerifiedBadge: boolean;
+                id: number;
+                name: string;
+                type: "User" | "Group";
+            };
+            description: string;
+            id: number;
+            isPurchasable: boolean;
+            itemRestrictions: string[];
+            itemType: "Asset" | "Bundle";
+            name: string;
+            noPriceStatus: "OffSale" | null;
+            priceInRobux: number | null;
+            quantityOwned: number;
+            meta: undefined | {
+                headShape: "Invalid" | number;
+                order: null | number;
+                position: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | null;
+                puffiness: null | number;
+                rotation: {
+                    x: number;
+                    y: number;
+                    z: number;
+                } | null;
+                scale: {
+                    scale: 0;
+                    x: number;
+                    y: number;
+                    z: number;
+                } | null;
+                version: number;
+            };
+        }[];
+        lookId: string;
+        lookType: "Avatar";
+        moderationStatus: "Approved";
+        name: string;
+        totalPrice: number;
+        totalValue: number;
+        updatedTime: string;
+    };
+}
+
+export declare const magic = "<roblox!";
+
+export declare const MainToSubNames: {
+    [K in string]: string[];
+};
+
+export declare class MakeupDescriptionWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+}
+
+export declare const MakeupType: {
+    Face: number;
+    Lip: number;
+    Eye: number;
+};
+
+export declare function mapNum(x: number, in_min: number, in_max: number, out_min: number, out_max: number): number;
+
+export declare interface MarketplaceWidget {
+    id: string;
+    type: string;
+    content: {
+        type: "Asset" | "Bundle" | "Look";
+        id: number;
+    }[];
+    template: {
+        type: "ItemGroup" | string;
+        seeAllButton: true | null;
+        title: string | null;
+        localizedTitle: string | null;
+        itemFooters: {
+            contentType: string;
+        }[];
+        categories: unknown[];
+        previewRows: unknown[];
+        previewColumns: unknown[];
+    };
+}
+
+export declare interface MarketplaceWidgets_Result {
+    widgets: {
+        [K in number]: MarketplaceWidget;
+    };
+    configuration: unknown;
+}
+
+declare type Mat3x3 = [number, number, number, number, number, number, number, number, number];
+
+declare type Mat4x4 = [number, number, number, number, number, number, number, number, number, number, number, number, number, number, number, number];
+
+export declare function mathRandom(min: number, max: number): number;
+
+export declare const MaxOneOfAssetTypes: string[];
+
+/**
+ * @deprecated This is incorrect
+ */
+export declare const MaxPerAsset: {
+    [K in string]: number;
+};
+
+export declare const MeshType: {
+    Brick: number;
+    Cylinder: number;
+    FileMesh: number;
+    Head: number;
+    Sphere: number;
+    Torso: number;
+    Wedge: number;
+};
+
+export declare const minimumDeltaEBodyColorDifference = 11.4;
+
+export declare class ModelWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    GetModelCFrame(): CFrame;
+    GetExtentsSize(): Vector3;
+}
+
+export declare function mount(container: HTMLDivElement): void;
+
+export declare interface NavigationMenuItems {
+    categories: {
+        category: string;
+        taxonomy: string;
+        assetTypeIds: number[];
+        bundleTypeIds: number[];
+        categoryId: number;
+        name: string;
+        orderIndex: number;
+        subcategories: {
+            subcategory: string | null;
+            taxonomy: string;
+            assetTypeIds: number[];
+            bundleTypeIds: number[];
+            subcategoryId: number | null;
+            name: string;
+            shortName: string | null;
+        }[];
+        isSearchable: boolean;
+    }[];
+    genres: {
+        genre: number;
+        name: string;
+        isSelected: boolean;
+    }[];
+    sortMenu: {
+        sortOptions: {
+            sortType: number;
+            sortOrder: number;
+            name: string;
+            isSelected: boolean;
+            hasSubMenu: boolean;
+            isPriceRelated: boolean;
+        }[];
+        sortAggregations: {
+            sortAggregation: number;
+            name: string;
+            isSelected: boolean;
+            hasSubMenu: boolean;
+            isPriceRelated: boolean;
+        }[];
+    };
+    creatorFilters: {
+        userId: number;
+        name: string;
+        isSelected: boolean;
+    }[];
+    priceFilters: {
+        currencyType: number;
+        name: string;
+        excludePriceSorts: boolean;
+    }[];
+    defaultGearSubcategory: number;
+    defaultCategory: number;
+    defaultCategoryIdForRecommendedSearch: number;
+    defaultCreator: number;
+    defaultCurrency: number;
+    defaultSortType: number;
+    defaultSortAggregation: number;
+    categoriesWithCreator: number[];
+    isGenreAllowed: boolean;
+    robloxUserId: number;
+    robloxUserName: string;
+    gearSubcategory: number;
+    allCategories: number;
+    freeFilter: number;
+    customRobuxFilter: number;
+    robuxFilter: number;
+    salesTypeFilters: {
+        name: string;
+        filter: number;
+    }[];
+}
+
+export declare const NeverLayeredAccessoryTypes: number[];
+
+export declare const NormalId: {
+    Right: number;
+    Top: number;
+    Back: number;
+    Left: number;
+    Bottom: number;
+    Front: number;
+};
+
+export declare class NumberRange {
+    Min: number;
+    Max: number;
+    constructor(Min?: number, Max?: number);
+    clone(): NumberRange;
+    isSame(other: NumberRange): boolean;
+}
+
+export declare class NumberSequence {
+    keypoints: NumberSequenceKeypoint[];
+    constructor(keypoints?: NumberSequenceKeypoint[]);
+    clone(): NumberSequence;
+    getLowerKey(time: number): NumberSequenceKeypoint | null;
+    getHigherKey(time: number): NumberSequenceKeypoint | null;
+    getValue(time: number, seed: number): number;
+}
+
+export declare class NumberSequenceKeypoint {
+    time: number;
+    value: number;
+    envelope: number;
+    constructor(time: number, value: number, envelope?: number);
+    clone(): NumberSequenceKeypoint;
+}
+
+export declare const ObjectDescClassTypes: string[];
+
+export declare class Outfit {
+    scale: Scale;
+    bodyColors: BodyColors | BodyColor3s;
+    playerAvatarType: AvatarType;
+    assets: Asset[];
+    name: string;
+    _id: number;
+    lookId?: number | string;
+    origin?: OutfitOrigin;
+    _creatorId?: number;
+    creationDate?: number;
+    cachedImage?: string;
+    editable?: boolean;
+    collections?: string[];
+    /**
+     * @param {number} newId
+     */
+    set id(newId: number);
+    get id(): number;
+    /**
+     * @param {number} newId
+     */
+    set creatorId(newId: number | undefined);
+    get creatorId(): number | undefined;
+    constructor();
+    clone(): Outfit;
+    toJson(removeNotOwnedAssets?: boolean): OutfitJson;
+    toCleanJson(removeNotOwnedAssets?: boolean): OutfitJson;
+    fromJson(outfitJson: OutfitJson): void;
+    /**
+     * @deprecated Incorrect, use getValidationIssues() instead
+     */
+    isValid(): boolean;
+    getValidationIssues(): ValidationIssue[];
+    toHumanoidDescription(): Promise<Document | null>;
+    fromHumanoidDescription(rootDocument: Document): Promise<void>;
+    downloadHumanoidDescription(): Promise<void>;
+    getAssetsJson(removeNotOwnedAssets?: boolean): AssetJson[];
+    containsAsset(assetId: number): boolean;
+    containsAssets(assetIds: number[]): boolean;
+    containsAssetType(assetType: string): boolean;
+    removeAsset(assetId: number): void;
+    removeAssetType(type: string | number): void;
+    addAsset(id: number, type: string | number, name: string): void;
+    fixOrders(): void;
+    isOrderUsed(order: number, self?: Asset): boolean;
+    getNextOrder(order: number): number;
+    addAssetId(assetId: number): Promise<boolean>;
+    addBundleId(bundleId: number): Promise<boolean>;
+    getAssetId(assetId: number): Asset | undefined;
+    fromLook(look: Look_Result["look"]): Promise<boolean>;
+    fromBuffer(buffer: ArrayBuffer): Promise<this>;
+    toBuffer(): ArrayBuffer;
+}
+
+declare type OutfitJson = {
+    scale?: ScaleJson;
+    playerAvatarType?: AvatarType;
+    assets?: AssetJson[];
+    outfitType?: string;
+    name?: string;
+    creatorId?: number;
+    outfitId?: number;
+    collections?: string[];
+    creationDate?: number;
+    bodyColors?: BodyColorsJson;
+    bodyColor3s?: BodyColor3sJson;
+    id?: number;
+    scales?: ScaleJson;
+};
+
+export declare type OutfitOrigin = "WebAvatar" | "WebOutfit" | "Other" | "Look";
+
+export declare const OutfitOrigin: {
+    [K in OutfitOrigin]: OutfitOrigin;
+};
+
+declare class PartCurve {
+    motorParent: string;
+    motorName: string;
+    position?: FloatCurve3;
+    rotationOrder: number;
+    rotation?: FloatCurve3;
+}
+
+export declare const ParticleEmitterShapeInOut: {
+    Outward: number;
+    Inward: number;
+    InAndOut: number;
+};
+
+export declare const ParticleOrientation: {
+    FacingCamera: number;
+    FacingCameraWorldUp: number;
+    VelocityParallel: number;
+    VelocityPerpendicular: number;
+};
+
+declare class PartKeyframe extends BaseKeyframe {
+    cframe: CFrame;
+    constructor(time: number, cframe: CFrame);
+}
+
+declare class PartKeyframeGroup extends BaseKeyframeGroup {
+    motorParent: string;
+    motorName: string;
+    keyframes: PartKeyframe[];
+    getHigherKeyframe(time: number): PartKeyframe | null;
+    getLowerKeyframe(time: number): PartKeyframe | null;
+}
+
+declare class PRNT {
+    instanceCount: number;
+    childReferents: number[];
+    parentReferents: number[];
+    clone(): PRNT;
+}
+
+declare class PROP {
+    classID: number;
+    propertyName: string;
+    typeID: number;
+    values: unknown[];
+    clone(): PROP;
+}
+
+export declare class Property {
+    name?: string;
+    typeID?: number;
+    _value?: unknown;
+    constructor(name?: string | undefined, typeID?: number | undefined);
+    get value(): unknown;
+}
+
+export declare const PropertyTypeInfo: {
+    Pants: {
+        PantsTemplate: string;
+        Name: string;
+        archiveable: string;
+    };
+    Shirt: {
+        ShirtTemplate: string;
+        Name: string;
+        archiveable: string;
+    };
+    ShirtGraphic: {
+        Graphic: string;
+        Name: string;
+        archiveable: string;
+    };
+};
+
+declare class QuantizedMatrix {
+    rows: number;
+    columns: number;
+    matrix: number[];
+    version: number;
+    v2_min?: number;
+    v2_max?: number;
+    constructor(version: number, rows: number, columns: number);
+    clone(): QuantizedMatrix;
+}
+
+declare class QuantizedTransform {
+    px: QuantizedMatrix;
+    py: QuantizedMatrix;
+    pz: QuantizedMatrix;
+    rx: QuantizedMatrix;
+    ry: QuantizedMatrix;
+    rz: QuantizedMatrix;
+    constructor(px: QuantizedMatrix, py: QuantizedMatrix, pz: QuantizedMatrix, rx: QuantizedMatrix, ry: QuantizedMatrix, rz: QuantizedMatrix);
+    clone(): QuantizedTransform;
+}
+
+export declare function rad(degrees: number): number;
+
+export declare class Ray {
+    Origin: Vec3;
+    Direction: Vec3;
+    clone(): Ray;
+}
+
+export declare class RBX {
+    classCount: number;
+    instanceCount: number;
+    meta: Map<string, string>;
+    sstr: Map<number[], string>;
+    sstrArr: string[];
+    instArray: INST[];
+    propArray: PROP[];
+    prnt: PRNT;
+    classIDtoINST: Map<any, any>;
+    dataModel: Instance;
+    treeGenerated: boolean;
+    xmlString?: string;
+    get instances(): Instance[];
+    constructor();
+    reset(): void;
+    clone(): RBX;
+    readMETA(chunkView: RBXSimpleView): void;
+    readSSTR(chunkView: RBXSimpleView): void;
+    readINST(chunkView: RBXSimpleView): void;
+    readPROP(chunkView: RBXSimpleView): void;
+    readPRNT(chunkView: RBXSimpleView): void;
+    getChunkBuffer(view: RBXSimpleView, compressedLength: number, uncompressedLength: number): ArrayBuffer | SharedArrayBuffer;
+    addItem(item: Element, itemParent?: Instance): Instance;
+    fromXML(xml: Document): void;
+    fromBuffer(buffer: ArrayBuffer): void;
+    fromInstance(root: Instance): ArrayBuffer;
+    generateTree(): Instance;
+}
+
+export declare class RBXRenderer {
+    static isRenderingMesh: Map<Instance, boolean>;
+    static renderDescs: Map<Instance, RenderDesc>;
+    static destroyConnections: Map<Instance, Connection>;
+    static lookAwayVector: Vec3;
+    static lookAwayDistance: number;
+    static orbitControlsTarget: Vec3;
+    static scene: THREE.Scene;
+    static camera: THREE.PerspectiveCamera;
+    static controls: OrbitControls | undefined;
+    static renderer: THREE.WebGLRenderer;
+    static effectComposer: EffectComposer | undefined;
+    static resolution: [number, number];
+    /**Fully sets up renderer with scene, camera and frame rendering*/
+    static fullSetup(): void;
+    /**Sets up the THREE.js renderer */
+    static create(): void;
+    /**Sets up a basic scene with lighting
+     * @param lightingType "WellLit" is the default lighting for RoAvatar, "Thumbnail" tries to match the Roblox thumbnail lighting
+     */
+    static setupScene(lightingType?: "WellLit" | "Thumbnail"): void;
+    /**Sets up orbit controls */
+    static setupControls(): void;
+    /**Makes the renderer render a new frame on every animationFrame */
+    static animate(): void;
+    static _createEffectComposer(): void;
+    /**Removes an instance from the renderer */
+    static removeInstance(instance: Instance): void;
+    static _addRenderDesc(instance: Instance, auth: Authentication, DescClass: typeof RenderDesc): void;
+    /**Adds an instance to the renderer or updates it */
+    static addInstance(instance: Instance, auth: Authentication): void;
+    static setRendererSize(width: number, height: number): void;
+    static getRendererDom(): HTMLCanvasElement;
+    static getRendererCamera(): THREE.PerspectiveCamera;
+    static getRendererControls(): OrbitControls | undefined;
+    static getRenderer(): THREE.WebGLRenderer;
+    static getScene(): THREE.Scene;
+    /**@deprecated
+     * This function is unstable and can throw errors, but might work
+     */
+    static exportScene(): void;
+}
+
+declare class RBXSimpleView {
+    view: DataView;
+    viewOffset: number;
+    buffer: ArrayBufferLike;
+    locked: boolean;
+    constructor(buffer: ArrayBufferLike);
+    lock(): void;
+    unlock(): void;
+    lockCheck(): void;
+    writeUtf8String(value: string, includeLength?: boolean): void;
+    readUtf8String(stringLength?: number): string;
+    writeFloat32(value: number, littleEndian?: boolean): void;
+    readFloat32(littleEndian?: boolean): number;
+    writeNormalFloat32(value: number, littleEndian?: boolean): void;
+    readNormalFloat32(littleEndian?: boolean): number;
+    writeFloat64(value: number, littleEndian?: boolean): void;
+    readFloat64(littleEndian?: boolean): number;
+    writeInt32(value: number, littleEndian?: boolean): void;
+    readInt32(littleEndian?: boolean): number;
+    writeInt64(value: bigint, littleEndian?: boolean): void;
+    readInt64(littleEndian?: boolean): bigint;
+    writeInterleaved32(values: (number | bigint)[], length: number, littleEndian?: boolean, writeFunc?: string, byteOffset?: number): void;
+    readInterleaved32(length: number, littleEndian?: boolean, readFunc?: string, byteOffset?: number): number[] | bigint[];
+    writeUint32(value: number, littleEndian?: boolean): void;
+    readUint32(littleEndian?: boolean): number;
+    writeInt16(value: number, littleEndian?: boolean): void;
+    readInt16(littleEndian?: boolean): number;
+    writeUint16(value: number, littleEndian?: boolean): void;
+    readUint16(littleEndian?: boolean): number;
+    writeInt8(value: number): void;
+    readInt8(): number;
+    writeUint8(value: number): void;
+    readUint8(): number;
+}
+
+export declare function RegisterWrappers(): void;
+
+export declare const RegularBodyColors: string[];
+
+/**
+ * Abstract class used to describe all rendered instances
+ */
+declare class RenderDesc extends DisposableDesc {
+    results?: THREE.Mesh[];
+    instance?: Instance;
+    isSame(_other: RenderDesc): boolean;
+    needsRegeneration(_other: RenderDesc): boolean;
+    fromRenderDesc(other: RenderDesc): void;
+    virtualFromRenderDesc(_other: RenderDesc): void;
+    fromInstance(_child: Instance): void;
+    compileResults(_renderer: THREE.WebGLRenderer, _scene: THREE.Scene): Promise<THREE.Mesh[] | Response | undefined>;
+    updateResults(): void;
+}
+
+export declare function replaceBodyPart(rig: Instance, child: Instance): void;
+
+export declare function rgbToHex(r: number, g: number, b: number): string;
+
+export declare type RigData = {
+    outfit: Outfit;
+    rig: Instance;
+    stepHeight: number;
+    cumulativeStepHeightLeft: number;
+    cumulativeStepHeightRight: number;
+    cumulativeLegLeft: number;
+    cumulativeLegRight: number;
+    bodyScale: Vector3;
+    headScale: number;
+};
+
+export declare class RNG {
+    m: number;
+    a: number;
+    c: number;
+    state: number;
+    constructor(seed: number);
+    nextInt(): number;
+    nextFloat(): number;
+}
+
+export declare type RoAvatarBrowser = "Dev" | "Chrome" | "Firefox" | "Edge";
+
+export declare class RoAvatarData {
+    errors: RoAvatarDataError[];
+    versions?: RoAvatarVersions;
+    criticalOutdated?: RoAvatarVersions;
+    fromInstance(instance: Instance): void;
+}
+
+export declare class RoAvatarDataError {
+    name: string;
+    text?: string;
+    timestamp: number;
+    minVersion?: string;
+    maxVersion?: string;
+    browser: RoAvatarBrowser[];
+    type: RoAvatarErrorType;
+    color?: string;
+    constructor(name: string);
+    shouldShow(): boolean;
+}
+
+export declare type RoAvatarErrorType = "Error" | "Warning" | "Bug";
+
+export declare class RoAvatarVersions {
+    Dev?: string;
+    Chrome?: string;
+    Firefox?: string;
+    Edge?: string;
+    getForBrowser(browser: RoAvatarBrowser): string | undefined;
+    fromInstance(instance: Instance): void;
+}
+
+export declare function rotationMatrixToEulerAngles(te: number[], order?: string): Vec3;
+
+export declare type SaleLocationType = "ShopOnly" | "ShopAndAllExperiences" | "ExperiencesDevApiOnly" | string;
+
+export declare function saveByteArray(data: BlobPart[] | undefined, name: string): void;
+
+export declare class Scale {
+    height: number;
+    width: number;
+    head: number;
+    depth: number;
+    proportion: number;
+    bodyType: number;
+    constructor();
+    clone(): Scale;
+    reset(): void;
+    toJson(): {
+        height: number;
+        width: number;
+        head: number;
+        depth: number;
+        proportion: number;
+        bodyType: number;
+    };
+    fromJson(scaleJson: ScaleJson): void;
+}
+
+export declare function ScaleAccessory(accessory: Instance, bodyScaleVector: Vector3, headScaleVector: Vector3, bodyTypeScale: number | null, bodyProportionScale: number | null, rig: Instance, humanoidDescription: Instance): void;
+
+export declare function ScaleAccessoryForRig(accessory: Instance, rig: Instance, outfit: Outfit, humanoidDescription: Instance): void;
+
+export declare function ScaleCharacter(rig: Instance, outfit: Outfit, humanoidDescription: Instance): RigData | undefined;
+
+declare type ScaleJson = {
+    height?: number;
+    width?: number;
+    head?: number;
+    depth?: number;
+    proportion?: number;
+    bodyType?: number;
+};
+
+export declare type ScaleName = "height" | "width" | "head" | "depth" | "proportion" | "bodyType";
+
+export declare class ScriptWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    get data(): ScriptWrapperData;
+    created(): void;
+    Run(): void;
+    SoundPlayer(script: Instance): Promise<void>;
+}
+
+declare class ScriptWrapperData {
+    shouldStop: boolean;
+}
+
+export declare interface Search_Payload {
+    taxonomy: string;
+    salesTypeFilter: number;
+    categoryFilter?: number;
+    sortType?: number;
+    keyword?: string;
+    topics?: string[];
+    creatorName?: string;
+    minPrice?: number;
+    maxPrice?: number;
+    includeNotForSale?: boolean;
+    limit?: number;
+}
+
+export declare interface Search_Result {
+    keyword: string | null;
+    previousPageCursor: string | null;
+    nextPageCursor: string | null;
+    data: {
+        bundledItems: {
+            id: number;
+            name: string;
+            type: "Asset" | "UserOutfit";
+        }[];
+        id: number;
+        itemType: "Asset" | "Bundle";
+        assetType?: number;
+        bundleType?: number;
+        name: string;
+        description: string;
+        productId: number;
+        itemStatus: unknown[];
+        itemRestrictions: string[];
+        creatorHasVerifiedBadge: boolean;
+        creatorType: "User" | "Group";
+        creatorTargetId: number;
+        creatorName: string;
+        price: number;
+        lowestPrice?: number;
+        lowestResalePrice: number;
+        priceStatus?: "Off Sale" | string;
+        unitsAvailableForConsumption: number;
+        favoriteCount: number;
+        offSaleDeadline: null | unknown;
+        collectibleItemId: string;
+        totalQuantity: number;
+        saleLocationType: SaleLocationType;
+        hasResellers: boolean;
+        isOffSale?: boolean;
+    }[];
+}
+
+declare class SimpleView {
+    view: DataView;
+    viewOffset: number;
+    buffer: ArrayBuffer;
+    constructor(buffer: ArrayBuffer);
+    writeUtf8String(value: string): void;
+    readUtf8String(stringLength?: number): string;
+    writeFloat32(value: number, littleEndian?: boolean): void;
+    readFloat32(littleEndian?: boolean): number;
+    writeUint64(value: bigint, littleEndian?: boolean): void;
+    readUint64(littleEndian?: boolean): bigint;
+    writeInt32(value: number, littleEndian?: boolean): void;
+    readInt32(littleEndian?: boolean): number;
+    writeUint32(value: number, littleEndian?: boolean): void;
+    readUint32(littleEndian?: boolean): number;
+    writeInt16(value: number, littleEndian?: boolean): void;
+    readInt16(littleEndian?: boolean): number;
+    writeUint16(value: number, littleEndian?: boolean): void;
+    readUint16(littleEndian?: boolean): number;
+    writeInt8(value: number): void;
+    readInt8(): number;
+    writeUint8(value: number): void;
+    readUint8(): number;
+}
+
+declare class SKINNING {
+    numSkinnings: number;
+    skinnings: FileMeshSkinning[];
+    numBones: number;
+    bones: FileMeshBone[];
+    nameTableSize: number;
+    nameTable: string[];
+    numSubsets: number;
+    subsets: FileMeshSubset[];
+    clone(): SKINNING;
+    getBone(boneName: string): FileMeshBone | undefined;
+    getSubsetIndex(vertIndex: number): number;
+}
+
+export declare class SortInfo {
+    sortOption: string;
+    itemCategories: ItemSort[];
+    constructor(itemCategories: ItemSort[], sortOption?: string);
+}
+
+export declare const SortTypes: {
+    [K in string]: number | undefined;
+};
+
+export declare class SoundWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    get data(): SoundWrapperData;
+    created(): void;
+    _updateVolume(): void;
+    Play(): void;
+    Stop(): void;
+}
+
+declare class SoundWrapperData {
+    audio: HTMLAudioElement | undefined;
+}
+
+export declare function specialClamp(value: number, min: number, max: number): number;
+
+export declare class SpecialInfo {
+    type: string;
+    constructor(type: string);
+}
+
+export declare const SpecialLayeredAssetTypes: string[];
+
+export declare const StringBufferProperties: string[];
+
+declare type ThreePoseCorrective = Vec3;
+
+export declare interface ThumbnailsCustomization_Payload {
+    thumbnailType: number;
+    emoteAssetId: number;
+    camera: {
+        fieldOfViewDeg: number;
+        yRotDeg: number;
+        distanceScale: number;
+    };
+}
+
+export declare class ToolWrapper extends InstanceWrapper {
+    static className: string;
+    static requiredProperties: string[];
+    setup(): void;
+    created(): void;
+    createWeld(): void;
+}
+
+export declare const ToRemoveBeforeBundleType: {
+    DynamicHead: string[];
+    Shoes: string[];
+    AnimationPack: string[];
+    Character: string[];
+};
+
+export declare function traverseRigCFrame(instance: Instance): CFrame;
+
+export declare function traverseRigInstance(instance: Instance): Instance[];
+
+declare type Triangle = [Vec3, Vec3, Vec3];
+
+declare type TwoPoseCorrective = Vec2;
+
+export declare class UDim {
+    Scale: number;
+    Offset: number;
+    constructor(Scale?: number, Offset?: number);
+    clone(): UDim;
+}
+
+export declare class UDim2 {
+    X: UDim;
+    Y: UDim;
+    clone(): UDim2;
+}
+
+declare type UserInfo = {
+    id: number;
+    name: string;
+    displayName: string;
+};
+
+export declare interface UserLooks_Result {
+    data: {
+        assets: {
+            id: number;
+        }[];
+        bundles: {
+            id: number;
+        }[];
+        createdTime: string;
+        displayProperties: {
+            backgroundType: "None" | string;
+            backgroundValue: null;
+            emoteAssetId: null;
+        };
+        lookId: string;
+        lookType: "Avatar";
+        moderationStatus: "Approved";
+        name: string;
+        totalValue: number;
+        updatedTime: string;
+    }[];
+    nextCursor: string | null;
+    previousCursor: string | null;
+}
+
+declare type ValidationIssue = {
+    type: ValidationIssueType;
+    text: string;
+    assetIndex?: number;
+};
+
+declare type ValidationIssueType = "AccessoryLimit" | "LayeredLimit" | "OneOfTypeLimit" | "DuplicateId" | "NotWearable" | "MissingLayeredMeta" | "InvalidAsset";
+
+declare type Vec2 = [number, number];
+
+declare type Vec3 = [number, number, number];
+
+declare type Vec4 = [number, number, number, number];
+
+export declare class Vector2 {
+    X: number;
+    Y: number;
+    constructor(X?: number, Y?: number);
+    clone(): Vector2;
+    isSame(other: Vector2): boolean;
+}
+
+export declare class Vector3 {
+    X: number;
+    Y: number;
+    Z: number;
+    constructor(X?: number, Y?: number, Z?: number);
+    fromVec3(vec3: Vec3): this;
+    toVec3(): Vec3;
+    multiply(vec3: Vector3): Vector3;
+    divide(vec3: Vector3): Vector3;
+    add(vec3: Vector3): Vector3;
+    minus(vec3: Vector3): Vector3;
+    magnitude(): number;
+    normalize(): Vector3;
+    clone(): Vector3;
+    isSame(other: Vector3): boolean;
+    static new(X: number, Y: number, Z: number): Vector3;
+}
+
+declare type VecXYZ = {
+    X: number;
+    Y: number;
+    Z: number;
+};
+
+declare type Vecxyz = {
+    x: number;
+    y: number;
+    z: number;
+};
+
+export declare function versionToNumber(version: string): number;
+
+export declare function Wait(time: number): Promise<unknown>;
+
+export declare const WearableAssetTypes: string[];
+
+export declare const WrapLayerAutoSkin: {
+    Disabled: number;
+    EnabledPreserve: number;
+    EnabledOverride: number;
+};
+
+export declare const xmlMagic = "<roblox ";
+
+export { }