@rtsdk/topia 0.2.2 → 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,1251 @@
+/**
+ * BSD 3-Clause License
+ *
+ * Copyright (c) 2023, metaversecloud.com | topia.io
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+ *
+ * - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+ *
+ * - Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+import * as axios from 'axios';
+import { AxiosResponse, AxiosInstance, AxiosError } from 'axios';
+import jwt from 'jsonwebtoken';
+
+declare enum DroppedAssetClickType {
+    NONE = "none",
+    LINK = "link",
+    PORTAL = "portal",
+    TELEPORT = "teleport"
+}
+declare enum DroppedAssetMediaType {
+    NONE = "none",
+    LINK = "link"
+}
+
+type InteractiveCredentials = {
+    assetId?: string;
+    interactiveNonce?: string;
+    interactivePublicKey?: string;
+    visitorId?: number;
+    urlSlug?: string;
+    apiKey?: string;
+    profileId?: string | null;
+};
+
+type AssetOptions = {
+    attributes?: AssetInterface | undefined;
+    credentials?: InteractiveCredentials | undefined;
+};
+type DroppedAssetOptions = {
+    attributes?: DroppedAssetInterface | undefined;
+    credentials?: InteractiveCredentials | undefined;
+};
+type UserOptions = {
+    credentials?: InteractiveCredentials | undefined;
+};
+type VisitorOptions = {
+    attributes?: VisitorInterface | undefined;
+    credentials?: InteractiveCredentials | undefined;
+};
+type WorldOptions = {
+    attributes?: WorldInterface | undefined;
+    credentials?: InteractiveCredentials | undefined;
+};
+
+type ResponseType = {
+    message: string;
+    success: boolean;
+};
+
+/**
+ * @summary
+ * Create an instance of Scene class with a given scene id and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new Scene(topia, "sceneId", { attributes: { name: "My Scene" } });
+ * ```
+ */
+declare class Scene extends SDKController implements SceneInterface {
+    readonly id: string;
+    constructor(topia: Topia, id: string, options?: SceneOptionalInterface);
+    fetchSceneById(): Promise<void | ResponseType>;
+}
+
+/**
+ * @summary
+ * Create an instance of Dropped Asset class with a given dropped asset id, url slug, and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new DroppedAsset(topia, "1giFZb0sQ3X27L7uGyQX", "example", { attributes: { text: "" }, credentials: { assetId: "1giFZb0sQ3X27L7uGyQX" } } });
+ * ```
+ */
+declare class DroppedAsset extends Asset implements DroppedAssetInterface {
+    #private;
+    dataObject?: object | null;
+    readonly id?: string | undefined;
+    text?: string | null | undefined;
+    urlSlug: string;
+    isInteractive?: boolean | null;
+    interactivePublicKey?: string | null;
+    constructor(topia: Topia, id: string, urlSlug: string, options?: DroppedAssetOptionalInterface);
+    /**
+     * @summary
+     * Retrieves dropped asset details.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchDroppedAssetById();
+     * const { assetName } = droppedAsset;
+     * ```
+     */
+    fetchDroppedAssetById(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Delete dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.deleteDroppedAsset();
+     * ```
+     */
+    deleteDroppedAsset(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieves the data object for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchDataObject();
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    fetchDataObject(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Sets the data object for a dropped asset.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.setDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    setDataObject(dataObject: object, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates the data object for a dropped asset.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    updateDroppedAssetDataObject(dataObject: object, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates broadcast options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateBroadcast({
+     *   assetBroadcast: true,
+     *   assetBroadcastAll: true,
+     *   broadcasterEmail: "example@email.com"
+     * });
+     * ```
+     */
+    updateBroadcast({ assetBroadcast, assetBroadcastAll, broadcasterEmail, }: UpdateBroadcastInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates click options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateClickType({
+     *   "clickType": "portal",
+     *   "clickableLink": "https://topia.io",
+     *   "clickableLinkTitle": "My awesome link!",
+     *   "clickableDisplayTextDescription": "Description",
+     *   "clickableDisplayTextHeadline": "Title",
+     *   "position": {
+     *     "x": 0,
+     *     "y": 0
+     *   },
+     *   "portalName": "community"
+     * });
+     * ```
+     */
+    updateClickType({ clickType, clickableLink, clickableLinkTitle, clickableDisplayTextDescription, clickableDisplayTextHeadline, isForceLinkInIframe, isOpenLinkInDrawer, portalName, position, }: UpdateClickTypeInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates text and style of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * };
+     * await droppedAsset.updateCustomTextAsset(style, "hello world");
+     * ```
+     */
+    updateCustomTextAsset(style: object | undefined | null, text: string | null | undefined): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates media options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateMediaType({
+     *   "mediaType": "link",
+     *   "mediaLink": "https://www.youtube.com/watch?v=dQw4w9WgXcQ",
+     *   "isVideo": true,
+     *   "syncUserMedia": true,
+     *   "audioSliderVolume: 30"
+     *   "portalName": "community",
+     *   "audioRadius": 0,
+     *   "mediaName": "string"
+     * });
+     * ```
+     */
+    updateMediaType({ audioRadius, audioSliderVolume, isVideo, mediaLink, mediaName, mediaType, portalName, syncUserMedia, }: UpdateMediaTypeInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates mute zone options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateMuteZone(true);
+     * ```
+     */
+    updateMuteZone(isMutezone: boolean): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates webhook zone options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateWebhookZone(true);
+     * ```
+     */
+    updateWebhookZone(isWebhookZoneEnabled: boolean): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Moves a dropped asset to specified coordinates.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updatePosition(100,200);
+     * ```
+     */
+    updatePosition(x: number, y: number): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates private zone options for a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updatePrivateZone({
+     *   "isPrivateZone": false,
+     *   "isPrivateZoneChatDisabled": true,
+     *   "privateZoneUserCap": 10
+     * });
+     * ```
+     */
+    updatePrivateZone({ isPrivateZone, isPrivateZoneChatDisabled, privateZoneUserCap, }: UpdatePrivateZoneInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates the size of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.assetScale(.5);
+     * ```
+     */
+    updateScale(assetScale: number): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Change or remove media embedded in a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateUploadedMediaSelected("LVWyxwNxI96eLjnXWwYO");
+     * ```
+     */
+    updateUploadedMediaSelected(mediaId: string): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Change or remove top and bottom layers of a dropped asset.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateWebImageLayers("","https://www.shutterstock.com/image-vector/colorful-illustration-test-word-260nw-1438324490.jpg");
+     * ```
+     */
+    updateWebImageLayers(bottom: string, top: string): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Add a webhook to a dropped asset
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.addWebhook({
+     *   active: true,
+     *   dataObject: {},
+     *   description: "Webhook desc",
+     *   enteredBy: "you",
+     *   isUniqueOnly: false,
+     *   title: "title",
+     *   type: "type",
+     *   url: "https://url.com",
+     *   urlSlug: "world",
+     * });
+     * ```
+     */
+    addWebhook({ dataObject, description, isUniqueOnly, title, type, url, }: {
+        dataObject: object;
+        description: string;
+        isUniqueOnly: boolean;
+        title: string;
+        type: string;
+        url: string;
+    }): Promise<void | AxiosResponse>;
+    /**
+     * @summary
+     * Set the interactive settings on a dropped asset
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.setInteractiveSettings({
+     *   isInteractive: true,
+     *   interactivePublicKey: "xyz"
+     * });
+     * ```
+     */
+    setInteractiveSettings({ isInteractive, interactivePublicKey, }: {
+        isInteractive?: boolean;
+        interactivePublicKey: string;
+    }): Promise<void | ResponseType>;
+}
+
+/**
+ * @summary
+ * Create an instance of World class with a given url slug and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new World(topia, "exampleWorld", { attributes: { name: "Example World" } });
+ * ```
+ */
+declare class World extends SDKController implements WorldInterface {
+    #private;
+    urlSlug: string;
+    constructor(topia: Topia, urlSlug: string, options?: WorldOptionalInterface);
+    get droppedAssets(): {
+        [key: string]: DroppedAsset;
+    };
+    /**
+     * @summary
+     * Retrieves details of a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDetails();
+     * const { name } = world;
+     * ```
+     */
+    fetchDetails(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Update details of a world.
+     *
+     * @usage
+     * ```ts
+     * await world.updateDetails({
+     *   controls: {
+     *     allowMuteAll: true,
+     *     disableHideVideo: true,
+     *     isMobileDisabled: false,
+     *     isShowingCurrentGuests: false,
+     *   },
+     *   description: 'Welcome to my world.',
+     *   forceAuthOnLogin: false,
+     *   height: 2000,
+     *   name: 'Example',
+     *   spawnPosition: { x: 100, y: 100 },
+     *   width: 2000
+     * });
+     * ```
+     */
+    updateDetails({ controls, description, forceAuthOnLogin, height, name, spawnPosition, width, }: WorldInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieve all assets dropped in a world.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDroppedAssets();
+     * const assets = world.droppedAssets;
+     * ```
+     */
+    fetchDroppedAssets(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieve all assets dropped in a world matching uniqueName.
+     *
+     * @usage
+     * ```ts
+     * await world.fetchDroppedAssets();
+     * const assets = world.droppedAssets;
+     * ```
+     */
+    fetchDroppedAssetsWithUniqueName({ uniqueName, isPartial, isReversed, }: {
+        uniqueName: string;
+        isPartial?: boolean;
+        isReversed?: boolean;
+    }): Promise<DroppedAsset[]>;
+    /**
+     * @summary
+     * Update multiple custom text dropped assets with a single style while preserving text for specified dropped assets only.
+     *
+     * @usage
+     * ```ts
+     * const droppedAssetsToUpdate = [world.droppedAssets["6"], world.droppedAssets["12"]];
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * };
+     * await world.updateCustomText(droppedAssetsToUpdate, style);
+     * ```
+     *
+     * @result
+     * Updates each DroppedAsset instance and world.droppedAssets map.
+     */
+    updateCustomTextDroppedAssets(droppedAssetsToUpdate: Array<DroppedAsset>, style: object): Promise<object>;
+    /**
+     * @summary
+     * Drop a scene in a world.
+     *
+     * @usage
+     * ```ts
+     * await world.dropScene({
+     *   "sceneId": "string",
+     *   "position": {
+     *     "x": 0,
+     *     "y": 0
+     *   },
+     *   "assetSuffix": "string"
+     * });
+     * ```
+     */
+    dropScene({ assetSuffix, position, sceneId, }: {
+        assetSuffix: string;
+        position: object;
+        sceneId: string;
+    }): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Replace the current scene of a world.
+     *
+     * @usage
+     * ```ts
+     * const droppedAssetsToUpdate = [world.droppedAssets["6"], world.droppedAssets["12"]]
+     * const style = {
+     *   "textColor": "#abc123",
+     *   "textFontFamily": "Arial",
+     *   "textSize": 40,
+     *   "textWeight": "normal",
+     *   "textWidth": 200
+     * }
+     * await world.replaceScene(SCENE_ID);
+     * ```
+     */
+    replaceScene(sceneId: string): Promise<void | ResponseType>;
+}
+
+/**
+ * @summary
+ * Create an instance of User class with optional session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new User(topia, { interactiveNonce: "exampleNonce", interactivePublicKey: "examplePublicKey", visitorId: 1 });
+ * ```
+ */
+declare class User extends SDKController {
+    #private;
+    profileId?: string | null;
+    dataObject?: object | null | undefined;
+    profile?: Record<string, any>;
+    constructor(topia: Topia, options?: UserOptionalInterface);
+    get assets(): {
+        [key: string]: Asset;
+    };
+    get scenes(): {
+        [key: string]: Scene;
+    };
+    get worlds(): {
+        [key: string]: World;
+    };
+    /**
+     * @summary
+     * Returns all assets owned by User when an email address is provided.
+     */
+    fetchAssets(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Returns all scenes owned by User
+     */
+    fetchScenes(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieves all worlds owned by user with matching API Key,
+     * creates a new World object for each,
+     * and creates new map of Worlds accessible via user.worlds.
+     *
+     * @usage
+     * ```ts
+     * await user.fetchWorldsByKey();
+     * const userWorlds = user.worlds;
+     * ```
+     *
+     * @result
+     * ```ts
+     * { urlSlug: new World({ apiKey, worldArgs, urlSlug }) }
+     * ```
+     */
+    fetchWorldsByKey(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieves the data object for a user.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchDataObject();
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    fetchDataObject(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Sets the data object for a user.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.setDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    setDataObject(dataObject: object | null | undefined, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates the data object for a user.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateUserDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    updateDataObject(dataObject: object, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+}
+
+/**
+ * @summary
+ * Create an instance of Visitor class with a given id and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new Visitor(topia, id, urlSlug, { attributes: { moveTo: { x: 0, y: 0 } } });
+ * ```
+ */
+declare class Visitor extends User implements VisitorInterface {
+    #private;
+    readonly id: number;
+    urlSlug: string;
+    user?: User;
+    constructor(topia: Topia, id: number, urlSlug: string, options?: VisitorOptionalInterface);
+    /**
+     * @summary
+     * Get a single visitor from a world
+     *
+     * @usage
+     * ```ts
+     * await visitor.fetchVisitor();
+     * ```
+     *
+     * @result
+     * Returns details for a visitor in a world by id and urlSlug
+     */
+    fetchVisitor(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Teleport or walk a visitor currently in a world to a single set of coordinates.
+     *
+     * @usage
+     * ```ts
+     * await visitor.moveVisitor({
+     *   shouldTeleportVisitor: true,
+     *   x: 100,
+     *   y: 100,
+     * });
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveVisitor({ shouldTeleportVisitor, x, y }: MoveVisitorInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Display a message via a toast to a visitor currently in a world.
+     *
+     * @usage
+     * ```ts
+     * await visitor.fireToast({
+     *   groupId: "custom-message",
+     *   title: "Hello World",
+     *   text: "Thank you for participating!",
+     * });
+     * ```
+     */
+    fireToast({ groupId, title, text }: FireToastInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Open an iframe in a drawer or modal for a visitor currently in a world.
+     *
+     * @usage
+     * ```ts
+     * await visitor.openIframe({
+     *   link: "https://topia.io",
+     *   shouldOpenInDrawer: true,
+     *   title: "Hello World",
+     * });
+     * ```
+     */
+    openIframe({ link, shouldOpenInDrawer, title }: OpenIframeInterface): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Retrieves the data object for a visitor.
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.fetchVisitorDataObject();
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    fetchDataObject(): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Sets the data object for a visitor.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.setVisitorDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    setDataObject(dataObject: object | null | undefined, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+    /**
+     * @summary
+     * Updates the data object for a visitor.
+     *
+     * Optionally, a lock can be provided with this request to ensure only one update happens at a time between all updates that share the same lock id
+     *
+     * @usage
+     * ```ts
+     * await droppedAsset.updateVisitorDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    updateDataObject(dataObject: object, options?: {
+        lock?: {
+            lockId: string;
+            releaseLock?: boolean;
+        };
+    }): Promise<void | ResponseType>;
+}
+
+type VisitorType = {
+    visitorId: number;
+    color: string;
+    displayName: string;
+    gestureType: number;
+    hidden: boolean;
+    isAdmin: boolean;
+    isBackground: boolean;
+    isMobile: boolean;
+    isRecording: boolean;
+    isRecordingBot: boolean;
+    lastUpdate: number;
+    moveFrom: object;
+    movedOn: number;
+    moveTo: {
+        x: number;
+        y: number;
+    };
+    muted: boolean;
+    performer: boolean;
+    performerNear: boolean;
+    shareScreen: boolean;
+    sitting: boolean;
+    username: string;
+};
+type VisitorsToMoveType = {
+    visitorObj: Visitor;
+    shouldTeleportVisitor: boolean;
+    x: number;
+    y: number;
+};
+type VisitorsToMoveArrayType = Array<VisitorsToMoveType>;
+
+interface SDKInterface {
+    credentials?: InteractiveCredentials;
+    jwt?: string;
+    requestOptions: object;
+    topia: Topia;
+}
+
+interface AssetInterface extends SDKInterface {
+    fetchPlatformAssets(): Promise<object>;
+    addedOn?: string;
+    assetName?: string;
+    creatorTags?: object;
+    readonly id?: string;
+    isPublic?: boolean;
+    library?: string;
+    originalAssetId?: string;
+    originalKit?: string;
+    ownerId?: string;
+    ownerName?: string;
+    platformAsset?: boolean;
+    purchased?: boolean;
+    purchaseDate?: string;
+    purchasedFrom?: string;
+    specialType?: string | null;
+    transactionId?: string;
+    type?: string;
+}
+type AssetOptionalInterface = {
+    attributes?: AssetInterface | object;
+    credentials?: InteractiveCredentials | object;
+};
+
+interface DroppedAssetInterface extends AssetInterface {
+    id?: string;
+    assetId?: string;
+    assetScale?: number | null;
+    assetPodium?: boolean | null;
+    audioRadius?: number | null;
+    assetBroadcastAll?: boolean | null;
+    assetPrivateConversation?: boolean | null;
+    assetPrivateZoneChannelDisabled?: boolean | null;
+    assetPrivateConversationCap?: number | null;
+    audioSliderVolume?: number | null;
+    broadcasterEmail?: string | null;
+    clickType?: string | null;
+    clickableLink?: string | null;
+    clickableLinkTitle?: string | null;
+    clickablePortal?: string | null;
+    creationDatetime?: number;
+    contractAddress?: string | null;
+    dataObject?: object | null;
+    clickableDisplayTextDescription?: string | null;
+    clickableDisplayTextHeadline?: string | null;
+    existingKey?: string | null;
+    interactivePublicKey?: string | null;
+    isInteractive?: boolean | null;
+    isVideoPlayer?: boolean | null;
+    kitId?: string | null;
+    layer0?: string | null;
+    layer1?: string | null;
+    mediaLink?: string | null;
+    mediaPlayTime?: number | null;
+    mediaType?: string | null;
+    mediaName?: string | null;
+    muteZone?: boolean | null;
+    mediaUploadedId?: string | null;
+    mediaUploadedLink?: string | null;
+    metaName?: string | null;
+    position?: {
+        x?: number;
+        y?: number;
+    };
+    portalCoordsX?: number | null;
+    portalCoordsY?: number | null;
+    showMediaAsIfPeer?: boolean | null;
+    syncUserMedia?: boolean | null;
+    urlSlug: string;
+    tagJson?: string | null;
+    text?: string | null;
+    textColor?: string | null;
+    textSize?: number | null;
+    textWidth?: number | null;
+    textWeight?: string | null;
+    textFont?: string | null;
+    textFontFamily?: string | null;
+    teleportX?: number | null;
+    teleportY?: number | null;
+    tokenSymbol?: string | null;
+    tokenName?: string | null;
+    worldId?: string | null;
+    walletAddress?: string | null;
+    yOrderAdjust?: number | null;
+}
+interface DroppedAssetOptionalInterface {
+    attributes?: DroppedAssetInterface | {
+        text: string;
+        urlSlug?: string;
+    };
+    credentials?: InteractiveCredentials | object;
+}
+interface UpdateBroadcastInterface {
+    assetBroadcast?: boolean;
+    assetBroadcastAll?: boolean;
+    broadcasterEmail?: string;
+}
+interface UpdateClickTypeInterface {
+    clickType: DroppedAssetClickType;
+    clickableLink: string;
+    clickableLinkTitle: string;
+    clickableDisplayTextDescription: string;
+    clickableDisplayTextHeadline: string;
+    isForceLinkInIframe?: boolean;
+    isOpenLinkInDrawer?: boolean;
+    portalName: string;
+    position: {
+        x: number;
+        y: number;
+    };
+}
+interface UpdateMediaTypeInterface {
+    audioRadius: number;
+    audioSliderVolume: number;
+    isVideo: boolean;
+    mediaLink: string;
+    mediaName: string;
+    mediaType: DroppedAssetMediaType;
+    portalName: string;
+    syncUserMedia: boolean;
+}
+interface UpdatePrivateZoneInterface {
+    isPrivateZone: boolean;
+    isPrivateZoneChatDisabled: boolean;
+    privateZoneUserCap: number;
+}
+
+interface SceneInterface {
+    id: string;
+    background?: null;
+    description?: string;
+    created?: {
+        _seconds?: number;
+        _nanoseconds?: number;
+    };
+    height?: number;
+    kitWorldOwner?: string;
+    name?: string;
+    price?: number;
+    spawnPosition?: {
+        radius?: number;
+        y?: number;
+        x?: number;
+    };
+    timesUsed?: number;
+    urlSlug?: string;
+    width?: number;
+    worldCenteredAtZero?: boolean;
+}
+type SceneOptionalInterface = {
+    attributes?: SceneInterface | object;
+    credentials?: InteractiveCredentials | object;
+};
+
+interface TopiaInterface {
+    apiDomain?: string;
+    apiKey?: string;
+    apiProtocol?: string;
+    axios: AxiosInstance;
+    interactiveKey?: string;
+    interactiveSecret?: jwt.Secret;
+}
+
+interface UserOptionalInterface {
+    credentials?: InteractiveCredentials | object;
+    profileId?: string | null;
+    visitorId?: number | null;
+    urlSlug?: string;
+}
+
+interface VisitorInterface extends SDKInterface {
+    color?: string;
+    dataObject?: object | null | undefined;
+    displayName?: string;
+    gestureType?: number;
+    hidden?: boolean;
+    isAdmin?: boolean;
+    isBackground?: boolean;
+    isMobile?: boolean;
+    isRecording?: boolean;
+    isRecordingBot?: boolean;
+    lastUpdate?: number | undefined;
+    moveFrom?: object;
+    movedOn?: number | undefined;
+    moveTo?: {
+        x?: number;
+        y?: number;
+    };
+    muted?: boolean;
+    performer?: boolean;
+    performerNear?: boolean;
+    id?: number | undefined;
+    shareScreen?: boolean;
+    sitting?: boolean;
+    urlSlug: string;
+    username?: string | undefined;
+}
+interface VisitorOptionalInterface {
+    attributes?: VisitorInterface | object;
+    credentials?: InteractiveCredentials | object;
+}
+interface MoveVisitorInterface {
+    shouldTeleportVisitor: boolean;
+    x: number;
+    y: number;
+}
+interface FireToastInterface {
+    groupId?: string;
+    title: string;
+    text?: string;
+}
+interface OpenIframeInterface {
+    link: string;
+    shouldOpenInDrawer?: boolean;
+    title?: string;
+}
+
+interface WorldActivityOptionalInterface {
+    credentials?: InteractiveCredentials | object;
+}
+interface MoveAllVisitorsInterface {
+    shouldFetchVisitors?: boolean;
+    shouldTeleportVisitors?: boolean;
+    scatterVisitorsBy?: number;
+    x: number;
+    y: number;
+}
+
+interface WorldInterface extends SDKInterface {
+    background?: string | null;
+    controls?: {
+        allowMuteAll?: boolean;
+        disableHideVideo?: boolean;
+        isMobileDisabled?: boolean;
+        isShowingCurrentGuests?: boolean;
+    };
+    created?: object;
+    description?: string;
+    enforceWhitelistOnLogin?: boolean;
+    forceAuthOnLogin?: boolean;
+    height?: number;
+    heroImage?: string;
+    mapExists?: boolean;
+    name?: string;
+    redirectTo?: string | null;
+    spawnPosition?: {
+        x?: number;
+        y?: number;
+    };
+    tileBackgroundEverywhere?: boolean | null;
+    urlSlug: string;
+    useTopiaPassword?: boolean;
+    width?: number;
+}
+interface WorldOptionalInterface {
+    attributes?: WorldInterface | object;
+    credentials?: InteractiveCredentials | object;
+}
+
+/**
+ * @summary
+ * Create a single instance of Topia axios used for all calls to the public API in all classes
+ *
+ * @usage
+ * ```ts
+ * const topia = await new Topia({
+ *   apiDomain: "api.topia.io",
+ *   apiKey: "exampleKey",
+ *   interactiveKey: "key",
+ *   interactiveSecret: "secret",
+ * });
+ * ```
+ */
+declare class Topia implements TopiaInterface {
+    axios: AxiosInstance;
+    apiDomain?: string;
+    apiKey?: string;
+    apiProtocol?: string;
+    interactiveKey?: string;
+    interactiveSecret?: jwt.Secret;
+    constructor({ apiDomain, apiKey, apiProtocol, interactiveKey, interactiveSecret, }: {
+        apiDomain?: string;
+        apiKey?: string;
+        apiProtocol?: string;
+        interactiveKey?: string;
+        interactiveSecret?: jwt.Secret;
+    });
+}
+
+/**
+ * @summary
+ * Create an instance of SDKController class with credentials.
+ *
+ * @usage
+ * ```ts
+ * const credentials = {
+ *   assetId: "exampleAsset",
+ *   interactiveNonce: "exampleNonce"
+ *   interactivePublicKey: "examplePublicKey",
+ *   visitorId: 1,
+ *   url: "https://topia.io",
+ * }
+ * const topia = await new Topia({
+ *   apiDomain: "api.topia.io",
+ *   apiKey: "exampleKey",
+ *   interactiveKey: "key",
+ *   interactiveSecret: "secret",
+ * }
+ * await new SDKController({ credentials, topia });
+ * ```
+ */
+declare class SDKController implements SDKInterface {
+    credentials: InteractiveCredentials | undefined;
+    jwt?: string;
+    requestOptions: object;
+    topia: Topia;
+    constructor(topia: Topia, credentials?: InteractiveCredentials);
+    topiaPublicApi(): axios.AxiosInstance;
+    errorHandler({ error, message, }: {
+        error?: Error | AxiosError | unknown;
+        message?: string;
+    }): {
+        data: {};
+        message: string;
+        method: string;
+        stack: string;
+        stackTrace: Error;
+        status: number;
+        success: boolean;
+        url: string;
+    };
+}
+
+/**
+ * @summary
+ * Create an instance of Asset class with a given asset id and optional attributes and session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new Asset(topia, "assetId", { attributes: { assetName: "My Asset", isPublic: false } });
+ * ```
+ */
+declare class Asset extends SDKController implements AssetInterface {
+    readonly id?: string;
+    constructor(topia: Topia, id: string, options?: AssetOptionalInterface);
+    fetchPlatformAssets(): Promise<object | ResponseType>;
+}
+
+/**
+ * @summary
+ * Create an instance of WorldActivity class with a given url slug and optional attributes and session credentials.
+ *
+ * This class is responsible for all activity of a specified world including editing dropped assets, moving current visitors, etc.
+ *
+ * @usage
+ * ```ts
+ * await new WorldActivity(topia, "exampleWorld", { attributes: { name: "Example World" } });
+ * ```
+ */
+declare class WorldActivity extends SDKController {
+    #private;
+    urlSlug: string;
+    constructor(topia: Topia, urlSlug: string, options?: WorldActivityOptionalInterface);
+    get visitors(): {
+        [key: string]: Visitor;
+    };
+    private fetchVisitors;
+    /**
+     * @summary
+     * Retrieve all visitors currently in a world.
+     *
+     * @usage
+     * ```ts
+     * const visitors = await world.currentVisitors();
+     * ```
+     */
+    currentVisitors(): Promise<unknown>;
+    /**
+     * @summary
+     * Move all visitors currently in a world to a single set of coordinates.
+     * Optionally refetch visitors, teleport or walk visitors to new location,
+     * and scatter visitors by any number so that they don't all move to the exact same location.
+     *
+     * @usage
+     * ```ts
+     * await world.moveAllVisitors({
+     *   shouldFetchVisitors: true,
+     *   shouldTeleportVisitors: true,
+     *   scatterVisitorsBy: 40,
+     *   x: 100,
+     *   y: 100,
+     * });
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveAllVisitors({ shouldFetchVisitors, shouldTeleportVisitors, scatterVisitorsBy, x, y, }: MoveAllVisitorsInterface): Promise<(void | ResponseType)[] | undefined>;
+    /**
+     * @summary
+     * Teleport or walk a list of visitors currently in a world to various coordinates.
+     *
+     * @usage
+     * ```ts
+     * const visitorsToMove = [
+     *   {
+     *     visitorObj: world.visitors["1"],
+     *     shouldTeleportVisitor: true,
+     *     x: 100,
+     *     y: 100
+     *   }, {
+     *     visitorObj: world.visitors["2"],
+     *     shouldTeleportVisitor: false,
+     *     x: 100,
+     *     y: 100
+     *   }
+     * ];
+     * await world.moveVisitors(visitorsToMove);
+     * ```
+     *
+     * @result
+     * Updates each Visitor instance and world.visitors map.
+     */
+    moveVisitors(visitorsToMove: VisitorsToMoveArrayType): Promise<(void | ResponseType)[]>;
+}
+
+declare class AssetFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: string, options?: AssetOptionalInterface): Asset;
+}
+
+declare class DroppedAssetFactory extends SDKController {
+    constructor(topia: Topia);
+    create(id: string, urlSlug: string, options?: DroppedAssetOptionalInterface): DroppedAsset;
+    get(id: string, urlSlug: string, options?: DroppedAssetOptionalInterface): Promise<DroppedAsset>;
+    drop(asset: Asset, { position: { x, y }, uniqueName, urlSlug, }: {
+        position: {
+            x: number;
+            y: number;
+        };
+        uniqueName?: string;
+        urlSlug: string;
+    }): Promise<DroppedAsset>;
+}
+
+declare class SceneFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: string, options?: SceneOptionalInterface): Scene;
+    get(id: string, options?: SceneOptionalInterface): Promise<Scene>;
+}
+
+declare class UserFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(options?: UserOptionalInterface): User;
+}
+
+declare class VisitorFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(id: number, urlSlug: string, options?: VisitorOptionalInterface): Visitor;
+    get(id: number, urlSlug: string, options?: VisitorOptionalInterface): Promise<Visitor>;
+}
+
+declare class WorldActivityFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(urlSlug: string, options?: WorldOptionalInterface): WorldActivity;
+}
+
+declare class WorldFactory {
+    topia: Topia;
+    constructor(topia: Topia);
+    create(urlSlug: string, options?: WorldOptionalInterface): World;
+}
+
+export { AssetFactory, AssetInterface, AssetOptionalInterface, AssetOptions, DroppedAssetClickType, DroppedAssetFactory, DroppedAssetInterface, DroppedAssetMediaType, DroppedAssetOptionalInterface, DroppedAssetOptions, FireToastInterface, InteractiveCredentials, MoveAllVisitorsInterface, MoveVisitorInterface, OpenIframeInterface, ResponseType, SDKInterface, SceneFactory, SceneInterface, SceneOptionalInterface, Topia, TopiaInterface, UpdateBroadcastInterface, UpdateClickTypeInterface, UpdateMediaTypeInterface, UpdatePrivateZoneInterface, UserFactory, UserOptionalInterface, UserOptions, VisitorFactory, VisitorInterface, VisitorOptionalInterface, VisitorOptions, VisitorType, VisitorsToMoveArrayType, VisitorsToMoveType, WorldActivityFactory, WorldActivityOptionalInterface, WorldFactory, WorldInterface, WorldOptionalInterface, WorldOptions };