@fastpix/fastpix-node 1.0.1 → 2.0.0

package/dist/commonjs/sdk/signingkeys.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SigningKeys = void 0;
+const signingKeysCreateSigningKey_js_1 = require("../funcs/signingKeysCreateSigningKey.js");
+const signingKeysDeleteSigningKey_js_1 = require("../funcs/signingKeysDeleteSigningKey.js");
+const signingKeysGetSigningKeyById_js_1 = require("../funcs/signingKeysGetSigningKeyById.js");
+const signingKeysListSigningKeys_js_1 = require("../funcs/signingKeysListSigningKeys.js");
+const sdks_js_1 = require("../lib/sdks.js");
+const fp_js_1 = require("../types/fp.js");
+class SigningKeys extends sdks_js_1.ClientSDK {
+    /**
+     * Create a signing key
+     *
+     * @remarks
+     * This endpoint allows you to create a new signing key pair for FastPix. When you call this endpoint, the API generates a 2048-bit RSA key pair. The privateKey will be returned in the response, encoded in Base64 format, and you will receive a unique key id to reference the key in future operations. FastPix will securely store the public key to validate signed tokens.
+     *
+     * <h4>Instructions</h4>
+     *
+     * **Private key handling:** The privateKey you receive is encoded in Base64. To use it, you'll need to decode it using Base64 decoding. Make sure to store this private key securely, as it is required for signing tokens.
+     *
+     * **Key-ID:** The id will be used to reference this specific key pair in future API requests or configurations.
+     *
+     * Once the key pair is generated, the private key must be securely stored by the developer, as FastPix will not save it. The public key will be used by FastPix to verify any signed tokens, ensuring that the client interacting with the system is legitimate.
+     *
+     * <h4>Use case scenario</h4>
+     *
+     * **Use case:** A developer building a video subscription service wants to ensure that only authorized users can access premium content. By generating a signing key, the developer can issue signed JSON Web Tokens (JWTs) to authenticate and authorize users. These tokens can be validated by FastPix using the stored public key.
+     *
+     * **Detailed example:**  Imagine a scenario where you're building a video-on-demand platform that restricts access based on user subscriptions. To ensure only subscribed users can stream content, you generate a signing key using this API. Each time a user logs in, you create a JWT signed with the private key. When the user attempts to play a video, FastPix uses the public key to verify the token and confirms that the user is authorized.
+     */
+    async createSigningKey(options) {
+        return (0, fp_js_1.unwrapAsync)((0, signingKeysCreateSigningKey_js_1.signingKeysCreateSigningKey)(this, options));
+    }
+    /**
+     * Get list of signing key
+     *
+     * @remarks
+     * This endpoint returns a list of all the signing keys associated with an organization in FastPix. Each key entry in the response includes metadata such as the key id, creation date, and workspace details. This helps you manage multiple keys, track their usage, and identify which keys are valid for signing API requests.
+     *
+     * <h4>How it works</h4>
+     *
+     * The API returns the list in a paginated format, allowing you to audit and track all keys used for your application. Regularly reviewing this list is essential for ensuring that old or compromised keys are promptly revoked and that new keys are properly integrated into workflows.
+     *
+     * <h4>Use case scenario</h4>
+     *
+     * **Use case:** A security-conscious development team wants to ensure they follow a key rotation policy, rotating signing keys every few months. By retrieving the list of signing keys, they can identify which keys are still in use and which ones need to be rotated.
+     *
+     * **Detailed example:**  You're managing a multi-region video platform where different teams in different regions have created their own signing keys. To ensure compliance with your organization's security policies, you regularly review the list of signing keys to verify which ones are still active. You find a few keys that haven’t been used in months, and based on the creation date, you decide to rotate them.
+     */
+    async listSigningKeys(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, signingKeysListSigningKeys_js_1.signingKeysListSigningKeys)(this, request, options));
+    }
+    /**
+     * Delete a signing key
+     *
+     * @remarks
+     * This endpoint allows you to delete an existing signing key, and the action is permanent. Once a key is deleted, any signatures or tokens generated using that key will immediately become invalid. This means you can no longer use the key to sign JSON Web Tokens (JWTs) or authenticate API requests.
+     * <h4>Usage</h4>
+     * To delete a signing key, you will need to provide the unique key id that was obtained when creating the signing key. This key id serves as the identifier for the specific signing key you want to remove from your account.
+     *
+     * <h4>How it works</h4>
+     *
+     * By specifying the key id, the API removes the signing key from the system. After the key is deleted, any API requests or tokens that rely on it will fail. This action is useful when a key is compromised or when rotating keys as part of security policies.
+     *
+     * <h4>Use case scenario</h4>
+     *
+     * **Use case:** A key used by an outdated application version has been compromised, or a developer accidentally leaked it. To prevent unauthorized access, the developer deletes the signing key, revoking its ability to sign requests immediately.
+     *
+     * **Detailed example:**  Let’s say you have a signing key used for a specific version of your mobile app, and you discover that this key has been compromised due to a security breach. To mitigate the issue, you delete the key to invalidate any tokens generated using it. As soon as the key is deleted, users on the compromised version of the app can no longer make valid requests, thus preventing further exploitation.
+     */
+    async deleteSigningKey(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, signingKeysDeleteSigningKey_js_1.signingKeysDeleteSigningKey)(this, request, options));
+    }
+    /**
+     * Get signing key by ID
+     *
+     * @remarks
+     * This endpoint allows you to retrieve detailed information about a specific signing key using its unique key id. While the private key is not returned for security reasons, you'll be able to see the key's creation date, status, and other associated metadata. This endpoint also returns the workspaceId and publicKey in the response.
+     *
+     * <h4>Usage: Generating a JWT token</h4>
+     *
+     * In the response, you will receive the workspaceId and publicKey associated with the signing key. With the publicKey and the privateKey obtained from the "Create a Signing Key" endpoint, you can generate a JSON Web Token (JWT) using the RS256 algorithm. This token can be utilized for accessing private media assets, GIFs, thumbnails, and spritesheets.
+     *
+     * <h4>Payload:</h4>
+     *
+     * ```
+     * {
+     *   "kid": "359302ee-2446-4afe-9348-8b4656b9ddb1",
+     *   "aud": "media:6cee6f85-9334-4a51-9ce3-e0241d94ceef",
+     *   "iss": "fastpix.io",
+     *   "sub": "",
+     *   "iat": 1706703204,
+     *   "exp": 1735626783
+     *
+     * }
+     * ```
+     *
+     * * **kid:** The key ID of the signing key.
+     * * **aud:** The audience for which the token is intended.
+     * * **iss:** The issuer of the token (e.g., "fastpix.io").
+     * * **sub:** The subject of the token, typically representing the user or entity the token is issued for. In this case, use the workspaceId fetched from the "Get Signing Key by ID" endpoint.
+     * * **groups:** An array of groups the subject belongs to (e.g., ["user"]).
+     * * **iat:** The issued-at timestamp, indicating when the token was created.
+     * * **exp:** The expiration timestamp, indicating when the token will no longer be valid.
+     *
+     * <h4>Use case scenario</h4>
+     *
+     * **Use case:** A developer is unsure about the status of a signing key they created months ago and wants to verify whether it's still in use or has expired.
+     *
+     * **Detailed example:**  You’re working on a streaming platform and realize you haven’t checked the status of a signing key that was used for playback access several months ago. By fetching the key details using its ID, you can confirm whether it’s still active, when it was created, and if it’s nearing expiration. This allows you to plan a rotation or deactivation if needed.
+     */
+    async getSigningKeyById(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, signingKeysGetSigningKeyById_js_1.signingKeysGetSigningKeyById)(this, request, options));
+    }
+}
+exports.SigningKeys = SigningKeys;
+//# sourceMappingURL=signingkeys.js.map

package/dist/commonjs/sdk/signingkeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signingkeys.js","sourceRoot":"","sources":["../../../src/sdk/signingkeys.ts"],"names":[],"mappings":";;;AAAA,4FAAsF;AACtF,4FAAsF;AACtF,8FAAwF;AACxF,0FAAoF;AACpF,4CAA2D;AAG3D,0CAA6C;AAE7C,MAAa,WAAY,SAAQ,mBAAS;IACxC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,gBAAgB,CACpB,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,4DAA2B,EAC5C,IAAI,EACJ,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,eAAe,CACnB,OAAuD,EACvD,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,0DAA0B,EAC3C,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,gBAAgB,CACpB,OAA2C,EAC3C,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,4DAA2B,EAC5C,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,KAAK,CAAC,iBAAiB,CACrB,OAA4C,EAC5C,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,8DAA4B,EAC7C,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;CACF;AAtID,kCAsIC"}

package/dist/commonjs/sdk/simulcaststream.d.ts

@@ -0,0 +1,57 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+export declare class SimulcastStream extends ClientSDK {
+    /**
+     * Create a simulcast
+     *
+     * @remarks
+     * Lets you to create a simulcast for a parent live stream. Simulcasting enables you to broadcast the live stream to multiple social platforms simultaneously (e.g., YouTube, Facebook, or Twitch). This feature is useful for expanding your audience reach across different platforms. However, a simulcast can only be created when the parent live stream is in idle state (i.e., not currently live or disabled). Additionally, only one simulcast target can be created per API call.
+     * #### How it works
+     *
+     * 1. Upon calling this endpoint, you need to provide the parent `streamId` and the details of the simulcast target (platform and credentials). The system will generate a unique `simulcastId`, which can be used to manage the simulcast later.
+     *
+     * 2. To notify your application about the status of simulcast related events check for the <a href="https://docs.fastpix.io/docs/webhooks-collection#simulcast-target-events">webhooks for simulcast</a> target events.
+     *
+     * #### Example
+     * An event manager sets up a live stream for a virtual conference and wants to simulcast the stream on YouTube and Facebook Live. They first create the primary live stream in FastPix, ensuring it's in the idle state. Then, they use the API to create a simulcast target for YouTube.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/docs/simulcast-to-3rd-party-platforms">Simulcast to 3rd party platforms</a>
+     */
+    createSimulcastOfStream(request: operations.CreateSimulcastOfStreamRequest, options?: RequestOptions): Promise<models.SimulcastResponse>;
+    /**
+     * Delete a simulcast
+     *
+     * @remarks
+     * Allows you to delete a simulcast using its unique `simulcastId`, which was returned during the simulcast creation process. Deleting a simulcast stops the broadcast to the associated platform, but the parent stream will continue to run if it is live. This action is irreversible, and a new simulcast would need to be created if you want to resume streaming to the same platform.
+     *
+     * Webhook event: <a href="https://docs.fastpix.io/docs/live-events#videolive_streamsimulcast_targetdeleted">video.live_stream.simulcast_target.deleted</a>
+     *
+     * #### Example
+     * A broadcaster needs to stop simulcasting to one platform due to technical difficulties while keeping the stream active on others. For instance, a tech company is simulcasting a product launch on multiple platforms. Midway through the event, they decide to stop the simulcast on Facebook due to performance issues, but keep it running on YouTube. They call this API to delete the Facebook simulcast target.
+     */
+    deleteSimulcastOfStream(request: operations.DeleteSimulcastOfStreamRequest, options?: RequestOptions): Promise<models.SimulcastdeleteResponse>;
+    /**
+     * Get a specific simulcast
+     *
+     * @remarks
+     * Retrieves the details of a specific simulcast associated with a parent live stream. By providing both the `streamId` of the parent stream and the `simulcastId`, FastPix returns detailed information about the simulcast, such as the stream URL, the status of the simulcast, and metadata.
+     *
+     * #### Example
+     * This endpoint can be used to verify the status of the simulcast on external platforms before the live stream begins. For instance, before starting a live gaming event, the organizer wants to ensure that the simulcast to Twitch is set up correctly. They retrieve the simulcast information to confirm that everything is properly configured.
+     */
+    getSpecificSimulcastOfStream(request: operations.GetSpecificSimulcastOfStreamRequest, options?: RequestOptions): Promise<models.SimulcastResponse>;
+    /**
+     * Update a simulcast
+     *
+     * @remarks
+     * Allows you to enable or disable a specific simulcast associated with a parent live stream. The status of the simulcast can be updated at any point, whether the live stream is active or idle. However, once the live stream is disabled, the simulcast can no longer be modified.
+     *
+     * Webhook event: <a href="https://docs.fastpix.io/docs/live-events#videolive_streamsimulcast_targetupdated">video.live_stream.simulcast_target.updated</a>
+     *
+     * #### Example
+     * When a `PATCH` request is made to this endpoint, the API updates the status of the simulcast. This can be useful for pausing or resuming a simulcast on a particular platform without stopping the parent live stream.
+     */
+    updateSpecificSimulcastOfStream(request: operations.UpdateSpecificSimulcastOfStreamRequest, options?: RequestOptions): Promise<models.SimulcastUpdateResponse>;
+}
+//# sourceMappingURL=simulcaststream.d.ts.map

package/dist/commonjs/sdk/simulcaststream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulcaststream.d.ts","sourceRoot":"","sources":["../../../src/sdk/simulcaststream.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAC7C,OAAO,KAAK,UAAU,MAAM,+BAA+B,CAAC;AAG5D,qBAAa,eAAgB,SAAQ,SAAS;IAC5C;;;;;;;;;;;;;;;OAeG;IACG,uBAAuB,CAC3B,OAAO,EAAE,UAAU,CAAC,8BAA8B,EAClD,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAQpC;;;;;;;;;;OAUG;IACG,uBAAuB,CAC3B,OAAO,EAAE,UAAU,CAAC,8BAA8B,EAClD,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAC;IAQ1C;;;;;;;;OAQG;IACG,4BAA4B,CAChC,OAAO,EAAE,UAAU,CAAC,mCAAmC,EACvD,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,iBAAiB,CAAC;IAQpC;;;;;;;;;;OAUG;IACG,+BAA+B,CACnC,OAAO,EAAE,UAAU,CAAC,sCAAsC,EAC1D,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAC;CAO3C"}

package/dist/commonjs/sdk/simulcaststream.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimulcastStream = void 0;
+const simulcastStreamCreateSimulcastOfStream_js_1 = require("../funcs/simulcastStreamCreateSimulcastOfStream.js");
+const simulcastStreamDeleteSimulcastOfStream_js_1 = require("../funcs/simulcastStreamDeleteSimulcastOfStream.js");
+const simulcastStreamGetSpecificSimulcastOfStream_js_1 = require("../funcs/simulcastStreamGetSpecificSimulcastOfStream.js");
+const simulcastStreamUpdateSpecificSimulcastOfStream_js_1 = require("../funcs/simulcastStreamUpdateSpecificSimulcastOfStream.js");
+const sdks_js_1 = require("../lib/sdks.js");
+const fp_js_1 = require("../types/fp.js");
+class SimulcastStream extends sdks_js_1.ClientSDK {
+    /**
+     * Create a simulcast
+     *
+     * @remarks
+     * Lets you to create a simulcast for a parent live stream. Simulcasting enables you to broadcast the live stream to multiple social platforms simultaneously (e.g., YouTube, Facebook, or Twitch). This feature is useful for expanding your audience reach across different platforms. However, a simulcast can only be created when the parent live stream is in idle state (i.e., not currently live or disabled). Additionally, only one simulcast target can be created per API call.
+     * #### How it works
+     *
+     * 1. Upon calling this endpoint, you need to provide the parent `streamId` and the details of the simulcast target (platform and credentials). The system will generate a unique `simulcastId`, which can be used to manage the simulcast later.
+     *
+     * 2. To notify your application about the status of simulcast related events check for the <a href="https://docs.fastpix.io/docs/webhooks-collection#simulcast-target-events">webhooks for simulcast</a> target events.
+     *
+     * #### Example
+     * An event manager sets up a live stream for a virtual conference and wants to simulcast the stream on YouTube and Facebook Live. They first create the primary live stream in FastPix, ensuring it's in the idle state. Then, they use the API to create a simulcast target for YouTube.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/docs/simulcast-to-3rd-party-platforms">Simulcast to 3rd party platforms</a>
+     */
+    async createSimulcastOfStream(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, simulcastStreamCreateSimulcastOfStream_js_1.simulcastStreamCreateSimulcastOfStream)(this, request, options));
+    }
+    /**
+     * Delete a simulcast
+     *
+     * @remarks
+     * Allows you to delete a simulcast using its unique `simulcastId`, which was returned during the simulcast creation process. Deleting a simulcast stops the broadcast to the associated platform, but the parent stream will continue to run if it is live. This action is irreversible, and a new simulcast would need to be created if you want to resume streaming to the same platform.
+     *
+     * Webhook event: <a href="https://docs.fastpix.io/docs/live-events#videolive_streamsimulcast_targetdeleted">video.live_stream.simulcast_target.deleted</a>
+     *
+     * #### Example
+     * A broadcaster needs to stop simulcasting to one platform due to technical difficulties while keeping the stream active on others. For instance, a tech company is simulcasting a product launch on multiple platforms. Midway through the event, they decide to stop the simulcast on Facebook due to performance issues, but keep it running on YouTube. They call this API to delete the Facebook simulcast target.
+     */
+    async deleteSimulcastOfStream(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, simulcastStreamDeleteSimulcastOfStream_js_1.simulcastStreamDeleteSimulcastOfStream)(this, request, options));
+    }
+    /**
+     * Get a specific simulcast
+     *
+     * @remarks
+     * Retrieves the details of a specific simulcast associated with a parent live stream. By providing both the `streamId` of the parent stream and the `simulcastId`, FastPix returns detailed information about the simulcast, such as the stream URL, the status of the simulcast, and metadata.
+     *
+     * #### Example
+     * This endpoint can be used to verify the status of the simulcast on external platforms before the live stream begins. For instance, before starting a live gaming event, the organizer wants to ensure that the simulcast to Twitch is set up correctly. They retrieve the simulcast information to confirm that everything is properly configured.
+     */
+    async getSpecificSimulcastOfStream(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, simulcastStreamGetSpecificSimulcastOfStream_js_1.simulcastStreamGetSpecificSimulcastOfStream)(this, request, options));
+    }
+    /**
+     * Update a simulcast
+     *
+     * @remarks
+     * Allows you to enable or disable a specific simulcast associated with a parent live stream. The status of the simulcast can be updated at any point, whether the live stream is active or idle. However, once the live stream is disabled, the simulcast can no longer be modified.
+     *
+     * Webhook event: <a href="https://docs.fastpix.io/docs/live-events#videolive_streamsimulcast_targetupdated">video.live_stream.simulcast_target.updated</a>
+     *
+     * #### Example
+     * When a `PATCH` request is made to this endpoint, the API updates the status of the simulcast. This can be useful for pausing or resuming a simulcast on a particular platform without stopping the parent live stream.
+     */
+    async updateSpecificSimulcastOfStream(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, simulcastStreamUpdateSpecificSimulcastOfStream_js_1.simulcastStreamUpdateSpecificSimulcastOfStream)(this, request, options));
+    }
+}
+exports.SimulcastStream = SimulcastStream;
+//# sourceMappingURL=simulcaststream.js.map

package/dist/commonjs/sdk/simulcaststream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulcaststream.js","sourceRoot":"","sources":["../../../src/sdk/simulcaststream.ts"],"names":[],"mappings":";;;AAAA,kHAA4G;AAC5G,kHAA4G;AAC5G,4HAAsH;AACtH,kIAA4H;AAC5H,4CAA2D;AAG3D,0CAA6C;AAE7C,MAAa,eAAgB,SAAQ,mBAAS;IAC5C;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,uBAAuB,CAC3B,OAAkD,EAClD,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,kFAAsC,EACvD,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,uBAAuB,CAC3B,OAAkD,EAClD,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,kFAAsC,EACvD,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,KAAK,CAAC,4BAA4B,CAChC,OAAuD,EACvD,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,4FAA2C,EAC5D,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,+BAA+B,CACnC,OAA0D,EAC1D,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,kGAA8C,EAC/D,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;CACF;AA3FD,0CA2FC"}

package/dist/commonjs/sdk/startlivestream.d.ts

@@ -0,0 +1,27 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+export declare class StartLiveStream extends ClientSDK {
+    /**
+     * Create a new stream
+     *
+     * @remarks
+     * Allows you to initiate a new <a href="https://docs.fastpix.io/docs/get-started-with-live-streaming">RTMPS</a> or <a href="https://docs.fastpix.io/docs/using-srt-to-live-stream">SRT</a> live stream on FastPix. Upon creating a stream, FastPix generates a unique `streamKey` and `srtSecret`, which can be used with any broadcasting software (like OBS) to connect to FastPix's RTMPS or SRT servers.
+     * Leverage SRT for live streaming in environments with unstable networks, taking advantage of its error correction and encryption features for a resilient and secure broadcast.
+     *
+     * <h4>How it works</h4>
+     *
+     * 1. Send a a `POST` request to this endpoint. You can configure the stream settings, including `metadata` (such as stream name and description), `reconnectWindow` (in case of disconnection), and privacy options (`public` or `private`).
+     *
+     * 2. FastPix returns the stream details for both RTMPS and SRT configurations. These keys and IDs from the stream details are essential for connecting the broadcasting software to FastPix’s servers and transmitting the live stream to viewers.
+     *
+     * 3. Once the live stream is created, we’ll shoot a `POST` message to the address you give us with the webhook event <a href="https://docs.fastpix.io/docs/live-events#videolive_streamcreated">video.live_stream.created</a>.
+     *
+     * **Example:**
+     *
+     *   Imagine a gaming platform that allows users to live stream gameplay directly from their dashboard. The API creates a new stream, provides the necessary stream key, and sets it to "private" so that only specific viewers can access it.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/docs/how-to-livestream">How to live stream</a>
+     */
+    createNewStream(request: models.CreateLiveStreamRequest, options?: RequestOptions): Promise<models.LiveStreamResponseDTO>;
+}
+//# sourceMappingURL=startlivestream.d.ts.map

package/dist/commonjs/sdk/startlivestream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startlivestream.d.ts","sourceRoot":"","sources":["../../../src/sdk/startlivestream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAC;AAG7C,qBAAa,eAAgB,SAAQ,SAAS;IAC5C;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,eAAe,CACnB,OAAO,EAAE,MAAM,CAAC,uBAAuB,EACvC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC;CAOzC"}

package/dist/commonjs/sdk/startlivestream.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StartLiveStream = void 0;
+const startLiveStreamCreateNewStream_js_1 = require("../funcs/startLiveStreamCreateNewStream.js");
+const sdks_js_1 = require("../lib/sdks.js");
+const fp_js_1 = require("../types/fp.js");
+class StartLiveStream extends sdks_js_1.ClientSDK {
+    /**
+     * Create a new stream
+     *
+     * @remarks
+     * Allows you to initiate a new <a href="https://docs.fastpix.io/docs/get-started-with-live-streaming">RTMPS</a> or <a href="https://docs.fastpix.io/docs/using-srt-to-live-stream">SRT</a> live stream on FastPix. Upon creating a stream, FastPix generates a unique `streamKey` and `srtSecret`, which can be used with any broadcasting software (like OBS) to connect to FastPix's RTMPS or SRT servers.
+     * Leverage SRT for live streaming in environments with unstable networks, taking advantage of its error correction and encryption features for a resilient and secure broadcast.
+     *
+     * <h4>How it works</h4>
+     *
+     * 1. Send a a `POST` request to this endpoint. You can configure the stream settings, including `metadata` (such as stream name and description), `reconnectWindow` (in case of disconnection), and privacy options (`public` or `private`).
+     *
+     * 2. FastPix returns the stream details for both RTMPS and SRT configurations. These keys and IDs from the stream details are essential for connecting the broadcasting software to FastPix’s servers and transmitting the live stream to viewers.
+     *
+     * 3. Once the live stream is created, we’ll shoot a `POST` message to the address you give us with the webhook event <a href="https://docs.fastpix.io/docs/live-events#videolive_streamcreated">video.live_stream.created</a>.
+     *
+     * **Example:**
+     *
+     *   Imagine a gaming platform that allows users to live stream gameplay directly from their dashboard. The API creates a new stream, provides the necessary stream key, and sets it to "private" so that only specific viewers can access it.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/docs/how-to-livestream">How to live stream</a>
+     */
+    async createNewStream(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, startLiveStreamCreateNewStream_js_1.startLiveStreamCreateNewStream)(this, request, options));
+    }
+}
+exports.StartLiveStream = StartLiveStream;
+//# sourceMappingURL=startlivestream.js.map

package/dist/commonjs/sdk/startlivestream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startlivestream.js","sourceRoot":"","sources":["../../../src/sdk/startlivestream.ts"],"names":[],"mappings":";;;AAAA,kGAA4F;AAC5F,4CAA2D;AAE3D,0CAA6C;AAE7C,MAAa,eAAgB,SAAQ,mBAAS;IAC5C;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,KAAK,CAAC,eAAe,CACnB,OAAuC,EACvC,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,kEAA8B,EAC/C,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;CACF;AAhCD,0CAgCC"}

package/dist/commonjs/sdk/views.d.ts

@@ -0,0 +1,120 @@
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+export declare class Views extends ClientSDK {
+    /**
+     * List video views
+     *
+     * @remarks
+     * Retrieves a list of video views that fall within the specified filters and have been completed within a defined timespan. It allows you to analyse viewer interactions with your video content effectively.
+     *
+     * #### How it works
+     *
+     *   1. Make a `GET` request to this endpoint with the desired query parameters.
+     *
+     *   2. Specify the timespan for which you want to retrieve the video views using the `timespan[]` parameter.
+     *
+     *   3. Filter the views based on dimensions such as browser, device, video title, viewer ID, etc., using the `filterby[]` parameter. Get the dimensions by calling <a href="https://docs.fastpix.io/reference/list_dimensions">list the dimensions</a> endpoint.
+     *
+     *   4. Paginate the results using the `limit` and `offset` parameters.
+     *
+     *   5. Optionally, filter by `viewerId`, `errorCode`, `orderBy` a specific field, and sort in ascending or descending order.
+     *
+     *   6. Receive a response containing the list of video views matching the specified criteria.
+     *
+     * Each view in the response will include a unique `viewId`. You can use this `viewId` to call the <a href="https://docs.fastpix.io/reference/get_video_view_details">get details of video view</a> endpoint to retrieve more detailed information about that specific view.
+     *
+     * #### Example
+     *
+     * Suppose you're managing a video streaming service and need to analyze how the content performs across different devices and browsers. By calling the List Video Views endpoint with filters like `browser_name` and `device_type`, you can get insights into which platforms are most popular with the audience. This data will help you optimize content for the most-used platforms and troubleshoot any playback issues on less common devices.
+     *
+     *   Related guide: <a href="https://docs.fastpix.io/docs/audience-metrics">Audience metrics</a>, <a href="https://docs.fastpix.io/docs/understand-dashboard-ui#1-views-dashboard">Views dashboard</a>
+     */
+    listVideoViews(request: operations.ListVideoViewsRequest, options?: RequestOptions): Promise<operations.ListVideoViewsResponse>;
+    /**
+     * Get details of video view
+     *
+     * @remarks
+     * Allows you to retrieve detailed information about a specific video view using its unique `viewId`. This is useful for getting insights into individual viewer interactions with your video content. This detailed information is valuable for enhancing user experience and improving engagement with your video assets.
+     *
+     * Make a `GET` request to this endpoint and you will receive a response containing detailed information about the specified video view, including metrics and attributes related to that view.
+     *
+     * #### Example
+     *
+     * Suppose a developer receives a report of a poor viewing experience for a specific user. By using this endpoint with the user's `viewId`, the developer can retrieve metrics like buffering duration, playback errors, and session length. This data allows the developer to pinpoint issues (such as poor connectivity or a browser-specific problem) and take steps to improve the user experience.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/page/what-video-data-do-we-capture#/">What Video Data do we capture?</a>
+     */
+    getVideoViewDetails(request: operations.GetVideoViewDetailsRequest, options?: RequestOptions): Promise<operations.GetVideoViewDetailsResponse>;
+    /**
+     * List by top content
+     *
+     * @remarks
+     * Retrieves a list of the top video views that fall within the specified filters and have been completed within a defined timespan. It allows you to identify the most popular content based on viewer interactions.
+     *
+     * #### How it works
+     *
+     *   1. Make a `GET` request to this endpoint with the desired query parameters.
+     *
+     *   2. Specify the timespan for which you want to retrieve the top content using the `timespan[]` parameter.
+     *
+     *   3. Filter the views based on dimensions such as browser, device, video title, etc., using the `filterby[]` parameter.
+     *
+     *   4. `Limit` the results to control the number of top views returned.
+     *
+     *   5. Receive a response containing the list of top video views matching the specified criteria.
+     *
+     *   Related guide: <a href="https://docs.fastpix.io/page/how-to-get-top-performing-content">Get top-performing content</a>
+     */
+    listByTopContent(request: operations.ListByTopContentRequest, options?: RequestOptions): Promise<operations.ListByTopContentResponse>;
+    /**
+     * Get concurrent viewers timeseries
+     *
+     * @remarks
+     * Retrieves a time series of the number of concurrent viewers, providing a real-time snapshot of audience activity over the last 30 minutes. This endpoint is essential for monitoring live events, gauging audience reaction to new content releases, or understanding immediate engagement trends.
+     *
+     * #### How it works
+     *
+     *   1. Make a simple `GET` request to this endpoint. No query parameters are needed.
+     *
+     *   2. The API automatically gathers data for the **last 30 minutes**, calculating the number of concurrent viewers at regular intervals within that window.
+     *
+     *   3. Receive a response containing a `data` array, where each object represents a specific point in time.
+     *
+     *   4. Each object in the array includes the `intervalTime` (the timestamp of the measurement) and `numberOfViews` (the count of concurrent viewers at that instant), allowing you to easily plot viewer activity over time.
+     *
+     * #### Example
+     *
+     * Imagine you are streaming a major live event, such as a product launch, a sports game, or a webinar. You need to monitor audience engagement in real-time to see if viewership is increasing, decreasing, or holding steady.
+     *
+     * By calling this endpoint periodically (e.g., every minute), you can plot a live graph of your viewership. This allows you to identify peak moments of interest, see the immediate impact of social media promotions, or detect potential technical issues if there's a sudden, unexpected drop in viewers
+     */
+    getDataViewlistCurrentViewsGetTimeseriesViews(options?: RequestOptions): Promise<operations.GetDataViewlistCurrentViewsGetTimeseriesViewsResponse>;
+    /**
+     * Get concurrent viewers breakdown by dimension
+     *
+     * @remarks
+     * Retrieves a real-time breakdown of present concurrent viewers, grouped by a chosen dimension. This endpoint allows you to see how your audience is distributed across different categories like geography, content, or technology, based on activity in the last 30 minutes.
+     *
+     * For example, you can see how many viewers are currently watching from the US vs. India, or which video titles are most popular right now.
+     *
+     * #### How it works
+     *
+     * 1. Make a `GET` request to this endpoint.
+     *
+     * 2. Specify the `dimension` you want to group by in the query parameters (e.g., `dimension=country` or `dimension=video_title`). This is the most important parameter as it defines how the data is categorized.
+     *
+     * 3. Optionally, use the `limit` parameter to control the number of results returned (e.g., `limit=5` to get the top 5 countries).
+     *
+     * 4. The API analyzes viewer data from the last 30 minutes and aggregates the viewer counts for each unique value within the chosen dimension.
+     *
+     * 5. Receive a response containing a `data` array, where each object represents a specific group (e.g., a country or a video title) and its corresponding number of `concurrent_viewers`.
+     *
+     * #### Example
+     *
+     * Imagine you are running a global streaming platform and have just launched a new original series. You want to see, in real-time, which regions are engaging most with the new content versus your older library content.
+     *
+     * By calling this endpoint with `dimension=video_title`, you can immediately see a list of your most-watched videos right now and their respective viewer counts. Then, by calling it again with `dimension=country`, you can get a live breakdown of your audience's geographic distribution. This helps you confirm if your marketing efforts in specific countries are paying off instantly and allows you to make data-driven decisions during live events.
+     */
+    getDataViewlistCurrentViewsFilter(request?: operations.GetDataViewlistCurrentViewsFilterRequest | undefined, options?: RequestOptions): Promise<operations.GetDataViewlistCurrentViewsFilterResponse>;
+}
+//# sourceMappingURL=views.d.ts.map

package/dist/commonjs/sdk/views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.d.ts","sourceRoot":"","sources":["../../../src/sdk/views.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,UAAU,MAAM,+BAA+B,CAAC;AAG5D,qBAAa,KAAM,SAAQ,SAAS;IAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,cAAc,CAClB,OAAO,EAAE,UAAU,CAAC,qBAAqB,EACzC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,UAAU,CAAC,sBAAsB,CAAC;IAQ7C;;;;;;;;;;;;;OAaG;IACG,mBAAmB,CACvB,OAAO,EAAE,UAAU,CAAC,0BAA0B,EAC9C,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,UAAU,CAAC,2BAA2B,CAAC;IAQlD;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CACpB,OAAO,EAAE,UAAU,CAAC,uBAAuB,EAC3C,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,UAAU,CAAC,wBAAwB,CAAC;IAQ/C;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,6CAA6C,CACjD,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,UAAU,CAAC,qDAAqD,CAAC;IAO5E;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,iCAAiC,CACrC,OAAO,CAAC,EAAE,UAAU,CAAC,wCAAwC,GAAG,SAAS,EACzE,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,UAAU,CAAC,yCAAyC,CAAC;CAOjE"}

package/dist/commonjs/sdk/views.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Views = void 0;
+const viewsGetDataViewlistCurrentViewsFilter_js_1 = require("../funcs/viewsGetDataViewlistCurrentViewsFilter.js");
+const viewsGetDataViewlistCurrentViewsGetTimeseriesViews_js_1 = require("../funcs/viewsGetDataViewlistCurrentViewsGetTimeseriesViews.js");
+const viewsGetVideoViewDetails_js_1 = require("../funcs/viewsGetVideoViewDetails.js");
+const viewsListByTopContent_js_1 = require("../funcs/viewsListByTopContent.js");
+const viewsListVideoViews_js_1 = require("../funcs/viewsListVideoViews.js");
+const sdks_js_1 = require("../lib/sdks.js");
+const fp_js_1 = require("../types/fp.js");
+class Views extends sdks_js_1.ClientSDK {
+    /**
+     * List video views
+     *
+     * @remarks
+     * Retrieves a list of video views that fall within the specified filters and have been completed within a defined timespan. It allows you to analyse viewer interactions with your video content effectively.
+     *
+     * #### How it works
+     *
+     *   1. Make a `GET` request to this endpoint with the desired query parameters.
+     *
+     *   2. Specify the timespan for which you want to retrieve the video views using the `timespan[]` parameter.
+     *
+     *   3. Filter the views based on dimensions such as browser, device, video title, viewer ID, etc., using the `filterby[]` parameter. Get the dimensions by calling <a href="https://docs.fastpix.io/reference/list_dimensions">list the dimensions</a> endpoint.
+     *
+     *   4. Paginate the results using the `limit` and `offset` parameters.
+     *
+     *   5. Optionally, filter by `viewerId`, `errorCode`, `orderBy` a specific field, and sort in ascending or descending order.
+     *
+     *   6. Receive a response containing the list of video views matching the specified criteria.
+     *
+     * Each view in the response will include a unique `viewId`. You can use this `viewId` to call the <a href="https://docs.fastpix.io/reference/get_video_view_details">get details of video view</a> endpoint to retrieve more detailed information about that specific view.
+     *
+     * #### Example
+     *
+     * Suppose you're managing a video streaming service and need to analyze how the content performs across different devices and browsers. By calling the List Video Views endpoint with filters like `browser_name` and `device_type`, you can get insights into which platforms are most popular with the audience. This data will help you optimize content for the most-used platforms and troubleshoot any playback issues on less common devices.
+     *
+     *   Related guide: <a href="https://docs.fastpix.io/docs/audience-metrics">Audience metrics</a>, <a href="https://docs.fastpix.io/docs/understand-dashboard-ui#1-views-dashboard">Views dashboard</a>
+     */
+    async listVideoViews(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, viewsListVideoViews_js_1.viewsListVideoViews)(this, request, options));
+    }
+    /**
+     * Get details of video view
+     *
+     * @remarks
+     * Allows you to retrieve detailed information about a specific video view using its unique `viewId`. This is useful for getting insights into individual viewer interactions with your video content. This detailed information is valuable for enhancing user experience and improving engagement with your video assets.
+     *
+     * Make a `GET` request to this endpoint and you will receive a response containing detailed information about the specified video view, including metrics and attributes related to that view.
+     *
+     * #### Example
+     *
+     * Suppose a developer receives a report of a poor viewing experience for a specific user. By using this endpoint with the user's `viewId`, the developer can retrieve metrics like buffering duration, playback errors, and session length. This data allows the developer to pinpoint issues (such as poor connectivity or a browser-specific problem) and take steps to improve the user experience.
+     *
+     * Related guide: <a href="https://docs.fastpix.io/page/what-video-data-do-we-capture#/">What Video Data do we capture?</a>
+     */
+    async getVideoViewDetails(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, viewsGetVideoViewDetails_js_1.viewsGetVideoViewDetails)(this, request, options));
+    }
+    /**
+     * List by top content
+     *
+     * @remarks
+     * Retrieves a list of the top video views that fall within the specified filters and have been completed within a defined timespan. It allows you to identify the most popular content based on viewer interactions.
+     *
+     * #### How it works
+     *
+     *   1. Make a `GET` request to this endpoint with the desired query parameters.
+     *
+     *   2. Specify the timespan for which you want to retrieve the top content using the `timespan[]` parameter.
+     *
+     *   3. Filter the views based on dimensions such as browser, device, video title, etc., using the `filterby[]` parameter.
+     *
+     *   4. `Limit` the results to control the number of top views returned.
+     *
+     *   5. Receive a response containing the list of top video views matching the specified criteria.
+     *
+     *   Related guide: <a href="https://docs.fastpix.io/page/how-to-get-top-performing-content">Get top-performing content</a>
+     */
+    async listByTopContent(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, viewsListByTopContent_js_1.viewsListByTopContent)(this, request, options));
+    }
+    /**
+     * Get concurrent viewers timeseries
+     *
+     * @remarks
+     * Retrieves a time series of the number of concurrent viewers, providing a real-time snapshot of audience activity over the last 30 minutes. This endpoint is essential for monitoring live events, gauging audience reaction to new content releases, or understanding immediate engagement trends.
+     *
+     * #### How it works
+     *
+     *   1. Make a simple `GET` request to this endpoint. No query parameters are needed.
+     *
+     *   2. The API automatically gathers data for the **last 30 minutes**, calculating the number of concurrent viewers at regular intervals within that window.
+     *
+     *   3. Receive a response containing a `data` array, where each object represents a specific point in time.
+     *
+     *   4. Each object in the array includes the `intervalTime` (the timestamp of the measurement) and `numberOfViews` (the count of concurrent viewers at that instant), allowing you to easily plot viewer activity over time.
+     *
+     * #### Example
+     *
+     * Imagine you are streaming a major live event, such as a product launch, a sports game, or a webinar. You need to monitor audience engagement in real-time to see if viewership is increasing, decreasing, or holding steady.
+     *
+     * By calling this endpoint periodically (e.g., every minute), you can plot a live graph of your viewership. This allows you to identify peak moments of interest, see the immediate impact of social media promotions, or detect potential technical issues if there's a sudden, unexpected drop in viewers
+     */
+    async getDataViewlistCurrentViewsGetTimeseriesViews(options) {
+        return (0, fp_js_1.unwrapAsync)((0, viewsGetDataViewlistCurrentViewsGetTimeseriesViews_js_1.viewsGetDataViewlistCurrentViewsGetTimeseriesViews)(this, options));
+    }
+    /**
+     * Get concurrent viewers breakdown by dimension
+     *
+     * @remarks
+     * Retrieves a real-time breakdown of present concurrent viewers, grouped by a chosen dimension. This endpoint allows you to see how your audience is distributed across different categories like geography, content, or technology, based on activity in the last 30 minutes.
+     *
+     * For example, you can see how many viewers are currently watching from the US vs. India, or which video titles are most popular right now.
+     *
+     * #### How it works
+     *
+     * 1. Make a `GET` request to this endpoint.
+     *
+     * 2. Specify the `dimension` you want to group by in the query parameters (e.g., `dimension=country` or `dimension=video_title`). This is the most important parameter as it defines how the data is categorized.
+     *
+     * 3. Optionally, use the `limit` parameter to control the number of results returned (e.g., `limit=5` to get the top 5 countries).
+     *
+     * 4. The API analyzes viewer data from the last 30 minutes and aggregates the viewer counts for each unique value within the chosen dimension.
+     *
+     * 5. Receive a response containing a `data` array, where each object represents a specific group (e.g., a country or a video title) and its corresponding number of `concurrent_viewers`.
+     *
+     * #### Example
+     *
+     * Imagine you are running a global streaming platform and have just launched a new original series. You want to see, in real-time, which regions are engaging most with the new content versus your older library content.
+     *
+     * By calling this endpoint with `dimension=video_title`, you can immediately see a list of your most-watched videos right now and their respective viewer counts. Then, by calling it again with `dimension=country`, you can get a live breakdown of your audience's geographic distribution. This helps you confirm if your marketing efforts in specific countries are paying off instantly and allows you to make data-driven decisions during live events.
+     */
+    async getDataViewlistCurrentViewsFilter(request, options) {
+        return (0, fp_js_1.unwrapAsync)((0, viewsGetDataViewlistCurrentViewsFilter_js_1.viewsGetDataViewlistCurrentViewsFilter)(this, request, options));
+    }
+}
+exports.Views = Views;
+//# sourceMappingURL=views.js.map

package/dist/commonjs/sdk/views.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"views.js","sourceRoot":"","sources":["../../../src/sdk/views.ts"],"names":[],"mappings":";;;AAAA,kHAA4G;AAC5G,0IAAoI;AACpI,sFAAgF;AAChF,gFAA0E;AAC1E,4EAAsE;AACtE,4CAA2D;AAE3D,0CAA6C;AAE7C,MAAa,KAAM,SAAQ,mBAAS;IAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,KAAK,CAAC,cAAc,CAClB,OAAyC,EACzC,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,4CAAmB,EACpC,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,mBAAmB,CACvB,OAA8C,EAC9C,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,sDAAwB,EACzC,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,KAAK,CAAC,gBAAgB,CACpB,OAA2C,EAC3C,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,gDAAqB,EACtC,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,KAAK,CAAC,6CAA6C,CACjD,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,0GAAkD,EACnE,IAAI,EACJ,OAAO,CACR,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAK,CAAC,iCAAiC,CACrC,OAAyE,EACzE,OAAwB;QAExB,OAAO,IAAA,mBAAW,EAAC,IAAA,kFAAsC,EACvD,IAAI,EACJ,OAAO,EACP,OAAO,CACR,CAAC,CAAC;IACL,CAAC;CACF;AAnKD,sBAmKC"}