@fastpix/fastpix-node 1.0.0

package/docs/Live/ManageLiveStreams.md

@@ -0,0 +1,116 @@
+# Managing Live Streams
+
+Live streams are uniquely identified by the `streamId`, which is generated automatically when you create a new live stream using the `initiateLiveStream` method. This `streamId` is essential for performing any operations related to live streams, such as retrieving details, updating configurations, or deleting streams.
+
+---
+
+# Method: getAllLiveStreams()
+
+The `getAllLiveStreams` method allows you to fetch a list of all live streams. You can customize the query by modifying parameters such as `limit`, `offset`, and `orderBy`. If no parameters are provided, the method will use default values.
+
+### Parameter Details:
+
+The method accepts the following query parameters:
+
+| **Parameter** | **Description**                                                                       | **Type** | **Default Value** | **Accepted Values**                         |
+| ------------- | ------------------------------------------------------------------------------------- | -------- | ----------------- | ------------------------------------------- |
+| `limit`       | Specifies the maximum number of items to display per page.                            | `Number` | `10`              | 1 to 50                                     |
+| `offset`      | Determines the starting point for data retrieval in a paginated list.                 | `Number` | `1`               | Any positive integer (e.g., `1`, `5`, `10`) |
+| `orderBy`     | Sorts the list of streams. The list can be arranged in ascending or descending order. | `String` | `desc`            | `"desc"`, `"asc"`                           |
+
+### Example Request:
+
+```javascript
+// Define pagination settings for retrieving live streams
+const getAllLiveStreamPagination = {
+  limit: 10, // Limit the number of live streams retrieved (1 to 50)
+  offset: 1, // Skip a specified number of streams for pagination
+  orderBy: "asc", // Sort the results in ascending order
+};
+
+// Fetch the live streams using the defined parameters
+const getAllLiveStreams = await fastpix.getAllLiveStreams(
+  getAllLiveStreamPagination
+);
+console.log("All Live Streams:", getAllLiveStreams);
+```
+
+---
+
+# Method: getLiveStreamById()
+
+The `getLiveStreamById` method allows you to retrieve the details of a specific live stream by its unique `streamId`. 
+
+### Parameter Details:
+
+| **Parameter**         | **Description**                                                                              | **Type** | **Accepted Values**                   |
+| --------------------- | -------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
+| `streamId` (required) | The unique identifier assigned to the live stream. You receive this ID upon stream creation. | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the streamId for the live stream you want to retrieve
+const getLiveStreamById = await fastpix.getLiveStreamById({
+  streamId: "a09f3e958c16ed00e85bfe798abd9845", // Replace with the actual stream ID
+});
+
+console.log("Live Stream Details:", getLiveStreamById);
+```
+
+---
+
+# Method: updateLiveStream()
+
+The `updateLiveStream` method allows you to update a live stream's `metadata` and `reconnectWindow`, using the `streamId`.
+
+### Parameter Details:
+
+| **Parameter**                | **Description**                                                                                                                                                   | **Type**  | **Accepted Values**                                             |
+| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------- |
+| `streamId` (required)        | The unique identifier assigned to the live stream. You receive this ID upon stream creation.                                                                      | `String`  | Any valid string (max 255 characters)                           |
+| `metadata`       | Optional metadata to tag the live stream with key-value pairs. You can add up to 10 key-value pairs, and each key and value can have a maximum of 255 characters. | `Object`  | Any valid key-value pair (max 255 characters per key and value) |
+| `reconnectWindow` | The time (in seconds) before ending the stream in case of a disruption. This value can range from 60 to 1800 seconds.                           | `Integer` | 60 to 1800 (seconds)                                            |
+
+### Example Request:
+
+```javascript
+// Define the fields to be updated in the live stream configuration
+const updateLiveStreamRequest = {
+  metadata: {
+    livestream_name: "Game_streaming", // Example of a metadata entry
+  },
+  reconnectWindow: 100, // Set the reconnect window to 100 seconds
+};
+
+// Update the live stream with the specified streamId
+const updateLiveStream = await fastpix.updateLiveStream(
+  { streamId: "a09f3e958c16ed00e85bfe798abd9845" }, // Provide the stream ID for the live stream to update
+  updateLiveStreamRequest
+);
+
+console.log("Updated Live Stream:", updateLiveStream);
+```
+
+---
+
+# Method: deleteLiveStream()
+
+The `deleteLiveStream` method allows you to delete a live stream by its unique `streamId`.
+
+### Parameter Details:
+
+| **Parameter**         | **Description**                                                                                       | **Type** | **Accepted Values**                   |
+| --------------------- | ----------------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
+| `streamId` (required) | The unique identifier assigned to the live stream. You receive this ID when creating the live stream. | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the streamId for the live stream you wish to delete
+const deleteLiveStream = await fastpix.deleteLiveStream({
+  streamId: "a09f3e958c16ed00e85bfe798abd9845", // Provide the stream ID of the live stream to delete
+});
+
+console.log("Deleted Live Stream:", deleteLiveStream);
+```

package/docs/Live/ManageStreamPlayback.md

@@ -0,0 +1,86 @@
+# Managing Live Stream Playback
+
+To manage playback, you must first initiate a live stream, which will provide you with a unique `streamId`. This `streamId` will be used across all playback management operations, such as generating playback IDs, retrieving policies, and deleting them.
+
+---
+
+# Method: generateLiveStreamPlaybackId()
+
+The `generateLiveStreamPlaybackId` method allows you to generate a playback ID for a live stream. This requires the `streamId` of the live stream you want to generate the playback ID for, as well as the desired `accessPolicy` which controls whether the stream will be public or private. If the `accessPolicy` is not provided, the default value is `public`.
+
+### Parameter Details:
+
+| **Parameter**             | **Description**                                                                                       | **Type** | **Default Value** | **Accepted Values**                   |
+| ------------------------- | ----------------------------------------------------------------------------------------------------- | -------- | ----------------- | ------------------------------------- |
+| `streamId` (required)     | The unique identifier assigned to the live stream. You receive this ID when creating the live stream. | `String` | -                 | Any valid string (max 255 characters) |
+| `accessPolicy` | Determines if access to the streamed content is kept private or available to all.                     | `String` | `"public"`        | `"public"`, `"private"`               |
+
+### Example Request:
+
+```javascript
+// Generate a live stream playback ID for an existing stream
+const generateLiveStreamPlaybackId = await fastpix.generateLiveStreamPlaybackId(
+  { streamId: "a09f3e958c16ed00e85bfe798abd9845" }, // Pass the stream ID for which the playback ID is to be generated
+  { accessPolicy: "public" } // Specify the access policy (can be "public" or "private")
+);
+
+console.log("Generated Live Stream Playback ID:", generateLiveStreamPlaybackId);
+```
+
+---
+
+# Method: deleteLiveStreamPlaybackId()
+
+The `deleteLiveStreamPlaybackId` method allows you to delete one or more playback IDs for a live stream. This method allows you to specify the `streamId` of the live stream, and the `playbackId` you wish to delete and supports deleting a **single playback ID** as a string or **multiple playback IDs** as an array of strings.
+
+### Parameter Details:
+
+| **Parameter**           | **Description**                                                                                       | **Type** | **Accepted Values**                     |
+| ----------------------- | ---------------------------------------------------------------------------------------------------- | -------- | --------------------------------------- |
+| `streamId` (required)   | The unique identifier assigned to the live stream. You receive this ID when creating the live stream. | `String` | Any valid string (up to 255 characters) |
+| `playbackId` (required) | The unique identifiers for the playback IDs to be deleted.            | `Array` or `String`  | Array of valid strings (up to 255 characters each) or string |
+
+### Example Request:
+
+```javascript
+// Define the streamId and playbackId dynamically
+const streamId = "a09f3e958c16ed00e85bfe798abd9845";
+
+// For single playbackId, pass it as a string
+const playbackId = "632029b4-7c53-4dcf-a4d3-1884c29e90f8"; 
+
+// For multiple playbackId's, pass them as an array of strings
+// const playbackId = ["632029b4-7c53-4dcf-a4d3-1884c29e90f8", "687629b4-7c53-4dcf-a4d3-1884876540f8"]; 
+
+const deleteLiveStreamPlaybackId = await fastpix.deleteLiveStreamPlaybackId({
+  streamId: streamId, // Pass the streamId of the live stream for which playback ID is to be deleted
+  playbackId: playbackId, // Pass the playbackId as an array (even for a single ID)
+});
+
+console.log("Deleted Live Stream Playback ID:", deleteLiveStreamPlaybackId);
+```
+
+---
+
+# Method: getLiveStreamPlaybackPolicy()
+
+The `getLiveStreamPlaybackPolicy` method allows you to retrieve the playback policy for a specific live stream playback ID. You need to provide both the `streamId` of the live stream and the `playbackId` associated with that stream to fetch the playback policy.
+
+### Parameter Details:
+
+| **Parameter**           | **Description**                                                                                       | **Type** | **Accepted Values**                   |
+| ----------------------- | ----------------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
+| `streamId` (required)   | The unique identifier assigned to the live stream. You receive this ID when creating the live stream. | `String` | Any valid string (max 255 characters) |
+| `playbackId` (required) | The unique identifier for the playback ID associated with the live stream.                            | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Retrieve the playback policy for a specific live stream playback ID
+const getLiveStreamPlaybackPolicy = await fastpix.getLiveStreamPlaybackPolicy({
+  streamId: "1c5e8abcc2080cba74f5d0ac91c7833e", // Replace with the actual stream ID
+  playbackId: "95ce872d-0b58-44f3-be72-8ed8b97ee2c9", // Replace with the actual playback ID
+});
+
+console.log("Live Stream Playback Policy:", getLiveStreamPlaybackPolicy);
+```

package/docs/Live/ManageStreamSimulcast.md

@@ -0,0 +1,133 @@
+# Manage Live Stream Simulcast
+
+Simulcasting allows you to stream your live content to multiple platforms simultaneously. A suite of methods is available to manage live stream simulcasts, including creating a new simulcast, retrieving its details, updating its configuration, and deleting an existing simulcast. 
+
+To manage simulcasts effectively, you’ll need the `streamId` (generated when you initiate a live stream) and the `simulcastId` (generated when the simulcast is created). These identifiers are crucial for linking simulcast operations to the correct live stream and simulcast.
+
+# Method: initiateLiveStreamSimulcast()
+
+The `initiateLiveStreamSimulcast` method allows you to create a new simulcast for an existing live stream. Provide the `streamId` of the live stream and a simulcast payload containing the URL and stream key required to start streaming.
+
+In the response `simulcastId` must be retained for managing future operations on the simulcast, such as updating or deleting it.
+
+### Parameter Details:
+
+| **Parameter**          | **Description**                                                                                                                                      | **Type** | **Accepted Values**                                           |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------------------------------- |
+| `url` (required)       | The RTMP URL, combined with the application name, is crucial for connecting to third-party live streaming services and transmitting the live stream. | `String` | Any valid RTMP URL (e.g., `rtmps://live.fastpix.io:443/live`) |
+| `streamKey` (required) | A unique stream key that allows the user to start streaming on a third-party platform. This key is used in the RTMP stream configuration.            | `String` | Any valid stream key (max 255 characters)                     |
+| `streamId` (required) | The unique identifier assigned to the live stream. This ID is generated during the creation of the live stream. | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the simulcast payload with the URL and stream key
+const simulcastPayload = {
+  url: "rtmps://live.fastpix.io:443/live", // RTMP URL for the third-party platform
+  streamKey:
+    "46c3457fa8a579b2d4da64125a2b6e83ka09f3e958c16ed00e85bfe798abd9845", // Replace with actual stream key
+};
+
+// Initiate the simulcast for an existing live stream
+const generateSimulcast = await fastpix.initiateLiveStreamSimulcast(
+  {
+    streamId: "a09f3e958c16ed00e85bfe798abd9845", // Replace with actual stream ID
+  },
+  simulcastPayload
+);
+
+console.log("Generate Simulcast:", generateSimulcast);
+```
+
+---
+
+# Method: getLiveStreamSimulcast()
+
+The `getLiveStreamSimulcast` method allows you to retrieve details of a specific simulcast for a live stream. To use this method, you need to provide both the `streamId` and the `simulcastId`.
+
+### Parameter Details:
+
+| **Parameter**            | **Description**                                                                                                  | **Type** | **Accepted Values**                   |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
+| `streamId` (required)    | The unique identifier assigned to the live stream. This ID is generated during the creation of the live stream.  | `String` | Any valid string (max 255 characters) |
+| `simulcastId` (required) | The unique identifier assigned to the simulcast stream. FastPix generates this ID when the simulcast is created. | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the streamId and simulcastId for the simulcast you want to retrieve
+const getLiveSimulcast = await fastpix.getLiveStreamSimulcast({
+  streamId: "a09f3e958c16ed00e85bfe798abd9845", // Replace with actual stream ID
+  simulcastId: "7269209ff0299319b6321c9a6e7850ff", // Replace with actual simulcast ID
+});
+
+console.log("Live Stream Simulcast Details:", getLiveSimulcast);
+```
+
+---
+
+# Method: updateLiveStreamSimulcast()
+
+The `updateLiveStreamSimulcast` method allows you to update the configuration of a simulcast stream for a live stream. To use this method, you need to provide the `streamId`, `simulcastId`, and specify the fields to be updated, including `isEnabled` and `metadata`.
+
+### Parameter Details:
+
+| **Parameter**            | **Description**                                                                                                                          | **Type**  | **Accepted Values**                                             |
+| ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------- | --------- | --------------------------------------------------------------- |
+| `streamId` (required)    | The unique identifier assigned to the live stream. This ID is generated during the creation of the live stream.                          | `String`  | Any valid string (max 255 characters)                           |
+| `simulcastId` (required) | The unique identifier assigned to the simulcast stream. FastPix generates this ID when the simulcast is created.                         | `String`  | Any valid string (max 255 characters)                           |
+| `isEnabled`              | Determines if the simulcast stream is enabled or disabled. Set to `false` to disable the simulcast.                                      | `Boolean` | `true` (enabled), `false` (disabled)                            |
+| `metadata`               | Arbitrary user-supplied metadata that will be included in the simulcast details. Max 255 characters per key and value, up to 10 entries. | `Object`  | Any valid key-value pair (max 255 characters per key and value) |
+
+### Example Request:
+
+```javascript
+// Assign streamId, simulcastId, and fields to variables
+const streamId = "a09f3e958c16ed00e85bfe798abd9845"; // Replace with actual stream ID
+const simulcastId = "7269209ff0299319b6321c9a6e7850ff"; // Replace with actual simulcast ID
+
+// Define the properties to be updated
+const updateProperties = {
+  isEnabled: false, // Disable the simulcast stream (set to true to enable)
+  metadata: {
+    simulcast2: "media", // Update the metadata as needed
+  },
+};
+
+// Call the updateLiveStreamSimulcast method with the defined variables
+const updateLiveSimulcast = await fastpix.updateLiveStreamSimulcast(
+  { streamId, simulcastId },
+  updateProperties
+);
+
+console.log("Updated Live Stream Simulcast:", updateLiveSimulcast);
+```
+
+---
+
+# Method: deleteLiveStreamSimulcast()
+
+The `deleteLiveStreamSimulcast` method allows you to delete a specific simulcast associated with a live stream. To remove a simulcast, you need to provide both the `streamId` and `simulcastId` that you want to delete.
+
+### Parameter Details:
+
+| **Parameter**            | **Description**                                                                                             | **Type** | **Accepted Values**                   |
+| ------------------------ | ----------------------------------------------------------------------------------------------------------- | -------- | ------------------------------------- |
+| `streamId` (required)    | The unique identifier assigned to the live stream. This ID is generated when the stream is created.         | `String` | Any valid string (max 255 characters) |
+| `simulcastId` (required) | The unique identifier assigned to the simulcast stream. This ID is generated when the simulcast is created. | `String` | Any valid string (max 255 characters) |
+
+### Example Request:
+
+```javascript
+// Assign streamId and simulcastId to variables
+const streamId = "a09f3e958c16ed00e85bfe798abd9845"; // Replace with actual stream ID
+const simulcastId = "7269209ff0299319b6321c9a6e7850ff"; // Replace with actual simulcast ID
+
+// Call the deleteLiveStreamSimulcast method with the defined variables
+const deleteLiveSimulcast = await fastpix.deleteLiveStreamSimulcast({
+  streamId,
+  simulcastId,
+});
+
+console.log("Deleted Live Stream Simulcast:", deleteLiveSimulcast);
+```

package/docs/VideoOnDemand/ManageMedia.md

@@ -0,0 +1,147 @@
+# Manage Media Methods
+
+To manage your media assets, you’ll need the `mediaId`, which is a unique identifier assigned to each media asset.
+
+---
+
+# Method: getAllMediaAssets()
+
+The `getAllMediaAssets` method allows you to fetch a list of all media assets. This method accepts three optional parameters: `limit`, `offset`, and `orderBy`. If not provided, the method will use the default values for these parameters.
+
+### Parameters Details:
+
+| **Parameter** | **Description**                                                                            | **Type** | **Default Value** | **Accepted Values**                         |
+| ------------- | ------------------------------------------------------------------------------------------ | -------- | ----------------- | ------------------------------------------- |
+| `limit`       | Specifies the maximum number of items to display per page.                                 | `Number` | `10`              | 1 to 50                                     |
+| `offset`      | Determines the starting point for data retrieval in a paginated list.                      | `Number` | `1`               | Any positive integer (e.g., `1`, `5`, `10`) |
+| `orderBy`     | Sorts the values in the list. The values can be arranged in descending or ascending order. | `String` | `desc`            | `"desc"`, `"asc"`                           |
+
+### Example Request:
+
+```javascript
+const mediaQueryParams = {
+  limit: 20, // Number of assets to fetch in one request (between 1 and 50)
+  offset: 5, // Pagination starting position
+  orderBy: "asc", // Sorting order of the assets ("asc" for ascending)
+};
+
+const mediaAssets = await fastpix.getAllMediaAssets(mediaQueryParams);
+console.log("Fetched Media Assets:", mediaAssets);
+```
+
+---
+
+# Method: getMediaAssetById()
+
+The `getMediaAssetById` method allows you to retrieve a specific media asset by its unique `mediaId`.
+
+### Parameters Details:
+
+| **Parameter**        | **Description**                                                                                | **Type** | **Required** | **Accepted Values**                |
+| -------------------- | ---------------------------------------------------------------------------------------------- | -------- | ------------ | ---------------------------------- |
+| `mediaId` (required) | The unique identifier assigned to the media asset. It can contain a maximum of 255 characters. | `String` | Yes          | Any valid string (up to 255 chars) |
+
+### Example Request:
+
+```javascript
+// Define the parameter for fetching a specific media asset by ID.
+const mediaQueryParams = {
+  mediaId: "media-id", // Unique identifier for the media asset to be retrieved
+};
+
+const getMediaAsset = await fastpix.getMediaAssetById(mediaQueryParams);
+console.log("Retrieved media asset by ID:", getMediaAsset);
+```
+
+---
+
+# Method: updateMediaAsset()
+
+The `updateMediaAsset` method lets you update a media asset's metadata by providing its `mediaId`.
+
+### Parameters Details:
+
+| **Parameter**         | **Description**                                                                                | **Type** | **Accepted Values**                |
+| --------------------- | ---------------------------------------------------------------------------------------------- | -------- | ---------------------------------- |
+| `mediaId` (required)  | The unique identifier assigned to the media asset. It can contain a maximum of 255 characters. | `String` | Any valid string (up to 255 chars) |
+| `metadata` (required) | Metadata key-value pairs to be updated for the media asset.                                    | `Object` | Key-value pairs (max 10 entries)   |
+
+### Metadata Object
+
+| **Parameter** | **Description**                                                | **Type** | **Accepted Values**                |
+| ------------- | -------------------------------------------------------------- | -------- | ---------------------------------- |
+| `key`         | A key for the metadata entry (max 255 characters).             | `String` | Any string (up to 255 characters). |
+| `value`       | The value for the specified metadata key (max 255 characters). | `String` | Any string (up to 255 characters). |
+
+You can add up to 10 metadata entries to the `metadata` object. Each entry is a key-value pair. This allows you to tag your media asset for easier identification or categorization.
+
+### Example Request:
+
+```javascript
+// Define the parameter for specifying the media asset to be updated.
+const mediaAssetToUpdate = {
+  mediaId: "media-id", // Unique identifier for the media asset to update.
+};
+
+// Define the payload with the updates to be applied to the media asset.
+const updatePayload = {
+  metadata: {
+    key: "value", // Replace "key" and "value" with actual metadata entries.
+    category: "nature", // Example of another metadata entry.
+  },
+};
+
+const updateMediaAsset = await fastpix.updateMediaAsset(
+  mediaAssetToUpdate,
+  updatePayload
+);
+console.log("Updated Media Asset:", updateMediaAsset);
+```
+
+---
+
+# Method: deleteMediaAsset()
+
+The `deleteMediaAsset` method deletes a media asset by its unique `mediaId`.
+
+### Parameters Details:
+
+| **Parameter**        | **Description**                                                                                | **Type** | **Accepted Values**                     |
+| -------------------- | ---------------------------------------------------------------------------------------------- | -------- | --------------------------------------- |
+| `mediaId` (required) | The unique identifier assigned to the media asset. It can contain a maximum of 255 characters. | `String` | Any valid string (up to 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the parameter for specifying the media asset to be deleted.
+const mediaAssetToDelete = {
+  mediaId: "media-id", // Unique identifier for the media asset to delete.
+};
+
+const deleteMediaAsset = await fastpix.deleteMediaAsset(mediaAssetToDelete);
+console.log("Deleted Media Asset:", deleteMediaAsset);
+```
+
+---
+
+# Method: getMediaAssetInfo()
+
+The `getMediaAssetInfo` method allows you to retrieve detailed information about the media inputs associated with a specific media asset. You can use this method to verify the media file’s input URL, track creation status, and container format. The `mediaId` must be provided to fetch the information.
+
+### Parameters Details:
+
+| **Parameter**        | **Description**                                                                                | **Type** | **Accepted Values**                     |
+| -------------------- | ---------------------------------------------------------------------------------------------- | -------- | --------------------------------------- |
+| `mediaId` (required) | The unique identifier assigned to the media asset. It can contain a maximum of 255 characters. | `String` | Any valid string (up to 255 characters) |
+
+### Example Request:
+
+```javascript
+// Define the parameter for specifying the media asset whose info is to be retrieved.
+const mediaInfoRequest = {
+  mediaId: "media-id", // Unique identifier for the media asset.
+};
+
+const getMediaInfo = await fastpix.getMediaAssetInfo(mediaInfoRequest);
+console.log("Media Asset Info:", getMediaInfo);
+```

package/docs/VideoOnDemand/ManageMediaPlayback.md

@@ -0,0 +1,61 @@
+# Method: generateMediaPlaybackId()
+
+The `generateMediaPlaybackId` method allows you to generate a playback ID for a specific media asset. You must provide the `mediaId` of the asset for which you want to generate the playback ID, and you can also configure options such as the `accessPolicy` to control the visibility of the media.
+
+### Parameters Details:
+
+| **Parameter**             | **Description**                                                                                                                             | **Type** | **Accepted Values**                     |
+| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | -------- | --------------------------------------- |
+| `mediaId` (required)      | The unique identifier assigned to the media asset. This is required to specify the media for which you want to generate a playback ID.      | `String` | Any valid string (up to 255 characters) |
+| `accessPolicy` (required) | Determines if access to the streamed content is kept private or available to all. This can be set to either `public` or `private` or `drm`. | `String` | `"public"`, `"private"`, `"drm"`        |
+
+### Example Request:
+
+```javascript
+// Define the mediaId and accessPolicy dynamically
+const mediaPlaybackRequest = {
+  mediaId: "media-id", // Unique identifier for the media asset.
+};
+
+const playbackOptions = {
+  accessPolicy: "public", // Can be 'public' or  'private' or 'drm'.
+};
+
+const playbackIdResponse = await fastpix.generateMediaPlaybackId(
+  mediaPlaybackRequest, // Pass the mediaId
+  playbackOptions // Pass the accessPolicy
+);
+
+console.log("Playback ID Creation Response:", playbackIdResponse);
+```
+
+---
+
+# Method: deleteMediaPlaybackId()
+
+The `deleteMediaPlaybackId` method allows you to delete one or more playback IDs for a media asset. This method allows you to specify both the `mediaId` and the `playbackId` you wish to delete and it supports deleting a **single playback ID** as a string or **multiple playback IDs** as an array of strings.
+
+### Parameters Details:
+
+| **Parameter**           | **Description**                                                                                      | **Type** | **Accepted Values**                     |
+| ----------------------- | ---------------------------------------------------------------------------------------------------- | -------- | --------------------------------------- |
+| `mediaId` (required)    | The unique identifier assigned to the media asset. It can contain a maximum of 255 characters.       | `String` | Any valid string (up to 255 characters) |
+| `playbackId` (required) | The unique identifiers for the playback IDs to be deleted.            | `Array` or `String`  | Array of valid strings (up to 255 characters each) or string |
+
+### Example Request:
+
+```javascript
+const mediaId = "media-id"; // The ID of the media asset for which you want to delete the playback ID.
+const playbackId = "playback-id"; // For deleting a single playback ID as a string.
+
+// Example for multiple playback IDs:
+// const playbackId = ["playback-id-1", "playback-id-2"]; // Pass an array of playback IDs to delete.
+
+// Use the deleteMediaPlaybackId method to delete the specified playback ID(s).
+const deletePlaybackResponse = await fastpix.deleteMediaPlaybackId({
+  mediaId: mediaId,     // Pass the mediaId for which playback ID(s) are to be deleted
+  playbackId: playbackId, // Pass the playbackId(s) to delete. 
+});
+
+console.log("Playback ID Deletion Response:", deletePlaybackResponse);
+```