@fastpix/fastpix-node 1.0.0

package/dist/index.cjs

@@ -0,0 +1,635 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_buffer = require("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 = import_buffer.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;

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import type { RequestObject, PaginationProps, UploadMediaFromUrlProps, DirectUploadRequest, MediaProps, AccessPolicy, LiveStreamProps, SimulcastObject, SimulcastProps, UpdateObject, InitiateLiveStreamProps, UpdateSimulcastProps } from "../types";
+import Media from "./VideoOnDemand";
+import LiveStream from "./Live";
+declare class Client {
+    accessTokenId: string;
+    secretKey: string;
+    mediaService: Media | null;
+    liveStream: LiveStream | null;
+    encodedAuthToken: string | undefined;
+    RequestObject: RequestObject;
+    constructor(props: {
+        accessTokenId: string;
+        secretKey: string;
+    });
+    validateSecrets(): void;
+    uploadMediaFromUrl(props: UploadMediaFromUrlProps): Promise<import("../types").FetchResponse> | null;
+    uploadMediaFromDevice(props: DirectUploadRequest): Promise<import("../types").FetchResponse> | null;
+    getAllMediaAssets(props?: PaginationProps): Promise<import("../types").FetchResponse> | null;
+    getMediaAssetById(props: MediaProps): Promise<import("../types").FetchResponse> | null;
+    getMediaAssetInfo(props: MediaProps): Promise<import("../types").FetchResponse> | null;
+    updateMediaAsset(props: MediaProps, updateObject: UpdateObject): Promise<import("../types").FetchResponse> | null;
+    deleteMediaAsset(props: MediaProps): Promise<import("../types").FetchResponse> | null;
+    generateMediaPlaybackId(props: MediaProps, accessPolicy: AccessPolicy): Promise<import("../types").FetchResponse> | null;
+    deleteMediaPlaybackId(props: MediaProps): Promise<import("../types").FetchResponse> | null;
+    initiateLiveStream(props: InitiateLiveStreamProps): Promise<import("../types").FetchResponse> | null;
+    getAllLiveStreams(props?: PaginationProps): Promise<import("../types").FetchResponse> | null;
+    getLiveStreamById(props: LiveStreamProps): Promise<import("../types").FetchResponse> | null;
+    updateLiveStream(props: LiveStreamProps, updateObject: any): Promise<import("../types").FetchResponse> | null;
+    deleteLiveStream(props: LiveStreamProps): Promise<import("../types").FetchResponse> | null;
+    generateLiveStreamPlaybackId(props: LiveStreamProps, accessPolicy: AccessPolicy): Promise<import("../types").FetchResponse> | null;
+    deleteLiveStreamPlaybackId(props: LiveStreamProps): Promise<import("../types").FetchResponse> | null;
+    getLiveStreamPlaybackPolicy(props: LiveStreamProps): Promise<import("../types").FetchResponse> | null;
+    initiateLiveStreamSimulcast(props: LiveStreamProps, liveStreamObj: SimulcastObject): Promise<import("../types").FetchResponse> | null;
+    getLiveStreamSimulcast(props: SimulcastProps): Promise<import("../types").FetchResponse> | null;
+    updateLiveStreamSimulcast(props: SimulcastProps, simulcastObj: UpdateSimulcastProps): Promise<import("../types").FetchResponse> | null;
+    deleteLiveStreamSimulcast(props: SimulcastProps): Promise<import("../types").FetchResponse> | null;
+}
+export default Client;