@fastpix/fastpix-node 1.0.2 → 2.0.0

package/dist/index.mjs

@@ -1,614 +0,0 @@
-// src/index.ts
-import { Buffer } from "buffer";
-
-// src/NetworkFetcher/index.ts
-var Fetcher = class {
-  // Fetches data from the specified URL using the provided headers.
-  async fetchData(url, header) {
-    if (!url || !header) {
-      throw new Error("Invalid arguments: URL and header are required.");
-    }
-    try {
-      const response = await fetch(url, header);
-      if (response.ok) {
-        const successResponse = await response.json();
-        return successResponse;
-      }
-      if ([400, 401, 403, 404, 409, 422].includes(response.status)) {
-        const errorResponse = await response.json();
-        const configErrorResponse = {
-          success: false,
-          error: {
-            code: response.status,
-            message: errorResponse?.error?.message ?? response.statusText ?? "An unexpected error occurred"
-          }
-        };
-        if (errorResponse?.error?.fields) {
-          configErrorResponse.error.fields = errorResponse.error.fields;
-        }
-        return configErrorResponse;
-      }
-      return {
-        success: false,
-        error: {
-          code: response.status ?? 500,
-          message: response.statusText ?? "An internal server error occurred."
-        }
-      };
-    } catch (error) {
-      throw new Error(
-        `An error occurred while fetching data: ${error?.message ?? "Internal error"}`
-      );
-    }
-  }
-  // Constructs a complete URL based on the provided request object, path, and query parameters.
-  constructUrl(requestObj, path = "", queryParams = "") {
-    const protocol = requestObj?.httpAgent ?? "https";
-    const domain = requestObj?.domain ?? "v1.fastpix.io";
-    return `${protocol}://${domain}/${path}${queryParams}`;
-  }
-  // Constructs HTTP headers for a request based on the provided request object.
-  constructHeaders(requestObj) {
-    if (!requestObj?.encodedAuthToken) {
-      throw new Error("Authorization credentials are missing.");
-    }
-    const method = requestObj?.method ?? "GET";
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Basic ${requestObj.encodedAuthToken}`
-    };
-    const requestOptions = {
-      method,
-      headers
-    };
-    if (method !== "GET" && method !== "DELETE" && requestObj?.body) {
-      requestOptions.body = JSON.stringify(requestObj.body);
-    }
-    return requestOptions;
-  }
-};
-var NetworkFetcher_default = Fetcher;
-
-// src/VideoOnDemand/index.ts
-var Media = class {
-  constructor() {
-    this.fetch = new NetworkFetcher_default();
-    this.mediaPath = "on-demand";
-  }
-  // Creates a new media asset.
-  async createAsset(requestObj, props = {}) {
-    const path = this.mediaPath;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const { accessPolicy = "public", ...restProps } = props;
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        accessPolicy,
-        ...restProps
-      }
-    };
-    const createAssetHeader = this.fetch.constructHeaders(constructObject);
-    const createUrlAsset = await this.fetch.fetchData(url, createAssetHeader);
-    return createUrlAsset;
-  }
-  // Uploads a media asset using direct upload.
-  async uploadAsset(requestObj, props = {
-    corsOrigin: "",
-    pushMediaSettings: {
-      accessPolicy: "public",
-      // Default access policy
-      inputs: []
-      // Default empty array for inputs (inside pushMediaSettings)
-    }
-  }) {
-    const path = `${this.mediaPath}/uploads`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const {
-      corsOrigin = "*",
-      pushMediaSettings = { accessPolicy: "public" },
-      ...restProps
-    } = props;
-    const { accessPolicy = "public", ...restPushMediaSettings } = pushMediaSettings;
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        corsOrigin,
-        pushMediaSettings: {
-          accessPolicy,
-          ...restPushMediaSettings
-        },
-        ...restProps
-      }
-    };
-    const uploadAssetHeader = this.fetch.constructHeaders(constructObject);
-    const uploadMediaAsset = await this.fetch.fetchData(url, uploadAssetHeader);
-    return uploadMediaAsset;
-  }
-  // Retrieves all media assets with pagination support.
-  async getAllAssets(props, requestObj) {
-    const path = this.mediaPath;
-    const queryParams = `?limit=${props?.limit ?? 10}&offset=${props?.offset ?? 1}&orderBy=${props?.orderBy ?? "desc"}`;
-    const url = this.fetch.constructUrl(requestObj, path, queryParams);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getAllAssetsHeader = this.fetch.constructHeaders(constructObject);
-    const assetsResponse = await this.fetch.fetchData(url, getAllAssetsHeader);
-    return assetsResponse;
-  }
-  // Retrieves details of a specific media asset.
-  async getAsset(props, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getAssetsHeader = this.fetch.constructHeaders(constructObject);
-    const assetsResponse = await this.fetch.fetchData(url, getAssetsHeader);
-    return assetsResponse;
-  }
-  // Retrieves detailed information about a media asset's input.
-  async getAssetInfo(props, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}/input-info`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getAssetInfoHeader = this.fetch.constructHeaders(constructObject);
-    const assetInfoResponse = await this.fetch.fetchData(
-      url,
-      getAssetInfoHeader
-    );
-    return assetInfoResponse;
-  }
-  // Updates the details of a media asset.
-  async updateAsset(props, updateObject, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "PATCH",
-      body: {
-        ...updateObject ?? {}
-      }
-    };
-    const updateAssetHeader = this.fetch.constructHeaders(constructObject);
-    const updateAssetResponse = await this.fetch.fetchData(
-      url,
-      updateAssetHeader
-    );
-    return updateAssetResponse;
-  }
-  // Deletes a media asset.
-  async deleteAsset(props, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "DELETE"
-    };
-    const deleteAssetHeader = this.fetch.constructHeaders(constructObject);
-    const deleteAssetResponse = await this.fetch.fetchData(
-      url,
-      deleteAssetHeader
-    );
-    return deleteAssetResponse;
-  }
-  //  Adds a playback ID to a media asset with a specific access policy.
-  async addMediaPlaybackId(props, playbackPolicy, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}/playback-ids`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        accessPolicy: playbackPolicy?.accessPolicy ?? "public"
-      }
-    };
-    const createPlaybackIdHeader = this.fetch.constructHeaders(constructObject);
-    const createPlaybackIdResponse = await this.fetch.fetchData(
-      url,
-      createPlaybackIdHeader
-    );
-    return createPlaybackIdResponse;
-  }
-  // Removes a playback ID from a media asset.
-  async removeMediaPlaybackId(props, requestObj) {
-    const path = `${this.mediaPath}/${props?.mediaId ?? ""}/playback-ids`;
-    let queryParams = "";
-    if (props?.playbackId) {
-      if (Array.isArray(props.playbackId)) {
-        const playbackIdParams = props.playbackId.map(
-          (id) => "playbackId=" + id
-        );
-        queryParams = "?" + playbackIdParams.join("&");
-      } else if (typeof props.playbackId === "string") {
-        queryParams = "?playbackId=" + props.playbackId;
-      }
-    }
-    const url = this.fetch.constructUrl(requestObj, path, queryParams);
-    const constructObject = {
-      ...requestObj,
-      method: "DELETE"
-    };
-    const deletePlaybackIdHeader = this.fetch.constructHeaders(constructObject);
-    const deletePlaybackIdResponse = await this.fetch.fetchData(
-      url,
-      deletePlaybackIdHeader
-    );
-    return deletePlaybackIdResponse;
-  }
-};
-var VideoOnDemand_default = Media;
-
-// src/Live/index.ts
-var LiveStream = class {
-  constructor() {
-    this.fetch = new NetworkFetcher_default();
-    this.livePath = "live/streams";
-  }
-  // Creates a new live stream with the given properties.
-  async createNewLiveStream(props, requestObj) {
-    const path = this.livePath;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        playbackSettings: {
-          accessPolicy: props?.playbackSettings?.accessPolicy ?? "public"
-        },
-        inputMediaSettings: {
-          ...props?.inputMediaSettings
-        }
-      }
-    };
-    const createLiveStreamHeader = this.fetch.constructHeaders(constructObject);
-    const createLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      createLiveStreamHeader
-    );
-    return createLiveStreamResponse;
-  }
-  // Retrieves all live streams with pagination support.
-  async getAllLiveStreams(props, requestObj) {
-    const path = this.livePath;
-    const queryParams = `?limit=${props?.limit ?? 10}&offset=${props?.offset ?? 1}&orderBy=${props?.orderBy ?? "desc"}`;
-    const url = this.fetch.constructUrl(requestObj, path, queryParams);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getAllLiveStreamHeader = this.fetch.constructHeaders(constructObject);
-    const getAllLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      getAllLiveStreamHeader
-    );
-    return getAllLiveStreamResponse;
-  }
-  // Retrieves details of a specific live stream.
-  async getLiveStream(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getLiveStreamHeader = this.fetch.constructHeaders(constructObject);
-    const getLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      getLiveStreamHeader
-    );
-    return getLiveStreamResponse;
-  }
-  // Updates a live stream with new properties.
-  async updateLiveStream(props, updateObject, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "PATCH",
-      body: {
-        ...updateObject ?? {}
-      }
-    };
-    const updateLiveStreamHeader = this.fetch.constructHeaders(constructObject);
-    const updateLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      updateLiveStreamHeader
-    );
-    return updateLiveStreamResponse;
-  }
-  // Deletes a specific live stream.
-  async deleteLiveStream(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "DELETE"
-    };
-    const deleteLiveStream = this.fetch.constructHeaders(constructObject);
-    const deleteLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      deleteLiveStream
-    );
-    return deleteLiveStreamResponse;
-  }
-  // Creates a playback ID for a live stream with specified access policy.
-  async createLiveStreamPlaybackId(props, playbackPolicy, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/playback-ids`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        accessPolicy: playbackPolicy?.accessPolicy ?? "public"
-      }
-    };
-    const createPlaybackIdHeader = this.fetch.constructHeaders(constructObject);
-    const createPlaybackIdResponse = await this.fetch.fetchData(
-      url,
-      createPlaybackIdHeader
-    );
-    return createPlaybackIdResponse;
-  }
-  // Removes a playback ID associated with a live stream.
-  async removeLivePlaybackId(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/playback-ids`;
-    let queryParams = "";
-    if (props?.playbackId) {
-      if (Array.isArray(props.playbackId)) {
-        const playbackIdParams = props.playbackId.map(
-          (id) => "playbackId=" + id
-        );
-        queryParams = "?" + playbackIdParams.join("&");
-      } else if (typeof props.playbackId === "string") {
-        queryParams = "?playbackId=" + props.playbackId;
-      }
-    }
-    const url = this.fetch.constructUrl(requestObj, path, queryParams);
-    const constructObject = {
-      ...requestObj,
-      method: "DELETE"
-    };
-    const deletePlaybackIdHeader = this.fetch.constructHeaders(constructObject);
-    const deletePlaybackIdResponse = await this.fetch.fetchData(
-      url,
-      deletePlaybackIdHeader
-    );
-    return deletePlaybackIdResponse;
-  }
-  // Retrieves the playback policy for a specific playback ID in a live stream.
-  async getLiveStreamPlaybackPolicy(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/playback-ids/${props?.playbackId}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getLiveStreamPlaybackPolicyHeader = this.fetch.constructHeaders(constructObject);
-    const getLiveStreamPlaybackPolicyResponse = await this.fetch.fetchData(
-      url,
-      getLiveStreamPlaybackPolicyHeader
-    );
-    return getLiveStreamPlaybackPolicyResponse;
-  }
-  // Creates a new simulcast target for a live stream.
-  async createLiveStreamSimulcast(props, liveStreamObj, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/simulcast`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "POST",
-      body: {
-        ...liveStreamObj
-      }
-    };
-    const createSimulCastHeader = this.fetch.constructHeaders(constructObject);
-    const createSimulCastResponse = await this.fetch.fetchData(
-      url,
-      createSimulCastHeader
-    );
-    return createSimulCastResponse;
-  }
-  // Retrieves details of a specific simulcast target for a live stream.
-  async getLiveStreamSimulcast(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/simulcast/${props?.simulcastId}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "GET"
-    };
-    const getSimulcastHeader = this.fetch.constructHeaders(constructObject);
-    const getSimulcastResponse = await this.fetch.fetchData(
-      url,
-      getSimulcastHeader
-    );
-    return getSimulcastResponse;
-  }
-  // Updates an existing simulcast target for a live stream.
-  async updateLiveStreamSimulcast(props, simulcastObj, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/simulcast/${props?.simulcastId}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "PUT",
-      body: {
-        ...simulcastObj
-      }
-    };
-    const updateLiveStreamHeader = this.fetch.constructHeaders(constructObject);
-    const updateLiveStreamResponse = await this.fetch.fetchData(
-      url,
-      updateLiveStreamHeader
-    );
-    return updateLiveStreamResponse;
-  }
-  //  Deletes an existing simulcast target from a live stream.
-  async deleteLiveStreamSimulcast(props, requestObj) {
-    const path = `${this.livePath}/${props?.streamId ?? ""}/simulcast/${props?.simulcastId}`;
-    const url = this.fetch.constructUrl(requestObj, path);
-    const constructObject = {
-      ...requestObj,
-      method: "DELETE"
-    };
-    const deleteSimulcastHeader = this.fetch.constructHeaders(constructObject);
-    const deleteSimulcastResponse = await this.fetch.fetchData(
-      url,
-      deleteSimulcastHeader
-    );
-    return deleteSimulcastResponse;
-  }
-};
-var Live_default = LiveStream;
-
-// src/index.ts
-var Client = class {
-  // Request configuration object
-  constructor(props) {
-    // Secret key for authentication
-    this.mediaService = null;
-    // Media service instance
-    this.liveStream = null;
-    this.accessTokenId = props?.accessTokenId;
-    this.secretKey = props?.secretKey;
-    this.validateSecrets();
-    this.mediaService = new VideoOnDemand_default();
-    this.liveStream = new Live_default();
-    if (this.accessTokenId && this.secretKey) {
-      this.encodedAuthToken = Buffer.from(
-        `${this.accessTokenId}:${this.secretKey}`
-      ).toString("base64");
-    }
-    this.RequestObject = {
-      httpAgent: "https",
-      domain: "v1.fastpix.io",
-      encodedAuthToken: this.encodedAuthToken
-    };
-  }
-  // Validate the provided credentials
-  validateSecrets() {
-    if (!this.accessTokenId || typeof this.accessTokenId !== "string") {
-      throw new Error(
-        'Invalid accessTokenId: The "accessTokenId" is required.'
-      );
-    }
-    if (!this.secretKey || typeof this.secretKey !== "string") {
-      throw new Error('Invalid secretKey: The "secretKey" is required.');
-    }
-  }
-  // Media Methods
-  // Uploads media from a given URL
-  uploadMediaFromUrl(props) {
-    return this.mediaService ? this.mediaService.createAsset(this.RequestObject, props) : null;
-  }
-  // Uploads media from a file input.
-  uploadMediaFromDevice(props) {
-    return this.mediaService ? this.mediaService.uploadAsset(this.RequestObject, props) : null;
-  }
-  // Retrieves all media assets with pagination.
-  getAllMediaAssets(props) {
-    return this.mediaService ? this.mediaService.getAllAssets(props, this.RequestObject) : null;
-  }
-  // Fetches a media asset by its ID.
-  getMediaAssetById(props) {
-    return this.mediaService ? this.mediaService.getAsset(props, this.RequestObject) : null;
-  }
-  // Fetches information about a media asset by its ID.
-  getMediaAssetInfo(props) {
-    return this.mediaService ? this.mediaService.getAssetInfo(props, this.RequestObject) : null;
-  }
-  // Modifies metadata of an existing media asset.
-  updateMediaAsset(props, updateObject) {
-    return this.mediaService ? this.mediaService.updateAsset(props, updateObject, this.RequestObject) : null;
-  }
-  // Removes a media asset by its ID.
-  deleteMediaAsset(props) {
-    return this.mediaService ? this.mediaService.deleteAsset(props, this.RequestObject) : null;
-  }
-  // Creates a playback ID for a media asset.
-  generateMediaPlaybackId(props, accessPolicy) {
-    return this.mediaService ? this.mediaService.addMediaPlaybackId(
-      props,
-      accessPolicy,
-      this.RequestObject
-    ) : null;
-  }
-  // Removes a playback ID from a media asset.
-  deleteMediaPlaybackId(props) {
-    return this.mediaService ? this.mediaService.removeMediaPlaybackId(props, this.RequestObject) : null;
-  }
-  // Initiates a new live stream.
-  initiateLiveStream(props) {
-    return this.liveStream ? this.liveStream.createNewLiveStream(props, this.RequestObject) : null;
-  }
-  // Retrieves all live streams with pagination.
-  getAllLiveStreams(props) {
-    return this.liveStream ? this.liveStream.getAllLiveStreams(props, this.RequestObject) : null;
-  }
-  // Fetches a live stream by its ID.
-  getLiveStreamById(props) {
-    return this.liveStream ? this.liveStream.getLiveStream(props, this.RequestObject) : null;
-  }
-  // Modifies an existing live stream.
-  updateLiveStream(props, updateObject) {
-    return this.liveStream ? this.liveStream.updateLiveStream(
-      props,
-      updateObject,
-      this.RequestObject
-    ) : null;
-  }
-  // Removes a live stream by its ID.
-  deleteLiveStream(props) {
-    return this.liveStream ? this.liveStream.deleteLiveStream(props, this.RequestObject) : null;
-  }
-  // Creates a playback ID for a live stream.
-  generateLiveStreamPlaybackId(props, accessPolicy) {
-    return this.liveStream ? this.liveStream.createLiveStreamPlaybackId(
-      props,
-      accessPolicy,
-      this.RequestObject
-    ) : null;
-  }
-  // Removes a playback ID from a live stream.
-  deleteLiveStreamPlaybackId(props) {
-    return this.liveStream ? this.liveStream.removeLivePlaybackId(props, this.RequestObject) : null;
-  }
-  // Fetches the playback policy for a live stream.
-  getLiveStreamPlaybackPolicy(props) {
-    return this.liveStream ? this.liveStream.getLiveStreamPlaybackPolicy(props, this.RequestObject) : null;
-  }
-  // Initiates a simulcast for a live stream.
-  initiateLiveStreamSimulcast(props, liveStreamObj) {
-    return this.liveStream ? this.liveStream.createLiveStreamSimulcast(
-      props,
-      liveStreamObj,
-      this.RequestObject
-    ) : null;
-  }
-  // Retrieves a simulcast for a live stream.
-  getLiveStreamSimulcast(props) {
-    return this.liveStream ? this.liveStream.getLiveStreamSimulcast(props, this.RequestObject) : null;
-  }
-  // Modifies an existing simulcast for a live stream.
-  updateLiveStreamSimulcast(props, simulcastObj) {
-    return this.liveStream ? this.liveStream.updateLiveStreamSimulcast(
-      props,
-      simulcastObj,
-      this.RequestObject
-    ) : null;
-  }
-  // Removes a simulcast from a live stream.
-  deleteLiveStreamSimulcast(props) {
-    return this.liveStream ? this.liveStream.deleteLiveStreamSimulcast(props, this.RequestObject) : null;
-  }
-};
-var index_default = Client;
-export {
-  index_default as default
-};

package/docs/Live/CreateLiveStream.md

@@ -1,48 +0,0 @@
-# Method: initiateLiveStream()
-
-The `initiateLiveStream` method allows you to start a live stream with specific configurations. You can define settings for playback, input media, and metadata. This method returns the details of the initiated stream, including the unique `streamId` and `streamKey` that you can use for managing further live stream operations.
-
-### Parameter Details:
-
-
-| **Parameter**        | **Description**                                                           | **Type** | **Accepted Values** |
-| -------------------- | ------------------------------------------------------------------------- | -------- | ------------------- |
-| `playbackSettings`   | Defines settings related to playback, such as access policy.              | `Object` | See details below   |
-| `inputMediaSettings` | Defines settings related to the media being streamed, such as resolution. | `Object` | See details below   |
-
-#### playbackSettings
-
-| **Parameter**  | **Description**                                                                   | **Type** | **Accepted Values**     |
-| -------------- | --------------------------------------------------------------------------------- | -------- | ----------------------- |
-| `accessPolicy` | Determines if access to the streamed content is kept private or available to all. | `String` | `"public"`, `"private"` |
-
-#### inputMediaSettings
-
-| **Parameter**     | **Description**                                                                                | **Type**  | **Accepted Values**                                             |
-| ----------------- | ---------------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------- |
-| `maxResolution`   | Sets the maximum resolution for the live stream.                                               | `String`  | `"1080p"`, `"720p"`, `"480p"`                                   |
-| `reconnectWindow` | The time in seconds to wait before reconnecting the stream if it's interrupted.                | `Integer` | 60 to 1800 seconds                                              |
-| `mediaPolicy`     | Determines whether the recorded stream is private or public when converted to VOD.             | `String`  | `"public"`, `"private"`                                         |
-| `metadata`        | Optional metadata for tagging the live stream. Up to 10 key-value pairs.                       | `Object`  | Any valid key-value pair (max 255 characters per key and value) |
-| `enableDvrMode`   | Enables or disables DVR mode for the live stream. When enabled, viewers can rewind the stream. | `Boolean` | `true`, `false`                                                 |
-
-### Example Request:
-
-```javascript
-// Define the live stream request with custom configurations
-const liveStreamRequest = {
-  playbackSettings: {
-    accessPolicy: "public", // Defines the access level of the live stream (public or private)
-  },
-  inputMediaSettings: {
-    maxResolution: "1080p", // Set the maximum resolution of the live stream
-    reconnectWindow: 60, // Set the duration for reconnecting the stream in seconds
-    mediaPolicy: "public", // Define media policy (public or private)
-    enableDvrMode: true, // Enable DVR mode to allow viewers to rewind the live stream
-  },
-};
-
-// Initiating the live stream
-const generateLiveStream = await fastpix.initiateLiveStream(liveStreamRequest);
-console.log("Live Stream initiated successfully:", generateLiveStream);
-```