@fastpix/fastpix-node 1.0.0

package/dist/index.mjs

@@ -0,0 +1,614 @@
+// 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

@@ -0,0 +1,48 @@
+# 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);
+```