@fastpix/fastpix-node 1.0.1 → 2.0.0

package/src/sdk/playback.ts

@@ -0,0 +1,89 @@
+import { playbackCreateMediaPlaybackId } from "../funcs/playbackCreateMediaPlaybackId.js";
+import { playbackDeleteMediaPlaybackId } from "../funcs/playbackDeleteMediaPlaybackId.js";
+import { playbackGetPlaybackId } from "../funcs/playbackGetPlaybackId.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Playback extends ClientSDK {
+  /**
+   * Create a playback ID
+   *
+   * @remarks
+   * You can create a new playback ID for a specific media asset. If you have already retrieved an existing `playbackId` using the <a href="https://docs.fastpix.io/reference/get-media">Get Media by ID</a> endpoint for a media asset, you can use this endpoint to generate a new playback ID with a specified access policy.
+   *
+   * If you want to create a private playback ID for a media asset that already has a public playback ID, this endpoint also allows you to do so by specifying the desired access policy.
+   *
+   * #### How it works
+   *
+   * 1. Make a `POST` request to this endpoint, replacing `<mediaId>` with the `uploadId` or `id` of the media asset.
+   *
+   * 2. Include the `accessPolicy` in the request body with `private` or `public` as the value.
+   *
+   * 3. Receive a response containing the newly created playback ID with the requested access level.
+   *
+   * #### Example
+   * A video streaming service generates playback IDs for each media file when users request to view specific content. The playback ID is then used by the video player to stream the video.
+   */
+  async createMediaPlaybackId(
+    request: operations.CreateMediaPlaybackIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateMediaPlaybackIdResponse> {
+    return unwrapAsync(playbackCreateMediaPlaybackId(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a playback ID
+   *
+   * @remarks
+   * This endpoint allows you to remove a specific playback ID associated with a media asset. Deleting a `playbackId` will revoke access to the media content linked to that ID.
+   *
+   * #### How it works
+   *
+   * 1. Make a `DELETE` request to this endpoint, replacing `<mediaId>` with the unique ID of the media asset from which you want to delete the playback ID.
+   *
+   * 2. Specify the `playbackId` you wish to delete in the request body.
+   *
+   * #### Example
+   *
+   * Your platform offers limited-time access to premium content. When the subscription expires, you can revoke access to the content by deleting the associated playback ID, preventing users from streaming the video further.
+   */
+  async deleteMediaPlaybackId(
+    request: operations.DeleteMediaPlaybackIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.DeleteMediaPlaybackIdResponse> {
+    return unwrapAsync(playbackDeleteMediaPlaybackId(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a playback ID
+   *
+   * @remarks
+   * This endpoint retrieves details about a specific playback ID associated with a media asset. This endpoint is commonly used to check the access policy (e.g., public or private) with the specific playback ID.
+   *
+   * **How it works:**
+   * 1. Make a GET request to the endpoint, replacing `{mediaId}` with the `id` of the media, and `{playbackId}` with the specific playback ID.
+   * 2. Useful for auditing or validation before granting playback access in your application.
+   *
+   * **Example:**
+   * A media platform might use this endpoint to verify if a playback ID is public or private before embedding the video in a frontend player or allowing access to a restricted group.
+   */
+  async getPlaybackId(
+    request: operations.GetPlaybackIdRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPlaybackIdResponse> {
+    return unwrapAsync(playbackGetPlaybackId(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/playlist.ts

@@ -0,0 +1,200 @@
+import { playlistAddMediaToPlaylist } from "../funcs/playlistAddMediaToPlaylist.js";
+import { playlistChangeMediaOrderInPlaylist } from "../funcs/playlistChangeMediaOrderInPlaylist.js";
+import { playlistCreateAPlaylist } from "../funcs/playlistCreateAPlaylist.js";
+import { playlistDeleteAPlaylist } from "../funcs/playlistDeleteAPlaylist.js";
+import { playlistDeleteMediaFromPlaylist } from "../funcs/playlistDeleteMediaFromPlaylist.js";
+import { playlistGetAllPlaylists } from "../funcs/playlistGetAllPlaylists.js";
+import { playlistGetPlaylistById } from "../funcs/playlistGetPlaylistById.js";
+import { playlistUpdateAPlaylist } from "../funcs/playlistUpdateAPlaylist.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class Playlist extends ClientSDK {
+  /**
+   * Create a new playlist
+   *
+   * @remarks
+   * This endpoint creates a new playlist within a specified workspace. A playlist acts as a container for organizing media items either manually or based on filters and metadata. <br> <br>
+   * ### Playlists can be created in two modes
+   * - **Manual:** An empty playlist is created without any initial media items. It's intended for manual curation, where items can be added later in a user-defined sequence.
+   * - **Smart:** The playlist is auto-populated at creation time based on filters (video creation date range) criteria provided in the request.
+   *
+   * #### How it works
+   *
+   *  - When a user sends a POST request to this endpoint, FastPix creates a playlist and returns a playlist ID, using which items can be added later in a user-defined sequence.
+   *  - For a smart playlist, the playlist will be auto-populated based on metadata in the request body.
+   *
+   * #### Example
+   * An e-learning platform creates a new playlist titled "Beginner Python Series" via the API. The response includes a unique playlist ID. The platform then uses this ID to add a series of video tutorials to the playlist in a defined order. The playlist is presented to learners on the frontend as a structured learning path.
+   */
+  async createAPlaylist(
+    request: models.CreatePlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistCreatedResponse> {
+    return unwrapAsync(playlistCreateAPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get all playlists
+   *
+   * @remarks
+   * This endpoint retrieves all playlists present within a specified workspace. It allows users to view the collection of playlists that have been created, whether manual or smart, along with their associated metadata.
+   * #### How it works
+   *
+   *  - When a user sends a GET request to this endpoint, FastPix returns a list of all playlists in the workspace, including details such as playlist IDs, titles, creation mode (manual or smart), and other relevant metadata.
+   *
+   * #### Example
+   *
+   *   An e-learning platform requests all playlists within a workspace to display an overview of available learning paths. The response includes multiple playlists like "Beginner Python Series" and "Advanced Java Tutorials," enabling the platform to show users a catalog of curated content collections.
+   */
+  async getAllPlaylists(
+    request?: operations.GetAllPlaylistsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetAllPlaylistsResponse> {
+    return unwrapAsync(playlistGetAllPlaylists(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get a playlist by ID
+   *
+   * @remarks
+   * This endpoint retrieves detailed information about a specific playlist using its unique `playlistId`. It provides comprehensive metadata about the playlist, including its title, creation mode (manual or smart), media items along with the metadata of each media in the playlist.
+   *
+   * #### Example
+   * An e-learning platform requests details for the playlist "Beginner Python Series" by providing its unique `playlistId`. The response includes the playlist's title, creation mode, and the ordered list of video tutorials contained within, enabling the platform to present the full learning path to users.
+   */
+  async getPlaylistById(
+    request: operations.GetPlaylistByIdRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistByIdResponse> {
+    return unwrapAsync(playlistGetPlaylistById(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update a playlist by ID
+   *
+   * @remarks
+   * This endpoint allows you to update the name and description of an existing playlist. It enables modifications to the playlist's metadata without altering the media items or playlist structure.
+   * #### How it works
+   *
+   *  - When a user sends a PUT request to this endpoint with the `playlistId` and updated name and description in the request body, FastPix updates the playlist metadata accordingly and returns the updated playlist details.
+   *
+   * #### Example
+   * An e-learning platform updates the playlist titled "Beginner Python Series" to rename it as "Python Basics" and add a more detailed description. The updated metadata is reflected when retrieving the playlist, helping users better understand the playlist content.
+   */
+  async updateAPlaylist(
+    request: operations.UpdateAPlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistCreatedResponse> {
+    return unwrapAsync(playlistUpdateAPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete a playlist by ID
+   *
+   * @remarks
+   * This endpoint allows you to delete an existing playlist from the workspace. Once deleted, the playlist and its metadata are permanently removed and cannot be recovered.
+   * #### How it works
+   *  - When a user sends a DELETE request to this endpoint with the `playlistId`, FastPix removes the specified playlist from the workspace and returns a confirmation of successful deletion.
+   *
+   * #### Example
+   * An e-learning platform deletes an outdated playlist titled "Old Python Tutorials" by providing its unique playlist ID. The platform receives confirmation that the playlist has been removed, ensuring learners no longer see the obsolete content.
+   */
+  async deleteAPlaylist(
+    request: operations.DeleteAPlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.SuccessResponse> {
+    return unwrapAsync(playlistDeleteAPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Add media to a playlist by ID
+   *
+   * @remarks
+   * This endpoint allows you to add one or more media items to an existing playlist. By passing the media ID(s) in the request, the specified media items are appended to the playlist in the order provided.
+   * #### How it works
+   *
+   *  - When a user sends a PATCH request to this endpoint with the `playlistId` as path parameter and a list of media ID(s) in the request body, FastPix adds the specified media items to the playlist and returns the updated playlist details.
+   *
+   * #### Example
+   * An e-learning platform adds new video tutorials to the "Beginner Python Series" playlist by sending their media IDs in the request. The playlist is updated with the new content, ensuring learners have access to the latest tutorials in sequence.
+   */
+  async addMediaToPlaylist(
+    request: operations.AddMediaToPlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistByIdResponse> {
+    return unwrapAsync(playlistAddMediaToPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Change media order in a playlist by ID
+   *
+   * @remarks
+   * This endpoint allows you to change the order of media items within a playlist. By passing the complete list of media IDs in the desired sequence, the playlist's play order is updated accordingly.
+   * #### How it works
+   *
+   *  - When a user sends a PUT request to this endpoint with the `playlistId` as path parameter and the reordered list of all media IDs in the request body, FastPix updates the playlist to reflect the new media sequence and returns the updated playlist details.
+   *
+   * #### Example
+   * An e-learning platform rearranges the "Beginner Python Series" playlist by submitting a reordered list of media IDs. The playlist now follows the new sequence, providing learners with a better structured learning path.
+   */
+  async changeMediaOrderInPlaylist(
+    request: operations.ChangeMediaOrderInPlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistByIdResponse> {
+    return unwrapAsync(playlistChangeMediaOrderInPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete media in a playlist by ID
+   *
+   * @remarks
+   * This endpoint allows you to delete one or more media items from an existing playlist. By passing the media ID(s) in the request, the specified media items are removed from the playlist.
+   * #### How it works
+   *
+   *  - When a user sends a DELETE request to this endpoint with the playlist ID as the path parameter and the media ID(s) to be removed in the request body, FastPix deletes the specified media items from the playlist and returns the updated playlist details.
+   *
+   * #### Example
+   * An e-learning platform removes outdated video tutorials from the "Beginner Python Series" playlist by specifying their media IDs in the request. The playlist is updated to exclude these items, ensuring learners only access relevant content.
+   */
+  async deleteMediaFromPlaylist(
+    request: operations.DeleteMediaFromPlaylistRequest,
+    options?: RequestOptions,
+  ): Promise<models.PlaylistByIdResponse> {
+    return unwrapAsync(playlistDeleteMediaFromPlaylist(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/sdk.ts

@@ -0,0 +1,93 @@
+import { ClientSDK } from "../lib/sdks.js";
+import { Dimensions } from "./dimensions.js";
+import { DRMConfigurations } from "./drmconfigurations.js";
+import { Errors } from "./errors.js";
+import { InputVideo } from "./inputvideo.js";
+import { InVideoAIFeatures } from "./invideoaifeatures.js";
+import { LivePlayback } from "./liveplayback.js";
+import { ManageLiveStream } from "./managelivestream.js";
+import { ManageVideos } from "./managevideos.js";
+import { Metrics } from "./metrics.js";
+import { Playback } from "./playback.js";
+import { Playlist } from "./playlist.js";
+import { SigningKeys } from "./signingkeys.js";
+import { SimulcastStream } from "./simulcaststream.js";
+import { StartLiveStream } from "./startlivestream.js";
+import { Views } from "./views.js";
+
+export class Fastpix extends ClientSDK {
+  private _inputVideo?: InputVideo;
+  get inputVideo(): InputVideo {
+    return (this._inputVideo ??= new InputVideo(this._options));
+  }
+
+  private _manageVideos?: ManageVideos;
+  get manageVideos(): ManageVideos {
+    return (this._manageVideos ??= new ManageVideos(this._options));
+  }
+
+  private _inVideoAIFeatures?: InVideoAIFeatures;
+  get inVideoAIFeatures(): InVideoAIFeatures {
+    return (this._inVideoAIFeatures ??= new InVideoAIFeatures(this._options));
+  }
+
+  private _playback?: Playback;
+  get playback(): Playback {
+    return (this._playback ??= new Playback(this._options));
+  }
+
+  private _playlist?: Playlist;
+  get playlist(): Playlist {
+    return (this._playlist ??= new Playlist(this._options));
+  }
+
+  private _drmConfigurations?: DRMConfigurations;
+  get drmConfigurations(): DRMConfigurations {
+    return (this._drmConfigurations ??= new DRMConfigurations(this._options));
+  }
+
+  private _startLiveStream?: StartLiveStream;
+  get startLiveStream(): StartLiveStream {
+    return (this._startLiveStream ??= new StartLiveStream(this._options));
+  }
+
+  private _manageLiveStream?: ManageLiveStream;
+  get manageLiveStream(): ManageLiveStream {
+    return (this._manageLiveStream ??= new ManageLiveStream(this._options));
+  }
+
+  private _livePlayback?: LivePlayback;
+  get livePlayback(): LivePlayback {
+    return (this._livePlayback ??= new LivePlayback(this._options));
+  }
+
+  private _simulcastStream?: SimulcastStream;
+  get simulcastStream(): SimulcastStream {
+    return (this._simulcastStream ??= new SimulcastStream(this._options));
+  }
+
+  private _signingKeys?: SigningKeys;
+  get signingKeys(): SigningKeys {
+    return (this._signingKeys ??= new SigningKeys(this._options));
+  }
+
+  private _views?: Views;
+  get views(): Views {
+    return (this._views ??= new Views(this._options));
+  }
+
+  private _dimensions?: Dimensions;
+  get dimensions(): Dimensions {
+    return (this._dimensions ??= new Dimensions(this._options));
+  }
+
+  private _metrics?: Metrics;
+  get metrics(): Metrics {
+    return (this._metrics ??= new Metrics(this._options));
+  }
+
+  private _errors?: Errors;
+  get errors(): Errors {
+    return (this._errors ??= new Errors(this._options));
+  }
+}

package/src/sdk/signingkeys.ts

@@ -0,0 +1,144 @@
+import { signingKeysCreateSigningKey } from "../funcs/signingKeysCreateSigningKey.js";
+import { signingKeysDeleteSigningKey } from "../funcs/signingKeysDeleteSigningKey.js";
+import { signingKeysGetSigningKeyById } from "../funcs/signingKeysGetSigningKeyById.js";
+import { signingKeysListSigningKeys } from "../funcs/signingKeysListSigningKeys.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class SigningKeys extends 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?: RequestOptions,
+  ): Promise<models.CreateResponse> {
+    return unwrapAsync(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?: operations.ListSigningKeysRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetAllSigningKeyResponse> {
+    return unwrapAsync(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: operations.DeleteSigningKeyRequest,
+    options?: RequestOptions,
+  ): Promise<models.DeleteSigningKeyResponse> {
+    return unwrapAsync(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: operations.GetSigningKeyByIdRequest,
+    options?: RequestOptions,
+  ): Promise<models.GetPublicPemUsingSigningKeyIdResponseDTO> {
+    return unwrapAsync(signingKeysGetSigningKeyById(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/simulcaststream.ts

@@ -0,0 +1,101 @@
+import { simulcastStreamCreateSimulcastOfStream } from "../funcs/simulcastStreamCreateSimulcastOfStream.js";
+import { simulcastStreamDeleteSimulcastOfStream } from "../funcs/simulcastStreamDeleteSimulcastOfStream.js";
+import { simulcastStreamGetSpecificSimulcastOfStream } from "../funcs/simulcastStreamGetSpecificSimulcastOfStream.js";
+import { simulcastStreamUpdateSpecificSimulcastOfStream } from "../funcs/simulcastStreamUpdateSpecificSimulcastOfStream.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export 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>
+   */
+  async createSimulcastOfStream(
+    request: operations.CreateSimulcastOfStreamRequest,
+    options?: RequestOptions,
+  ): Promise<models.SimulcastResponse> {
+    return unwrapAsync(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: operations.DeleteSimulcastOfStreamRequest,
+    options?: RequestOptions,
+  ): Promise<models.SimulcastdeleteResponse> {
+    return unwrapAsync(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: operations.GetSpecificSimulcastOfStreamRequest,
+    options?: RequestOptions,
+  ): Promise<models.SimulcastResponse> {
+    return unwrapAsync(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: operations.UpdateSpecificSimulcastOfStreamRequest,
+    options?: RequestOptions,
+  ): Promise<models.SimulcastUpdateResponse> {
+    return unwrapAsync(simulcastStreamUpdateSpecificSimulcastOfStream(
+      this,
+      request,
+      options,
+    ));
+  }
+}

package/src/sdk/startlivestream.ts

@@ -0,0 +1,38 @@
+import { startLiveStreamCreateNewStream } from "../funcs/startLiveStreamCreateNewStream.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export 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>
+   */
+  async createNewStream(
+    request: models.CreateLiveStreamRequest,
+    options?: RequestOptions,
+  ): Promise<models.LiveStreamResponseDTO> {
+    return unwrapAsync(startLiveStreamCreateNewStream(
+      this,
+      request,
+      options,
+    ));
+  }
+}