@rtsdk/topia 0.8.5 → 0.9.0

package/README.md

@@ -1,12 +1,10 @@
 # Javascript RTSDK - Topia Client Library
 
-The Topia Client Library leverages the Topia Public API and allows users to interact with the topia systems and modify their world programmatically. With the SDK you can now build new features to be used in Topia! Check out a list of examples [here](https://github.com/metaversecloud-com/sdk-examples). Questions, comments, or have something exciting to share with the Topia team? Reach out to [developers@topia.io](mailto:developers@topia.io)!
-
-<br>
+The Topia Client Library leverages the Topia Public API and allows users to interact with the topia systems and modify their world programmatically. With the SDK you can now build new features to be used in Topia! Questions, comments, or have something exciting to share with the Topia team? Reach out to [developers@topia.io](mailto:developers@topia.io)!
 
 ## Authorization
 
-A Topia provided API Key can be included with every object initialization as a parameter named `apiKey`. This API Key is used to in authorization headers in all calls to the Public API.
+A Topia provided API Key can be included with every object initialization as a parameter named `apiKey`. This API Key is used to in authorization headers in all calls to the Public API. Use it wisely and sparingly! The API Key should only be used to authorize your app (and therefore all of it's users) to perform specific actions. In most case the ability to interact with an SDK application should be controlled per user using Interactive Credentials (see below).
 
 ### Want to build interactive assets? This is how you can get started:
 
@@ -37,11 +35,9 @@ Make an asset “interactive” by adding your PUBLIC key to the integrations pa
 ```ts
 await DroppedAsset.get(assetId, urlSlug, {
   credentials: {
-    assetId,
     interactivePublicKey,
     interactiveNonce,
     visitorId,
-    urlSlug,
   },
 });
 ```
@@ -58,7 +54,7 @@ await DroppedAsset.get(assetId, urlSlug, {
 
 Alternatively, visitors of a [topia.io](https://topia.io/) world interact with each other and the interactively configured assets in your world without the need for an API Key. This is all made possible through Interactive Session credentials passed to the SDK with every request, when applicable. What does this mean for you? Not much, actually! All of the magic happens behind the scenes and all you have to do is make sure that new class constructors include an options object like this: `options: WorldOptionalInterface = { attributes: {}, credentials: {} }` and all calls to `this.topia.axios` include the inherited `this.requestOptions` parameter.
 
-![Interactive Application Development Diagram](./InteractiveApplicationDevelopment.png)
+![Interactive Application Development Diagram](https://raw.githubusercontent.com/metaversecloud-com/mc-sdk-js/main/clients/client-topia/InteractiveApplicationDevelopment.png)
 
 <br>
 
@@ -66,12 +62,28 @@ Alternatively, visitors of a [topia.io](https://topia.io/) world interact with e
 
 # Developers
 
-Need inspiration?! Check out our [example application](https://sdk-examples.metaversecloud.com/) which utilizes the SDK to create new and enhanced features inside [topia.io](https://topia.io/).
+<hr/>
+
+Need inspiration?! Check out the following applications which utilizes the SDK to create new and enhanced features inside [topia.io](https://topia.io/):
+
+- **TicTacToe:** A turn based multiplayer game built completely on the canvas.
+  - [Github](https://github.com/metaversecloud-com/sdk-tictactoe)
+  - [Demo](https://topia.io/tictactoe-prod)
+- **Quest:** A dynamic hide and seek game where an admin can drop multiple quest items within a world for users to find.
+  - [Github](https://github.com/metaversecloud-com/sdk-quest)
+  - [Demo](https://topia.io/quest-prod)
 
 <br>
 
 ## Get Started
 
+### Boilerplates
+
+We have two boilerplates available to help you get started. Pick the one that best suits your needs, clone it, and let the coding begin!
+
+- [Javascript](https://github.com/metaversecloud-com/sdk-boilerplate)
+- [Typescript](https://github.com/metaversecloud-com/sdk-ts-boilerplate)
+
 Run `yarn add @rtsdk/topia` or `npm install @rtsdk/topia`
 
 Create your instance of Topia and instantiate the factories you need:
@@ -84,7 +96,6 @@ import { AssetFactory, Topia, DroppedAssetFactory, UserFactory, WorldFactory } f
 
 const config = {
   apiDomain: process.env.INSTANCE_DOMAIN || "https://api.topia.io/",
-  apiKey: process.env.API_KEY,
   interactiveKey: process.env.INTERACTIVE_KEY,
   interactiveSecret: process.env.INTERACTIVE_SECRET,
 };
@@ -107,10 +118,14 @@ Put it to use:
 import { DroppedAsset } from "./pathToAboveCode";
 
 export const getAssetAndDataObject = async (req) => {
-  const { assetId, urlSlug } = req.body;
+  const { assetId, interactiveNonce, interactivePublicKey, urlSlug, visitorId } = req.query;
 
   const droppedAsset = await DroppedAsset.get(assetId, urlSlug, {
-    credentials: req.body,
+    credentials: {
+      interactiveNonce,
+      interactivePublicKey,
+      visitorId,
+    },
   });
 
   await droppedAsset.fetchDroppedAssetDataObject();
@@ -118,10 +133,90 @@ export const getAssetAndDataObject = async (req) => {
 };
 ```
 
+## Data Objects
+
+Data Objects can be used to store information such as game state, configurations, themes, and analytics.
+There are three types of Data Objects:
+
+- **World:** The World data object should be used to store information unique to your app in a given world but not necessarily specific details about an instance or an active game. This information would persist even if the app was removed from the world.
+  - **Example - Update two specific data points:**
+    ```js
+    await world.updateDataObject({
+      [`keyAssets.${keyAssetId}.itemsCollectedByUser.${profileId}`]: { [dateKey]: { count: 1 }, total: 1 },
+      [`profileMapper.${profileId}`]: username,
+    });
+    ```
+  - **Example - Increment a specific value within the data object by 1:**
+    ```js
+    await world.incrementDataObjectValue([`keyAssets.${keyAssetId}.totalItemsCollected.count`], 1);
+    ```
+- **Dropped Asset:** The Dropped Asset data object should only store what is unique to the specific instance of the app in the world such as game state. If the Dropped Asset is deleted, the data object would be lost as well so be sure to only store information here the doesn't need to persist!
+  - **Example - Initialize data object with default data and keyAssetId:**
+    ```js
+    await droppedAsset.setDataObject(
+      {
+        ...defaultGameData,
+        keyAssetId: droppedAsset.id,
+      },
+      { lock: { lockId, releaseLock: true } },
+    );
+    ```
+  - **Example - Update lastInteraction date and playerCount:**
+    ```js
+    await droppedAsset.updateDataObject({ lastInteraction: new Date(), playerCount: playerCount + 1 });
+    ```
+- **User:** The User data object should be used to store information unique to a user that is NOT unique to a world or instance (dropped asset) of an app.
+  - **Example - Update totalMessagesSentCount by a user across all worlds:**
+    ```js
+    await world.incrementDataObjectValue([`totalMessagesSentCount`], 1);
+    ```
+
+### Data Object Locking
+
+All of our data object set, update, and increment methods have an optional lock argument. You can create a lock id using that parameters specific to the action you are taking plus a timestamp so that the lock will expire after a certain amount of time has passed. As an example, TicTacToe allows users to Reset the game board so that they can start a new game but we'd only want the reset to happen once even if the user(s) press the button multiple times. To prevent multiple resets from happening within a 10 second window (stopping the calls from going through and preventing the race condition), we'd lock the object by doing the following:
+
+```js
+try {
+  await droppedAsset.updateDataObject(
+    { isResetInProgress: true },
+    {
+      lock: { lockId: `${assetId}-${resetCount}-${new Date(Math.round(new Date().getTime() / 10000) * 10000)}` },
+    },
+  );
+} catch (error) {
+  return res.status(409).json({ message: "Reset already in progress." });
+}
+```
+
+Using the code above would also allow us to check if `isResetInProgress === true` and prevent the code from progress immediately. Make sure that when using a lock such as this that you also call `await droppedAsset.updateDataObject({ isResetInProgress: false })};` after all reset functionality has been executed.
+
+**Turn based locking**
+Locking data object updates can also be extremely helpful when building a turn based game. As an example, TicTacToe should only allow one user to take a turn at a time. To prevent multiple moves at once we could use the following:
+
+```js
+try {
+  const timestamp = new Date(Math.round(new Date().getTime() / 5000) * 5000);
+  const lockId = `${keyAssetId}-${resetCount}-${turnCount}-${timestamp}`;
+  await droppedAsset.updateDataObject({}, { lock: { lockId, releaseLock: false } });
+} catch (error) {
+  return res.status(409).json({ message: "Move already in progress." });
+}
+```
+
+Once complete be sure to also call `await keyAsset.updateDataObject({ turnCount: turnCount + 1 });` so that the next player is free to take their turn!
+
+<br>
+
 <hr/>
 
+<br>
+
 # Contributors
 
+<hr/>
+
+<br>
+
 ## Get Started
 
 Run `gh repo clone metaversecloud-com/mc-sdk-js`

package/dist/index.cjs

@@ -39717,7 +39717,7 @@ class SDKController {
  */
 class Asset extends SDKController {
     constructor(topia, id, options = { attributes: {}, credentials: {} }) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         // assetId and urlSlug should only be used when Asset is extended by DroppedAsset
         super(topia, {
             apiKey: (_a = options === null || options === void 0 ? void 0 : options.credentials) === null || _a === void 0 ? void 0 : _a.apiKey,
@@ -39727,12 +39727,23 @@ class Asset extends SDKController {
             visitorId: (_e = options === null || options === void 0 ? void 0 : options.credentials) === null || _e === void 0 ? void 0 : _e.visitorId,
         });
         this.id = id;
+        this.urlSlug = (_f = options === null || options === void 0 ? void 0 : options.credentials) === null || _f === void 0 ? void 0 : _f.urlSlug;
         Object.assign(this, options.attributes);
     }
+    /**
+     * @summary
+     * Retrieves platform asset details.
+     *
+     * @usage
+     * ```ts
+     * await asset.fetchAssetById();
+     * const { assetName } = asset;
+     * ```
+     */
     fetchAssetById() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const response = yield this.topiaPublicApi().get(`/assets/${this.id}`, this.requestOptions);
+                const response = yield this.topiaPublicApi().get(`/assets/${this.urlSlug}/${this.id}`, this.requestOptions);
                 return response.data;
             }
             catch (error) {
@@ -39852,8 +39863,8 @@ class DroppedAsset extends Asset {
     setDataObject(dataObject, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/set-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/set-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = dataObject || this.dataObject;
             }
             catch (error) {
@@ -39878,8 +39889,8 @@ class DroppedAsset extends Asset {
     updateDataObject(dataObject, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/update-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/update-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = Object.assign(Object.assign({}, (this.dataObject || {})), (dataObject || {}));
             }
             catch (error) {
@@ -39904,8 +39915,8 @@ class DroppedAsset extends Asset {
     incrementDataObjectValue(path, amount, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/increment-data-object-value`, { path, amount, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/assets/${this.id}/increment-data-object-value`, { path, amount, analytics, lock }, this.requestOptions);
             }
             catch (error) {
                 throw this.errorHandler({
@@ -40313,6 +40324,16 @@ class Scene extends SDKController {
         this.id = id;
         Object.assign(this, options.attributes);
     }
+    /**
+     * @summary
+     * Retrieves scene details.
+     *
+     * @usage
+     * ```ts
+     * await scene.fetchSceneById();
+     * const { name } = scene;
+     * ```
+     */
     fetchSceneById() {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -40413,8 +40434,8 @@ class World extends SDKController {
          */
         this.setDataObject = (dataObject, options = {}) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/set-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/set-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = Object.assign(Object.assign({}, (this.dataObject || {})), (dataObject || {}));
             }
             catch (error) {
@@ -40437,8 +40458,8 @@ class World extends SDKController {
          */
         this.updateDataObject = (dataObject, options = {}) => __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/update-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/update-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = dataObject || this.dataObject;
             }
             catch (error) {
@@ -40830,8 +40851,8 @@ class World extends SDKController {
     incrementDataObjectValue(path, amount, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/increment-data-object-value`, { path, amount, lock }, this.requestOptions);
+                const { analytics, lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/increment-data-object-value`, { path, amount, analytics, lock }, this.requestOptions);
             }
             catch (error) {
                 throw this.errorHandler({
@@ -40955,6 +40976,12 @@ class User extends SDKController {
     /**
      * @summary
      * Returns all assets owned by User when an email address is provided.
+     *
+     * @usage
+     * ```ts
+     * await user.fetchAssets();
+     * const userAssets = user.assets;
+     * ```
      */
     fetchAssets() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40977,7 +41004,12 @@ class User extends SDKController {
     }
     /**
      * @summary
-     * Returns all platform assets
+     * Returns all platform assets.
+     *
+     * @usage
+     * ```ts
+     * const assets = await user.fetchPlatformAssets();
+     * ```
      */
     fetchPlatformAssets() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -40992,7 +41024,13 @@ class User extends SDKController {
     }
     /**
      * @summary
-     * Returns all scenes owned by User
+     * Returns all scenes owned by User.
+     *
+     * @usage
+     * ```ts
+     * await user.fetchScenes();
+     * const userScenes = user.scenes;
+     * ```
      */
     fetchScenes() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -41141,8 +41179,8 @@ class User extends SDKController {
             try {
                 if (!this.profileId)
                     throw "This method requires the use of a profileId";
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/set-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/set-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = dataObject || this.dataObject;
             }
             catch (error) {
@@ -41168,8 +41206,8 @@ class User extends SDKController {
             try {
                 if (!this.profileId)
                     throw "This method requires the use of a profileId";
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/update-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/update-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = Object.assign(Object.assign({}, (this.dataObject || {})), (dataObject || {}));
             }
             catch (error) {
@@ -41194,8 +41232,8 @@ class User extends SDKController {
     incrementDataObjectValue(path, amount, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/increment-data-object-value`, { path, amount, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/user/dataObjects/${this.profileId}/increment-data-object-value`, { path, amount, analytics, lock }, this.requestOptions);
             }
             catch (error) {
                 throw this.errorHandler({ error, params: { path, amount, options }, sdkMethod: "User.incrementDataObjectValue" });
@@ -41466,8 +41504,8 @@ class Visitor extends User {
     setDataObject(dataObject, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/set-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/set-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = Object.assign(Object.assign({}, (this.dataObject || {})), (dataObject || {}));
             }
             catch (error) {
@@ -41491,8 +41529,8 @@ class Visitor extends User {
     updateDataObject(dataObject, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/update-data-object`, { dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/update-data-object`, { analytics, dataObject: dataObject || this.dataObject, lock }, this.requestOptions);
                 this.dataObject = dataObject || this.dataObject;
             }
             catch (error) {
@@ -41517,8 +41555,8 @@ class Visitor extends User {
     incrementDataObjectValue(path, amount, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { lock = {} } = options;
-                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/increment-data-object-value`, { path, amount, lock }, this.requestOptions);
+                const { analytics = [], lock = {} } = options;
+                yield this.topiaPublicApi().put(`/world/${this.urlSlug}/visitors/${this.id}/increment-data-object-value`, { path, amount, analytics, lock }, this.requestOptions);
             }
             catch (error) {
                 throw this.errorHandler({
@@ -41713,23 +41751,62 @@ class Topia {
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const Asset = new AssetFactory(myTopiaInstance);
+ * ```
+ */
 class AssetFactory {
     constructor(topia) {
         this.topia = topia;
         this.create;
     }
+    /**
+     * @summary
+     * Instantiate a new instance of Asset class.
+     *
+     * @usage
+     * ```
+     * const assetInstance = await Asset.create(id, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(id, options) {
         return new Asset(this.topia, id, options);
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const DroppedAsset = new DroppedAssetFactory(myTopiaInstance);
+ * ```
+ */
 class DroppedAssetFactory extends SDKController {
     constructor(topia) {
         super(topia);
     }
+    /**
+     * @summary
+     * Instantiate a new instance of DroppedAsset class.
+     *
+     * @usage
+     * ```
+     * const droppedAssetInstance = await DroppedAsset.create(assetId, urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(id, urlSlug, options) {
         return new DroppedAsset(this.topia, id, urlSlug, options);
     }
+    /**
+     * @summary
+     * Instantiate a new instance of DroppedAsset class and retrieve all properties.
+     *
+     * @usage
+     * ```
+     * const droppedAssetInstance = await DroppedAsset.get(assetId, urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     get(id, urlSlug, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const droppedAsset = new DroppedAsset(this.topia, id, urlSlug, options);
@@ -41737,6 +41814,15 @@ class DroppedAssetFactory extends SDKController {
             return droppedAsset;
         });
     }
+    /**
+     * @summary
+     * Searches dropped assets within a world by a provide `uniqueName`. If a single match is found, a new instance of DroppedAsset class is returned all properties.
+     *
+     * @usage
+     * ```
+     * const droppedAssetInstance = await DroppedAsset.getWithUniqueName("exampleUniqueName", urlSlug, { interactivePublicKey, interactiveSecret });
+     * ```
+     */
     getWithUniqueName(uniqueName, urlSlug, credentials) {
         return __awaiter(this, void 0, void 0, function* () {
             const { apiKey, interactivePublicKey, interactiveSecret } = credentials;
@@ -41759,6 +41845,26 @@ class DroppedAssetFactory extends SDKController {
             }
         });
     }
+    /**
+     * @summary
+     * Drops an asset in a world and returns a new instance of DroppedAsset class with all properties.
+     *
+     * @usage
+     * ```
+     * const assetInstance = await Asset.create(id, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * const droppedAssetInstance = await DroppedAsset.get(assetInstance, {
+          assetScale: 1.5,
+          flipped: true,
+          layer0: "",
+          layer1: "https://pathtoimage.png",
+          interactivePublicKey,
+          isInteractive: true,
+          position: { x: 0, y: 0 },
+          uniqueName: "exampleUniqueName",
+          urlSlug,
+        });
+     * ```
+     */
     drop(asset, { assetScale = 1, flipped, interactivePublicKey, isInteractive, layer0 = "", layer1 = "", position: { x, y }, sceneDropId, text, textColor, textSize, textWeight, textWidth, uniqueName, urlSlug, yOrderAdjust, }) {
         return __awaiter(this, void 0, void 0, function* () {
             let specialType = null;
@@ -41803,14 +41909,38 @@ class DroppedAssetFactory extends SDKController {
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const Scene = new SceneFactory(myTopiaInstance);
+ * ```
+ */
 class SceneFactory {
     constructor(topia) {
         this.topia = topia;
         this.create;
     }
+    /**
+     * @summary
+     * Instantiate a new instance of Scene class.
+     *
+     * @usage
+     * ```
+     * const sceneInstance = await Scene.create(id, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(id, options) {
         return new Scene(this.topia, id, options);
     }
+    /**
+     * @summary
+     * Instantiate a new instance of Scene class and retrieve all properties.
+     *
+     * @usage
+     * ```
+     * const sceneInstance = await Scene.get(id, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     get(id, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const scene = yield new Scene(this.topia, id, options);
@@ -41820,22 +41950,61 @@ class SceneFactory {
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const User = new UserFactory(myTopiaInstance);
+ * ```
+ */
 class UserFactory {
     constructor(topia) {
         this.topia = topia;
     }
+    /**
+     * @summary
+     * Instantiate a new instance of User class.
+     *
+     * @usage
+     * ```
+     * const userInstance = await User.create({ credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(options) {
         return new User(this.topia, options);
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const Visitor = new VisitorFactory(myTopiaInstance);
+ * ```
+ */
 class VisitorFactory {
     constructor(topia) {
         this.topia = topia;
     }
+    /**
+     * @summary
+     * Instantiate a new instance of Visitor class.
+     *
+     * @usage
+     * ```
+     * const visitorInstance = await Visitor.create(id, urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(id, urlSlug, options) {
         return new Visitor(this.topia, id, urlSlug, options);
     }
+    /**
+     * @summary
+     * Instantiate a new instance of Visitor class and retrieve all properties.
+     *
+     * @usage
+     * ```
+     * const visitorInstance = await Visitor.get(id, urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     get(id, urlSlug, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const visitor = new Visitor(this.topia, id, urlSlug, options);
@@ -41845,22 +42014,61 @@ class VisitorFactory {
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const WorldActivity = new WorldActivityFactory(myTopiaInstance);
+ * ```
+ */
 class WorldActivityFactory {
     constructor(topia) {
         this.topia = topia;
     }
+    /**
+     * @summary
+     * Instantiate a new instance of WorldActivity class.
+     *
+     * @usage
+     * ```
+     * const worldActivityInstance = await WorldActivity.create(urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(urlSlug, options) {
         return new WorldActivity(this.topia, urlSlug, options);
     }
 }
 
+/**
+ * @usage
+ * ```ts
+ * const World = new WorldFactory(myTopiaInstance);
+ * ```
+ */
 class WorldFactory extends SDKController {
     constructor(topia) {
         super(topia);
     }
+    /**
+     * @summary
+     * Instantiate a new instance of World class.
+     *
+     * @usage
+     * ```
+     * const worldInstance = await World.create(urlSlug, { credentials: { interactiveNonce, interactivePublicKey, visitorId } });
+     * ```
+     */
     create(urlSlug, options) {
         return new World(this.topia, urlSlug, options);
     }
+    /**
+     * @summary
+     * Deletes an array of Dropped Assets from within a world and returns success: true
+     *
+     * @usage
+     * ```
+     * await World.deleteDroppedAssets(urlSlug, ["exampleDroppedAssetId1", "exampleDroppedAssetId2"], { interactiveNonce, interactivePublicKey, visitorId });
+     * ```
+     */
     deleteDroppedAssets(urlSlug, droppedAssetIds, credentials) {
         return __awaiter(this, void 0, void 0, function* () {
             const { apiKey, interactivePublicKey, interactiveSecret } = credentials;