@rtsdk/topia 0.0.31 → 0.1.1

package/dist/types/src/controllers/DroppedAsset.d.ts

@@ -0,0 +1,285 @@
+import { AxiosResponse } from "axios";
+import { Asset } from "controllers/Asset";
+import { Topia } from "controllers/Topia";
+import { DroppedAssetInterface, DroppedAssetOptionalInterface, UpdateBroadcastInterface, UpdateClickTypeInterface, UpdateMediaTypeInterface, UpdatePrivateZoneInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @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" } } });
+ * ```
+ */
+export 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.fetchDroppedAssetDataObject();
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    fetchDroppedAssetDataObject(): 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.setDroppedAssetDataObject({
+     *   "exampleKey": "exampleValue",
+     * });
+     * const { dataObject } = droppedAsset;
+     * ```
+     */
+    setDroppedAssetDataObject(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.updateDroppedAssetDataObject({
+     *   "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, 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, 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>;
+}
+export default DroppedAsset;

package/dist/types/src/controllers/SDKController.d.ts

@@ -0,0 +1,48 @@
+import { Topia } from "controllers/Topia";
+import { SDKInterface } from "interfaces";
+import { InteractiveCredentials } from "types";
+import { AxiosError } from "axios";
+/**
+ * @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 });
+ * ```
+ */
+export declare class SDKController implements SDKInterface {
+    credentials: InteractiveCredentials | undefined;
+    jwt?: string;
+    requestOptions: object;
+    topia: Topia;
+    constructor(topia: Topia, credentials?: InteractiveCredentials);
+    topiaPublicApi(): import("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;
+    };
+}
+export default SDKController;

package/dist/types/src/controllers/Scene.d.ts

@@ -0,0 +1,19 @@
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { SceneInterface, SceneOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @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" } });
+ * ```
+ */
+export declare class Scene extends SDKController implements SceneInterface {
+    readonly id: string;
+    constructor(topia: Topia, id: string, options?: SceneOptionalInterface);
+    fetchSceneById(): Promise<void | ResponseType>;
+}
+export default Scene;

package/dist/types/src/controllers/Topia.d.ts

@@ -0,0 +1,33 @@
+import { AxiosInstance } from "axios";
+import { TopiaInterface } from "interfaces";
+import jwt from "jsonwebtoken";
+/**
+ * @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",
+ * });
+ * ```
+ */
+export 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;
+    });
+}
+export default Topia;

package/dist/types/src/controllers/User.d.ts

@@ -0,0 +1,58 @@
+import { Asset } from "controllers/Asset";
+import { Scene } from "controllers/Scene";
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { World } from "controllers/World";
+import { UserOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @summary
+ * Create an instance of User class with optional session credentials.
+ *
+ * @usage
+ * ```ts
+ * await new User(topia, { interactiveNonce: "exampleNonce", interactivePublicKey: "examplePublicKey", visitorId: 1 });
+ * ```
+ */
+export declare class User extends SDKController {
+    #private;
+    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>;
+}
+export default User;

package/dist/types/src/controllers/Visitor.d.ts

@@ -0,0 +1,50 @@
+import { Topia } from "controllers/Topia";
+import { User } from "controllers/User";
+import { MoveVisitorInterface, VisitorInterface, VisitorOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @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 } } });
+ * ```
+ */
+export declare class Visitor extends User implements VisitorInterface {
+    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>;
+}
+export default Visitor;

package/dist/types/src/controllers/World.d.ts

@@ -0,0 +1,143 @@
+import { DroppedAsset } from "controllers/DroppedAsset";
+import { SDKController } from "controllers/SDKController";
+import { Topia } from "controllers/Topia";
+import { WorldInterface, WorldOptionalInterface } from "interfaces";
+import { ResponseType } from "types";
+/**
+ * @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" } });
+ * ```
+ */
+export 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>;
+}
+export default World;