@fishjam-cloud/js-server-sdk 0.29.0-rc.2 → 0.29.0

package/dist/index.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -49,1052 +39,1541 @@ __export(index_exports, {
   UnauthorizedException: () => UnauthorizedException,
   UnknownException: () => UnknownException,
   VideoCodec: () => VideoCodec,
-  decodeServerNotifications: () => decodeServerNotifications
+  decodeServerNotifications: () => decodeServerNotifications,
+  verifyWebhookSignature: () => verifyWebhookSignature
 });
 module.exports = __toCommonJS(index_exports);
 
 // ../fishjam-openapi/dist/index.js
-var import_axios = __toESM(require("axios"), 1);
-var import_axios2 = __toESM(require("axios"), 1);
 var BASE_PATH = "https://fishjam.io/api/v1/connect".replace(/\/+$/, "");
-var BaseAPI = class {
-  constructor(configuration, basePath = BASE_PATH, axios2 = import_axios2.default) {
-    this.basePath = basePath;
-    this.axios = axios2;
-    if (configuration) {
-      this.configuration = configuration;
-      this.basePath = configuration.basePath ?? basePath;
+var Configuration = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+};
+var DefaultConfig = new Configuration();
+var BaseAPI = class _BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  static jsonRegex = /^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$/i;
+  middleware;
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return _BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = void 0;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : void 0
+          }) || response;
+        }
+      }
+      if (response === void 0) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+};
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError = class extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+  name = "ResponseError";
+};
+var FetchError = class extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+  name = "FetchError";
+};
+var RequiredError = class extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    }
+  }
+  name = "RequiredError";
+};
+function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+var JSONApiResponse = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+};
+var VoidApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return void 0;
+  }
+};
+var CredentialsApi = class extends BaseAPI {
+  /**
+   * Creates request options for validateCredentials without sending the request
+   */
+  async validateCredentialsRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/validate`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Returns 200 if the provided Fishjam Management Token is valid, 404 otherwise.
+   * Validate Fishjam Management Token
+   */
+  async validateCredentialsRaw(initOverrides) {
+    const requestOptions = await this.validateCredentialsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Returns 200 if the provided Fishjam Management Token is valid, 404 otherwise.
+   * Validate Fishjam Management Token
+   */
+  async validateCredentials(initOverrides) {
+    await this.validateCredentialsRaw(initOverrides);
+  }
+};
+function MoqAccessFromJSON(json) {
+  return MoqAccessFromJSONTyped(json, false);
+}
+function MoqAccessFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "connection_url": json["connection_url"],
+    "token": json["token"]
+  };
+}
+function MoqAccessConfigToJSON(json) {
+  return MoqAccessConfigToJSONTyped(json, false);
+}
+function MoqAccessConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "publishPath": value["publishPath"],
+    "subscribePath": value["subscribePath"]
+  };
+}
+var MoQApi = class extends BaseAPI {
+  /**
+   * Creates request options for createMoqAccess without sending the request
+   */
+  async createMoqAccessRequestOpts(requestParameters) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/moq/access`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: MoqAccessConfigToJSON(requestParameters["moqAccessConfig"])
+    };
+  }
+  /**
+   * Issue a short-lived JWT for a Media over QUIC client.
+   * Create MoQ access
+   */
+  async createMoqAccessRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createMoqAccessRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => MoqAccessFromJSON(jsonValue));
+  }
+  /**
+   * Issue a short-lived JWT for a Media over QUIC client.
+   * Create MoQ access
+   */
+  async createMoqAccess(requestParameters = {}, initOverrides) {
+    const response = await this.createMoqAccessRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+function AudioSampleRateToJSON(value) {
+  return value;
+}
+function AudioFormatToJSON(value) {
+  return value;
+}
+function AgentOutputToJSON(json) {
+  return AgentOutputToJSONTyped(json, false);
+}
+function AgentOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "audioFormat": AudioFormatToJSON(value["audioFormat"]),
+    "audioSampleRate": AudioSampleRateToJSON(value["audioSampleRate"])
+  };
+}
+function SubscribeModeFromJSON(json) {
+  return SubscribeModeFromJSONTyped(json, false);
+}
+function SubscribeModeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function SubscribeModeToJSON(value) {
+  return value;
+}
+function PeerOptionsAgentToJSON(json) {
+  return PeerOptionsAgentToJSONTyped(json, false);
+}
+function PeerOptionsAgentToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "output": AgentOutputToJSON(value["output"]),
+    "subscribeMode": SubscribeModeToJSON(value["subscribeMode"])
+  };
+}
+function PeerConfigAgentToJSON(json) {
+  return PeerConfigAgentToJSONTyped(json, false);
+}
+function PeerConfigAgentToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "options": PeerOptionsAgentToJSON(value["options"]),
+    "type": value["type"]
+  };
+}
+function PeerOptionsVapiToJSON(json) {
+  return PeerOptionsVapiToJSONTyped(json, false);
+}
+function PeerOptionsVapiToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "apiKey": value["apiKey"],
+    "callId": value["callId"],
+    "subscribeMode": SubscribeModeToJSON(value["subscribeMode"])
+  };
+}
+function PeerConfigVAPIToJSON(json) {
+  return PeerConfigVAPIToJSONTyped(json, false);
+}
+function PeerConfigVAPIToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "options": PeerOptionsVapiToJSON(value["options"]),
+    "type": value["type"]
+  };
+}
+function PeerOptionsWebRTCToJSON(json) {
+  return PeerOptionsWebRTCToJSONTyped(json, false);
+}
+function PeerOptionsWebRTCToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "metadata": value["metadata"],
+    "subscribeMode": SubscribeModeToJSON(value["subscribeMode"])
+  };
+}
+function PeerConfigWebRTCToJSON(json) {
+  return PeerConfigWebRTCToJSONTyped(json, false);
+}
+function PeerConfigWebRTCToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "options": PeerOptionsWebRTCToJSON(value["options"]),
+    "type": value["type"]
+  };
+}
+function PeerConfigToJSON(json) {
+  return PeerConfigToJSONTyped(json, false);
+}
+function PeerConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  switch (value["type"]) {
+    case "agent":
+      return Object.assign({}, PeerConfigAgentToJSON(value), { "type": "agent" });
+    case "vapi":
+      return Object.assign({}, PeerConfigVAPIToJSON(value), { "type": "vapi" });
+    case "webrtc":
+      return Object.assign({}, PeerConfigWebRTCToJSON(value), { "type": "webrtc" });
+    default:
+      return value;
+  }
+}
+function SubscriptionsFromJSON(json) {
+  return SubscriptionsFromJSONTyped(json, false);
+}
+function SubscriptionsFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "peers": json["peers"],
+    "tracks": json["tracks"]
+  };
+}
+var PeerStatus = {
+  Connected: "connected",
+  Disconnected: "disconnected"
+};
+function PeerStatusFromJSON(json) {
+  return PeerStatusFromJSONTyped(json, false);
+}
+function PeerStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function PeerTypeFromJSON(json) {
+  return PeerTypeFromJSONTyped(json, false);
+}
+function PeerTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function TrackTypeFromJSON(json) {
+  return TrackTypeFromJSONTyped(json, false);
+}
+function TrackTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function TrackFromJSON(json) {
+  return TrackFromJSONTyped(json, false);
+}
+function TrackFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "id": json["id"] == null ? void 0 : json["id"],
+    "metadata": json["metadata"] == null ? void 0 : json["metadata"],
+    "type": json["type"] == null ? void 0 : TrackTypeFromJSON(json["type"])
+  };
+}
+function PeerFromJSON(json) {
+  return PeerFromJSONTyped(json, false);
+}
+function PeerFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "id": json["id"],
+    "metadata": json["metadata"],
+    "status": PeerStatusFromJSON(json["status"]),
+    "subscribeMode": SubscribeModeFromJSON(json["subscribeMode"]),
+    "subscriptions": SubscriptionsFromJSON(json["subscriptions"]),
+    "tracks": json["tracks"].map(TrackFromJSON),
+    "type": PeerTypeFromJSON(json["type"])
+  };
+}
+function PeerDetailsResponseDataFromJSON(json) {
+  return PeerDetailsResponseDataFromJSONTyped(json, false);
+}
+function PeerDetailsResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "peer": PeerFromJSON(json["peer"]),
+    "peer_websocket_url": json["peer_websocket_url"] == null ? void 0 : json["peer_websocket_url"],
+    "token": json["token"]
+  };
+}
+function PeerDetailsResponseFromJSON(json) {
+  return PeerDetailsResponseFromJSONTyped(json, false);
+}
+function PeerDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": PeerDetailsResponseDataFromJSON(json["data"])
+  };
+}
+function PeerRefreshTokenResponseDataFromJSON(json) {
+  return PeerRefreshTokenResponseDataFromJSONTyped(json, false);
+}
+function PeerRefreshTokenResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "token": json["token"]
+  };
+}
+function PeerRefreshTokenResponseFromJSON(json) {
+  return PeerRefreshTokenResponseFromJSONTyped(json, false);
+}
+function PeerRefreshTokenResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": PeerRefreshTokenResponseDataFromJSON(json["data"])
+  };
+}
+var RoomType = {
+  FullFeature: "full_feature",
+  AudioOnly: "audio_only",
+  Broadcaster: "broadcaster",
+  Livestream: "livestream",
+  Conference: "conference",
+  AudioOnlyLivestream: "audio_only_livestream"
+};
+function RoomTypeFromJSON(json) {
+  return RoomTypeFromJSONTyped(json, false);
+}
+function RoomTypeFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function RoomTypeToJSON(value) {
+  return value;
+}
+var VideoCodec = {
+  H264: "h264",
+  Vp8: "vp8"
+};
+function VideoCodecFromJSON(json) {
+  return VideoCodecFromJSONTyped(json, false);
+}
+function VideoCodecFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function VideoCodecToJSON(value) {
+  return value;
+}
+function RoomConfigFromJSON(json) {
+  return RoomConfigFromJSONTyped(json, false);
+}
+function RoomConfigFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "batchWebhookNotifications": json["batchWebhookNotifications"] == null ? void 0 : json["batchWebhookNotifications"],
+    "maxPeers": json["maxPeers"] == null ? void 0 : json["maxPeers"],
+    "public": json["public"] == null ? void 0 : json["public"],
+    "roomType": json["roomType"] == null ? void 0 : RoomTypeFromJSON(json["roomType"]),
+    "videoCodec": json["videoCodec"] == null ? void 0 : VideoCodecFromJSON(json["videoCodec"]),
+    "webhookUrl": json["webhookUrl"] == null ? void 0 : json["webhookUrl"]
+  };
+}
+function RoomConfigToJSON(json) {
+  return RoomConfigToJSONTyped(json, false);
+}
+function RoomConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "batchWebhookNotifications": value["batchWebhookNotifications"],
+    "maxPeers": value["maxPeers"],
+    "public": value["public"],
+    "roomType": RoomTypeToJSON(value["roomType"]),
+    "videoCodec": VideoCodecToJSON(value["videoCodec"]),
+    "webhookUrl": value["webhookUrl"]
+  };
+}
+function TrackForwardingInfoFromJSON(json) {
+  return TrackForwardingInfoFromJSONTyped(json, false);
+}
+function TrackForwardingInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "audioTrackId": json["audioTrackId"] == null ? void 0 : json["audioTrackId"],
+    "inputId": json["inputId"],
+    "peerId": json["peerId"],
+    "videoTrackId": json["videoTrackId"] == null ? void 0 : json["videoTrackId"]
+  };
+}
+function CompositionInfoFromJSON(json) {
+  return CompositionInfoFromJSONTyped(json, false);
+}
+function CompositionInfoFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "compositionUrl": json["compositionUrl"],
+    "forwardings": json["forwardings"].map(TrackForwardingInfoFromJSON)
+  };
+}
+function RoomFromJSON(json) {
+  return RoomFromJSONTyped(json, false);
+}
+function RoomFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "compositionInfo": json["compositionInfo"] == null ? void 0 : CompositionInfoFromJSON(json["compositionInfo"]),
+    "config": RoomConfigFromJSON(json["config"]),
+    "id": json["id"],
+    "peers": json["peers"].map(PeerFromJSON)
+  };
+}
+function RoomCreateDetailsResponseDataFromJSON(json) {
+  return RoomCreateDetailsResponseDataFromJSONTyped(json, false);
+}
+function RoomCreateDetailsResponseDataFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "room": RoomFromJSON(json["room"])
+  };
+}
+function RoomCreateDetailsResponseFromJSON(json) {
+  return RoomCreateDetailsResponseFromJSONTyped(json, false);
+}
+function RoomCreateDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": RoomCreateDetailsResponseDataFromJSON(json["data"])
+  };
+}
+function RoomDetailsResponseFromJSON(json) {
+  return RoomDetailsResponseFromJSONTyped(json, false);
+}
+function RoomDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": RoomFromJSON(json["data"])
+  };
+}
+function RoomsListingResponseFromJSON(json) {
+  return RoomsListingResponseFromJSONTyped(json, false);
+}
+function RoomsListingResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": json["data"].map(RoomFromJSON)
+  };
+}
+function SubscribeTracksRequestToJSON(json) {
+  return SubscribeTracksRequestToJSONTyped(json, false);
+}
+function SubscribeTracksRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "track_ids": value["track_ids"]
+  };
+}
+var RoomsApi = class extends BaseAPI {
+  /**
+   * Creates request options for addPeer without sending the request
+   */
+  async addPeerRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling addPeer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}/peer`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: PeerConfigToJSON(requestParameters["peerConfig"])
+    };
+  }
+  /**
+   * Add a peer to a room and return its connection token.
+   * Create a peer
+   */
+  async addPeerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.addPeerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PeerDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Add a peer to a room and return its connection token.
+   * Create a peer
+   */
+  async addPeer(requestParameters, initOverrides) {
+    const response = await this.addPeerRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for createRoom without sending the request
+   */
+  async createRoomRequestOpts(requestParameters) {
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: RoomConfigToJSON(requestParameters["roomConfig"])
+    };
+  }
+  /**
+   * Create a new room with the given configuration.
+   * Create a room
+   */
+  async createRoomRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createRoomRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RoomCreateDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create a new room with the given configuration.
+   * Create a room
+   */
+  async createRoom(requestParameters = {}, initOverrides) {
+    const response = await this.createRoomRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for deletePeer without sending the request
+   */
+  async deletePeerRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling deletePeer().'
+      );
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling deletePeer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}/peer/{id}`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    urlPath = urlPath.replace("{id}", encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Remove a peer from a room and disconnect it.
+   * Delete a peer
+   */
+  async deletePeerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deletePeerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Remove a peer from a room and disconnect it.
+   * Delete a peer
+   */
+  async deletePeer(requestParameters, initOverrides) {
+    await this.deletePeerRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for deleteRoom without sending the request
+   */
+  async deleteRoomRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling deleteRoom().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Delete a room by id and disconnect all of its peers.
+   * Delete a room
+   */
+  async deleteRoomRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteRoomRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Delete a room by id and disconnect all of its peers.
+   * Delete a room
+   */
+  async deleteRoom(requestParameters, initOverrides) {
+    await this.deleteRoomRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for getAllRooms without sending the request
+   */
+  async getAllRoomsRequestOpts() {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List all rooms and livestreams.
+   * List all rooms
+   */
+  async getAllRoomsRaw(initOverrides) {
+    const requestOptions = await this.getAllRoomsRequestOpts();
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RoomsListingResponseFromJSON(jsonValue));
+  }
+  /**
+   * List all rooms and livestreams.
+   * List all rooms
+   */
+  async getAllRooms(initOverrides) {
+    const response = await this.getAllRoomsRaw(initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for getRoom without sending the request
+   */
+  async getRoomRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling getRoom().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get a room by id.
+   * Get a room
+   */
+  async getRoomRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getRoomRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RoomDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get a room by id.
+   * Get a room
+   */
+  async getRoom(requestParameters, initOverrides) {
+    const response = await this.getRoomRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for refreshToken without sending the request
+   */
+  async refreshTokenRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling refreshToken().'
+      );
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling refreshToken().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}/peer/{id}/refresh_token`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    urlPath = urlPath.replace("{id}", encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Issue a fresh connection token for an existing peer.
+   * Refresh a peer token
+   */
+  async refreshTokenRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.refreshTokenRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => PeerRefreshTokenResponseFromJSON(jsonValue));
+  }
+  /**
+   * Issue a fresh connection token for an existing peer.
+   * Refresh a peer token
+   */
+  async refreshToken(requestParameters, initOverrides) {
+    const response = await this.refreshTokenRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for subscribePeer without sending the request
+   */
+  async subscribePeerRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling subscribePeer().'
+      );
+    }
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling subscribePeer().'
+      );
+    }
+    const queryParameters = {};
+    if (requestParameters["peerId"] != null) {
+      queryParameters["peer_id"] = requestParameters["peerId"];
+    }
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
     }
+    let urlPath = `/room/{room_id}/peer/{id}/subscribe_peer`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    urlPath = urlPath.replace("{id}", encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
   }
-  configuration;
-};
-var RequiredError = class extends Error {
-  constructor(field, msg) {
-    super(msg);
-    this.field = field;
-    this.name = "RequiredError";
-  }
-};
-var operationServerMap = {};
-var DUMMY_BASE_URL = "https://example.com";
-var assertParamExists = function(functionName, paramName, paramValue) {
-  if (paramValue === null || paramValue === void 0) {
-    throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+  /**
+   * Subscribe a peer to all current and future tracks published by another peer in the same room.
+   * Subscribe a peer to another peer\'s tracks
+   */
+  async subscribePeerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.subscribePeerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
   }
-};
-var setBearerAuthToObject = async function(object, configuration) {
-  if (configuration && configuration.accessToken) {
-    const accessToken = typeof configuration.accessToken === "function" ? await configuration.accessToken() : await configuration.accessToken;
-    object["Authorization"] = "Bearer " + accessToken;
+  /**
+   * Subscribe a peer to all current and future tracks published by another peer in the same room.
+   * Subscribe a peer to another peer\'s tracks
+   */
+  async subscribePeer(requestParameters, initOverrides) {
+    await this.subscribePeerRaw(requestParameters, initOverrides);
   }
-};
-function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
-  if (parameter == null) return;
-  if (typeof parameter === "object") {
-    if (Array.isArray(parameter)) {
-      parameter.forEach((item) => setFlattenedQueryParams(urlSearchParams, item, key));
-    } else {
-      Object.keys(parameter).forEach(
-        (currentKey) => setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== "" ? "." : ""}${currentKey}`)
+  /**
+   * Creates request options for subscribeTracks without sending the request
+   */
+  async subscribeTracksRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling subscribeTracks().'
       );
     }
-  } else {
-    if (urlSearchParams.has(key)) {
-      urlSearchParams.append(key, parameter);
-    } else {
-      urlSearchParams.set(key, parameter);
+    if (requestParameters["id"] == null) {
+      throw new RequiredError(
+        "id",
+        'Required parameter "id" was null or undefined when calling subscribeTracks().'
+      );
     }
-  }
-}
-var setSearchParams = function(url, ...objects) {
-  const searchParams = new URLSearchParams(url.search);
-  setFlattenedQueryParams(searchParams, objects);
-  url.search = searchParams.toString();
-};
-var serializeDataIfNeeded = function(value, requestOptions, configuration) {
-  const nonString = typeof value !== "string";
-  const needsSerialization = nonString && configuration && configuration.isJsonMime ? configuration.isJsonMime(requestOptions.headers["Content-Type"]) : nonString;
-  return needsSerialization ? JSON.stringify(value !== void 0 ? value : {}) : value || "";
-};
-var toPathString = function(url) {
-  return url.pathname + url.search + url.hash;
-};
-var createRequestFunction = function(axiosArgs, globalAxios3, BASE_PATH2, configuration) {
-  return (axios2 = globalAxios3, basePath = BASE_PATH2) => {
-    const axiosRequestArgs = { ...axiosArgs.options, url: (axios2.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
-    return axios2.request(axiosRequestArgs);
-  };
-};
-var PeerStatus = {
-  Connected: "connected",
-  Disconnected: "disconnected"
-};
-var RoomType = {
-  FullFeature: "full_feature",
-  AudioOnly: "audio_only",
-  Broadcaster: "broadcaster",
-  Livestream: "livestream",
-  Conference: "conference",
-  AudioOnlyLivestream: "audio_only_livestream"
-};
-var VideoCodec = {
-  H264: "h264",
-  Vp8: "vp8"
-};
-var CredentialsApiAxiosParamCreator = function(configuration) {
-  return {
-    /**
-     * Returns 200 if the provided Fishjam Management Token is valid, 404 otherwise.
-     * @summary Validate Fishjam Management Token
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    validateCredentials: async (options = {}) => {
-      const localVarPath = `/validate`;
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
       }
-      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
     }
-  };
-};
-var CredentialsApiFp = function(configuration) {
-  const localVarAxiosParamCreator = CredentialsApiAxiosParamCreator(configuration);
-  return {
-    /**
-     * Returns 200 if the provided Fishjam Management Token is valid, 404 otherwise.
-     * @summary Validate Fishjam Management Token
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async validateCredentials(options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.validateCredentials(options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["CredentialsApi.validateCredentials"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    }
-  };
-};
-var CredentialsApi = class extends BaseAPI {
+    let urlPath = `/room/{room_id}/peer/{id}/subscribe_tracks`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    urlPath = urlPath.replace("{id}", encodeURIComponent(String(requestParameters["id"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: SubscribeTracksRequestToJSON(requestParameters["subscribeTracksRequest"])
+    };
+  }
   /**
-   * Returns 200 if the provided Fishjam Management Token is valid, 404 otherwise.
-   * @summary Validate Fishjam Management Token
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof CredentialsApi
+   * Subscribe a peer to a specific list of track IDs in the same room.
+   * Subscribe a peer to specific tracks
    */
-  validateCredentials(options) {
-    return CredentialsApiFp(this.configuration).validateCredentials(options).then((request) => request(this.axios, this.basePath));
+  async subscribeTracksRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.subscribeTracksRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
   }
-};
-var MoQApiAxiosParamCreator = function(configuration) {
-  return {
-    /**
-     * Issue a short-lived JWT for a Media over QUIC client.
-     * @summary Create MoQ access
-     * @param {MoqAccessConfig} [moqAccessConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    createMoqAccess: async (moqAccessConfig, options = {}) => {
-      const localVarPath = `/moq/access`;
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      localVarHeaderParameter["Content-Type"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(moqAccessConfig, localVarRequestOptions, configuration);
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    }
-  };
-};
-var MoQApiFp = function(configuration) {
-  const localVarAxiosParamCreator = MoQApiAxiosParamCreator(configuration);
-  return {
-    /**
-     * Issue a short-lived JWT for a Media over QUIC client.
-     * @summary Create MoQ access
-     * @param {MoqAccessConfig} [moqAccessConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async createMoqAccess(moqAccessConfig, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.createMoqAccess(moqAccessConfig, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["MoQApi.createMoqAccess"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    }
-  };
-};
-var MoQApi = class extends BaseAPI {
   /**
-   * Issue a short-lived JWT for a Media over QUIC client.
-   * @summary Create MoQ access
-   * @param {MoqAccessConfig} [moqAccessConfig] 
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof MoQApi
+   * Subscribe a peer to a specific list of track IDs in the same room.
+   * Subscribe a peer to specific tracks
    */
-  createMoqAccess(moqAccessConfig, options) {
-    return MoQApiFp(this.configuration).createMoqAccess(moqAccessConfig, options).then((request) => request(this.axios, this.basePath));
+  async subscribeTracks(requestParameters, initOverrides) {
+    await this.subscribeTracksRaw(requestParameters, initOverrides);
   }
 };
-var RoomsApiAxiosParamCreator = function(configuration) {
+function StreamerFromJSON(json) {
+  return StreamerFromJSONTyped(json, false);
+}
+function StreamerFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
   return {
-    /**
-     * Add a peer to a room and return its connection token.
-     * @summary Create a peer
-     * @param {string} roomId Room id
-     * @param {PeerConfig} [peerConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    addPeer: async (roomId, peerConfig, options = {}) => {
-      assertParamExists("addPeer", "roomId", roomId);
-      const localVarPath = `/room/{room_id}/peer`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      localVarHeaderParameter["Content-Type"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(peerConfig, localVarRequestOptions, configuration);
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Create a new room with the given configuration.
-     * @summary Create a room
-     * @param {RoomConfig} [roomConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    createRoom: async (roomConfig, options = {}) => {
-      const localVarPath = `/room`;
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      localVarHeaderParameter["Content-Type"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(roomConfig, localVarRequestOptions, configuration);
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Remove a peer from a room and disconnect it.
-     * @summary Delete a peer
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    deletePeer: async (roomId, id, options = {}) => {
-      assertParamExists("deletePeer", "roomId", roomId);
-      assertParamExists("deletePeer", "id", id);
-      const localVarPath = `/room/{room_id}/peer/{id}`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId))).replace(`{${"id"}}`, encodeURIComponent(String(id)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Delete a room by id and disconnect all of its peers.
-     * @summary Delete a room
-     * @param {string} roomId Room id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    deleteRoom: async (roomId, options = {}) => {
-      assertParamExists("deleteRoom", "roomId", roomId);
-      const localVarPath = `/room/{room_id}`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * List all rooms and livestreams.
-     * @summary List all rooms
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    getAllRooms: async (options = {}) => {
-      const localVarPath = `/room`;
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Get a room by id.
-     * @summary Get a room
-     * @param {string} roomId Room ID
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    getRoom: async (roomId, options = {}) => {
-      assertParamExists("getRoom", "roomId", roomId);
-      const localVarPath = `/room/{room_id}`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Issue a fresh connection token for an existing peer.
-     * @summary Refresh a peer token
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    refreshToken: async (roomId, id, options = {}) => {
-      assertParamExists("refreshToken", "roomId", roomId);
-      assertParamExists("refreshToken", "id", id);
-      const localVarPath = `/room/{room_id}/peer/{id}/refresh_token`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId))).replace(`{${"id"}}`, encodeURIComponent(String(id)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Subscribe a peer to all current and future tracks published by another peer in the same room.
-     * @summary Subscribe a peer to another peer\'s tracks
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {string} [peerId] ID of the peer that produces the track
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    subscribePeer: async (roomId, id, peerId, options = {}) => {
-      assertParamExists("subscribePeer", "roomId", roomId);
-      assertParamExists("subscribePeer", "id", id);
-      const localVarPath = `/room/{room_id}/peer/{id}/subscribe_peer`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId))).replace(`{${"id"}}`, encodeURIComponent(String(id)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      if (peerId !== void 0) {
-        localVarQueryParameter["peer_id"] = peerId;
-      }
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Subscribe a peer to a specific list of track IDs in the same room.
-     * @summary Subscribe a peer to specific tracks
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {SubscribeTracksRequest} [subscribeTracksRequest] Track IDs
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    subscribeTracks: async (roomId, id, subscribeTracksRequest, options = {}) => {
-      assertParamExists("subscribeTracks", "roomId", roomId);
-      assertParamExists("subscribeTracks", "id", id);
-      const localVarPath = `/room/{room_id}/peer/{id}/subscribe_tracks`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId))).replace(`{${"id"}}`, encodeURIComponent(String(id)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      localVarHeaderParameter["Content-Type"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      localVarRequestOptions.data = serializeDataIfNeeded(subscribeTracksRequest, localVarRequestOptions, configuration);
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    }
+    "id": json["id"],
+    "status": json["status"],
+    "token": json["token"]
   };
-};
-var RoomsApiFp = function(configuration) {
-  const localVarAxiosParamCreator = RoomsApiAxiosParamCreator(configuration);
+}
+function StreamerDetailsResponseFromJSON(json) {
+  return StreamerDetailsResponseFromJSONTyped(json, false);
+}
+function StreamerDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
   return {
-    /**
-     * Add a peer to a room and return its connection token.
-     * @summary Create a peer
-     * @param {string} roomId Room id
-     * @param {PeerConfig} [peerConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async addPeer(roomId, peerConfig, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.addPeer(roomId, peerConfig, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.addPeer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Create a new room with the given configuration.
-     * @summary Create a room
-     * @param {RoomConfig} [roomConfig] 
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async createRoom(roomConfig, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.createRoom(roomConfig, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.createRoom"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Remove a peer from a room and disconnect it.
-     * @summary Delete a peer
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async deletePeer(roomId, id, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.deletePeer(roomId, id, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.deletePeer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Delete a room by id and disconnect all of its peers.
-     * @summary Delete a room
-     * @param {string} roomId Room id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async deleteRoom(roomId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.deleteRoom(roomId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.deleteRoom"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * List all rooms and livestreams.
-     * @summary List all rooms
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async getAllRooms(options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.getAllRooms(options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.getAllRooms"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Get a room by id.
-     * @summary Get a room
-     * @param {string} roomId Room ID
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async getRoom(roomId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.getRoom(roomId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.getRoom"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Issue a fresh connection token for an existing peer.
-     * @summary Refresh a peer token
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async refreshToken(roomId, id, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.refreshToken(roomId, id, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.refreshToken"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Subscribe a peer to all current and future tracks published by another peer in the same room.
-     * @summary Subscribe a peer to another peer\'s tracks
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {string} [peerId] ID of the peer that produces the track
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async subscribePeer(roomId, id, peerId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.subscribePeer(roomId, id, peerId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.subscribePeer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Subscribe a peer to a specific list of track IDs in the same room.
-     * @summary Subscribe a peer to specific tracks
-     * @param {string} roomId Room id
-     * @param {string} id Peer id
-     * @param {SubscribeTracksRequest} [subscribeTracksRequest] Track IDs
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async subscribeTracks(roomId, id, subscribeTracksRequest, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.subscribeTracks(roomId, id, subscribeTracksRequest, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["RoomsApi.subscribeTracks"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    }
+    "data": StreamerFromJSON(json["data"])
   };
-};
-var RoomsApi = class extends BaseAPI {
+}
+function StreamerTokenFromJSON(json) {
+  return StreamerTokenFromJSONTyped(json, false);
+}
+function StreamerTokenFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "token": json["token"]
+  };
+}
+var StreamersApi = class extends BaseAPI {
   /**
-   * Add a peer to a room and return its connection token.
-   * @summary Create a peer
-   * @param {string} roomId Room id
-   * @param {PeerConfig} [peerConfig] 
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Creates request options for createStreamer without sending the request
    */
-  addPeer(roomId, peerConfig, options) {
-    return RoomsApiFp(this.configuration).addPeer(roomId, peerConfig, options).then((request) => request(this.axios, this.basePath));
+  async createStreamerRequestOpts(requestParameters) {
+    if (requestParameters["streamId"] == null) {
+      throw new RequiredError(
+        "streamId",
+        'Required parameter "streamId" was null or undefined when calling createStreamer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/livestream/{stream_id}/streamer`;
+    urlPath = urlPath.replace("{stream_id}", encodeURIComponent(String(requestParameters["streamId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
   }
   /**
-   * Create a new room with the given configuration.
-   * @summary Create a room
-   * @param {RoomConfig} [roomConfig] 
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Create a streamer for a stream and return its credentials.
+   * Create a streamer
    */
-  createRoom(roomConfig, options) {
-    return RoomsApiFp(this.configuration).createRoom(roomConfig, options).then((request) => request(this.axios, this.basePath));
+  async createStreamerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createStreamerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => StreamerDetailsResponseFromJSON(jsonValue));
   }
   /**
-   * Remove a peer from a room and disconnect it.
-   * @summary Delete a peer
-   * @param {string} roomId Room id
-   * @param {string} id Peer id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Create a streamer for a stream and return its credentials.
+   * Create a streamer
    */
-  deletePeer(roomId, id, options) {
-    return RoomsApiFp(this.configuration).deletePeer(roomId, id, options).then((request) => request(this.axios, this.basePath));
+  async createStreamer(requestParameters, initOverrides) {
+    const response = await this.createStreamerRaw(requestParameters, initOverrides);
+    return await response.value();
   }
   /**
-   * Delete a room by id and disconnect all of its peers.
-   * @summary Delete a room
-   * @param {string} roomId Room id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Creates request options for deleteStreamer without sending the request
    */
-  deleteRoom(roomId, options) {
-    return RoomsApiFp(this.configuration).deleteRoom(roomId, options).then((request) => request(this.axios, this.basePath));
+  async deleteStreamerRequestOpts(requestParameters) {
+    if (requestParameters["streamId"] == null) {
+      throw new RequiredError(
+        "streamId",
+        'Required parameter "streamId" was null or undefined when calling deleteStreamer().'
+      );
+    }
+    if (requestParameters["streamerId"] == null) {
+      throw new RequiredError(
+        "streamerId",
+        'Required parameter "streamerId" was null or undefined when calling deleteStreamer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/livestream/{stream_id}/streamer/{streamer_id}`;
+    urlPath = urlPath.replace("{stream_id}", encodeURIComponent(String(requestParameters["streamId"])));
+    urlPath = urlPath.replace("{streamer_id}", encodeURIComponent(String(requestParameters["streamerId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
   }
   /**
-   * List all rooms and livestreams.
-   * @summary List all rooms
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Delete a streamer from a stream and revoke its token.
+   * Delete a streamer
    */
-  getAllRooms(options) {
-    return RoomsApiFp(this.configuration).getAllRooms(options).then((request) => request(this.axios, this.basePath));
+  async deleteStreamerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteStreamerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
   }
   /**
-   * Get a room by id.
-   * @summary Get a room
-   * @param {string} roomId Room ID
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Delete a streamer from a stream and revoke its token.
+   * Delete a streamer
    */
-  getRoom(roomId, options) {
-    return RoomsApiFp(this.configuration).getRoom(roomId, options).then((request) => request(this.axios, this.basePath));
+  async deleteStreamer(requestParameters, initOverrides) {
+    await this.deleteStreamerRaw(requestParameters, initOverrides);
   }
   /**
-   * Issue a fresh connection token for an existing peer.
-   * @summary Refresh a peer token
-   * @param {string} roomId Room id
-   * @param {string} id Peer id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Creates request options for generateStreamerToken without sending the request
    */
-  refreshToken(roomId, id, options) {
-    return RoomsApiFp(this.configuration).refreshToken(roomId, id, options).then((request) => request(this.axios, this.basePath));
+  async generateStreamerTokenRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling generateStreamerToken().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}/streamer`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
   }
   /**
-   * Subscribe a peer to all current and future tracks published by another peer in the same room.
-   * @summary Subscribe a peer to another peer\'s tracks
-   * @param {string} roomId Room id
-   * @param {string} id Peer id
-   * @param {string} [peerId] ID of the peer that produces the track
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Issue a fresh streamer token.
+   * Create a streamer token
    */
-  subscribePeer(roomId, id, peerId, options) {
-    return RoomsApiFp(this.configuration).subscribePeer(roomId, id, peerId, options).then((request) => request(this.axios, this.basePath));
+  async generateStreamerTokenRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.generateStreamerTokenRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => StreamerTokenFromJSON(jsonValue));
   }
   /**
-   * Subscribe a peer to a specific list of track IDs in the same room.
-   * @summary Subscribe a peer to specific tracks
-   * @param {string} roomId Room id
-   * @param {string} id Peer id
-   * @param {SubscribeTracksRequest} [subscribeTracksRequest] Track IDs
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof RoomsApi
+   * Issue a fresh streamer token.
+   * Create a streamer token
    */
-  subscribeTracks(roomId, id, subscribeTracksRequest, options) {
-    return RoomsApiFp(this.configuration).subscribeTracks(roomId, id, subscribeTracksRequest, options).then((request) => request(this.axios, this.basePath));
+  async generateStreamerToken(requestParameters, initOverrides) {
+    const response = await this.generateStreamerTokenRaw(requestParameters, initOverrides);
+    return await response.value();
   }
 };
-var StreamersApiAxiosParamCreator = function(configuration) {
+function ViewerFromJSON(json) {
+  return ViewerFromJSONTyped(json, false);
+}
+function ViewerFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
   return {
-    /**
-     * Create a streamer for a stream and return its credentials.
-     * @summary Create a streamer
-     * @param {string} streamId Stream id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    createStreamer: async (streamId, options = {}) => {
-      assertParamExists("createStreamer", "streamId", streamId);
-      const localVarPath = `/livestream/{stream_id}/streamer`.replace(`{${"stream_id"}}`, encodeURIComponent(String(streamId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Delete a streamer from a stream and revoke its token.
-     * @summary Delete a streamer
-     * @param {string} streamId Stream id
-     * @param {string} streamerId Streamer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    deleteStreamer: async (streamId, streamerId, options = {}) => {
-      assertParamExists("deleteStreamer", "streamId", streamId);
-      assertParamExists("deleteStreamer", "streamerId", streamerId);
-      const localVarPath = `/livestream/{stream_id}/streamer/{streamer_id}`.replace(`{${"stream_id"}}`, encodeURIComponent(String(streamId))).replace(`{${"streamer_id"}}`, encodeURIComponent(String(streamerId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Issue a fresh streamer token.
-     * @summary Create a streamer token
-     * @param {string} roomId ID of the stream.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    generateStreamerToken: async (roomId, options = {}) => {
-      assertParamExists("generateStreamerToken", "roomId", roomId);
-      const localVarPath = `/room/{room_id}/streamer`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    }
+    "id": json["id"],
+    "token": json["token"]
   };
-};
-var StreamersApiFp = function(configuration) {
-  const localVarAxiosParamCreator = StreamersApiAxiosParamCreator(configuration);
+}
+function ViewerDetailsResponseFromJSON(json) {
+  return ViewerDetailsResponseFromJSONTyped(json, false);
+}
+function ViewerDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
   return {
-    /**
-     * Create a streamer for a stream and return its credentials.
-     * @summary Create a streamer
-     * @param {string} streamId Stream id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async createStreamer(streamId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.createStreamer(streamId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["StreamersApi.createStreamer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Delete a streamer from a stream and revoke its token.
-     * @summary Delete a streamer
-     * @param {string} streamId Stream id
-     * @param {string} streamerId Streamer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async deleteStreamer(streamId, streamerId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.deleteStreamer(streamId, streamerId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["StreamersApi.deleteStreamer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Issue a fresh streamer token.
-     * @summary Create a streamer token
-     * @param {string} roomId ID of the stream.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async generateStreamerToken(roomId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.generateStreamerToken(roomId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["StreamersApi.generateStreamerToken"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    }
+    "data": ViewerFromJSON(json["data"])
   };
-};
-var StreamersApi = class extends BaseAPI {
+}
+function ViewerTokenFromJSON(json) {
+  return ViewerTokenFromJSONTyped(json, false);
+}
+function ViewerTokenFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "token": json["token"]
+  };
+}
+var ViewersApi = class extends BaseAPI {
   /**
-   * Create a streamer for a stream and return its credentials.
-   * @summary Create a streamer
-   * @param {string} streamId Stream id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof StreamersApi
+   * Creates request options for createViewer without sending the request
    */
-  createStreamer(streamId, options) {
-    return StreamersApiFp(this.configuration).createStreamer(streamId, options).then((request) => request(this.axios, this.basePath));
+  async createViewerRequestOpts(requestParameters) {
+    if (requestParameters["streamId"] == null) {
+      throw new RequiredError(
+        "streamId",
+        'Required parameter "streamId" was null or undefined when calling createViewer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/livestream/{stream_id}/viewer`;
+    urlPath = urlPath.replace("{stream_id}", encodeURIComponent(String(requestParameters["streamId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
   }
   /**
-   * Delete a streamer from a stream and revoke its token.
-   * @summary Delete a streamer
-   * @param {string} streamId Stream id
-   * @param {string} streamerId Streamer id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof StreamersApi
+   * Create a viewer for a stream and return its credentials.
+   * Create a viewer
    */
-  deleteStreamer(streamId, streamerId, options) {
-    return StreamersApiFp(this.configuration).deleteStreamer(streamId, streamerId, options).then((request) => request(this.axios, this.basePath));
+  async createViewerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createViewerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ViewerDetailsResponseFromJSON(jsonValue));
   }
   /**
-   * Issue a fresh streamer token.
-   * @summary Create a streamer token
-   * @param {string} roomId ID of the stream.
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof StreamersApi
+   * Create a viewer for a stream and return its credentials.
+   * Create a viewer
    */
-  generateStreamerToken(roomId, options) {
-    return StreamersApiFp(this.configuration).generateStreamerToken(roomId, options).then((request) => request(this.axios, this.basePath));
+  async createViewer(requestParameters, initOverrides) {
+    const response = await this.createViewerRaw(requestParameters, initOverrides);
+    return await response.value();
   }
-};
-var ViewersApiAxiosParamCreator = function(configuration) {
-  return {
-    /**
-     * Create a viewer for a stream and return its credentials.
-     * @summary Create a viewer
-     * @param {string} streamId Stream id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    createViewer: async (streamId, options = {}) => {
-      assertParamExists("createViewer", "streamId", streamId);
-      const localVarPath = `/livestream/{stream_id}/viewer`.replace(`{${"stream_id"}}`, encodeURIComponent(String(streamId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Delete a viewer from a stream and revoke its token.
-     * @summary Delete a viewer
-     * @param {string} streamId Stream id
-     * @param {string} viewerId Viewer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    deleteViewer: async (streamId, viewerId, options = {}) => {
-      assertParamExists("deleteViewer", "streamId", streamId);
-      assertParamExists("deleteViewer", "viewerId", viewerId);
-      const localVarPath = `/livestream/{stream_id}/viewer/{viewer_id}`.replace(`{${"stream_id"}}`, encodeURIComponent(String(streamId))).replace(`{${"viewer_id"}}`, encodeURIComponent(String(viewerId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "DELETE", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    /**
-     * Issue a fresh viewer token.
-     * @summary Create a viewer token
-     * @param {string} roomId ID of the stream.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    generateViewerToken: async (roomId, options = {}) => {
-      assertParamExists("generateViewerToken", "roomId", roomId);
-      const localVarPath = `/room/{room_id}/viewer`.replace(`{${"room_id"}}`, encodeURIComponent(String(roomId)));
-      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setBearerAuthToObject(localVarHeaderParameter, configuration);
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
+  /**
+   * Creates request options for deleteViewer without sending the request
+   */
+  async deleteViewerRequestOpts(requestParameters) {
+    if (requestParameters["streamId"] == null) {
+      throw new RequiredError(
+        "streamId",
+        'Required parameter "streamId" was null or undefined when calling deleteViewer().'
+      );
     }
-  };
-};
-var ViewersApiFp = function(configuration) {
-  const localVarAxiosParamCreator = ViewersApiAxiosParamCreator(configuration);
-  return {
-    /**
-     * Create a viewer for a stream and return its credentials.
-     * @summary Create a viewer
-     * @param {string} streamId Stream id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async createViewer(streamId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.createViewer(streamId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["ViewersApi.createViewer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Delete a viewer from a stream and revoke its token.
-     * @summary Delete a viewer
-     * @param {string} streamId Stream id
-     * @param {string} viewerId Viewer id
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async deleteViewer(streamId, viewerId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.deleteViewer(streamId, viewerId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["ViewersApi.deleteViewer"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    /**
-     * Issue a fresh viewer token.
-     * @summary Create a viewer token
-     * @param {string} roomId ID of the stream.
-     * @param {*} [options] Override http request option.
-     * @throws {RequiredError}
-     */
-    async generateViewerToken(roomId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.generateViewerToken(roomId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["ViewersApi.generateViewerToken"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, import_axios.default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    if (requestParameters["viewerId"] == null) {
+      throw new RequiredError(
+        "viewerId",
+        'Required parameter "viewerId" was null or undefined when calling deleteViewer().'
+      );
     }
-  };
-};
-var ViewersApi = class extends BaseAPI {
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/livestream/{stream_id}/viewer/{viewer_id}`;
+    urlPath = urlPath.replace("{stream_id}", encodeURIComponent(String(requestParameters["streamId"])));
+    urlPath = urlPath.replace("{viewer_id}", encodeURIComponent(String(requestParameters["viewerId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
   /**
-   * Create a viewer for a stream and return its credentials.
-   * @summary Create a viewer
-   * @param {string} streamId Stream id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof ViewersApi
+   * Delete a viewer from a stream and revoke its token.
+   * Delete a viewer
    */
-  createViewer(streamId, options) {
-    return ViewersApiFp(this.configuration).createViewer(streamId, options).then((request) => request(this.axios, this.basePath));
+  async deleteViewerRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteViewerRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
   }
   /**
    * Delete a viewer from a stream and revoke its token.
-   * @summary Delete a viewer
-   * @param {string} streamId Stream id
-   * @param {string} viewerId Viewer id
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof ViewersApi
+   * Delete a viewer
+   */
+  async deleteViewer(requestParameters, initOverrides) {
+    await this.deleteViewerRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for generateViewerToken without sending the request
+   */
+  async generateViewerTokenRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling generateViewerToken().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("management_token", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/room/{room_id}/viewer`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Issue a fresh viewer token.
+   * Create a viewer token
    */
-  deleteViewer(streamId, viewerId, options) {
-    return ViewersApiFp(this.configuration).deleteViewer(streamId, viewerId, options).then((request) => request(this.axios, this.basePath));
+  async generateViewerTokenRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.generateViewerTokenRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => ViewerTokenFromJSON(jsonValue));
   }
   /**
    * Issue a fresh viewer token.
-   * @summary Create a viewer token
-   * @param {string} roomId ID of the stream.
-   * @param {*} [options] Override http request option.
-   * @throws {RequiredError}
-   * @memberof ViewersApi
+   * Create a viewer token
    */
-  generateViewerToken(roomId, options) {
-    return ViewersApiFp(this.configuration).generateViewerToken(roomId, options).then((request) => request(this.axios, this.basePath));
+  async generateViewerToken(requestParameters, initOverrides) {
+    const response = await this.generateViewerTokenRaw(requestParameters, initOverrides);
+    return await response.value();
   }
 };
 
@@ -5864,13 +6343,11 @@ var MissingFishjamIdException = class extends Error {
 };
 var FishjamBaseException = class extends Error {
   statusCode;
-  axiosCode;
   details;
-  constructor(error) {
-    super(error.message);
-    this.statusCode = error.response?.status ?? 500;
-    this.axiosCode = error.code;
-    this.details = error.response?.data["detail"] ?? error.response?.data["errors"] ?? "Unknown error";
+  constructor(info) {
+    super(info.message);
+    this.statusCode = info.statusCode ?? 500;
+    this.details = info.details;
   }
 };
 var BadRequestException = class extends FishjamBaseException {
@@ -5908,6 +6385,16 @@ var getFishjamUrl = (config) => {
     return `https://fishjam.io/api/v1/connect/${config.fishjamId}`;
   }
 };
+var AGENT_SOCKET_PATH = "/socket/agent/websocket";
+var getAgentWebsocketUrl = (config, peerWebsocketUrl) => {
+  if (peerWebsocketUrl) {
+    const url = new URL(peerWebsocketUrl.includes("://") ? peerWebsocketUrl : `https://${peerWebsocketUrl}`);
+    url.protocol = url.protocol.replace("http", "ws");
+    url.pathname = url.pathname.replace(/\/socket\/peer\/websocket$/, AGENT_SOCKET_PATH);
+    return url.href;
+  }
+  return `${httpToWebsocket(getFishjamUrl(config))}${AGENT_SOCKET_PATH}`;
+};
 
 // src/notifications.ts
 var peerTypeMap = {
@@ -6035,7 +6522,14 @@ var FishjamWSNotifier = class extends import_events.EventEmitter {
 };
 
 // src/webhook.ts
+var import_node_crypto = require("crypto");
 var decodeServerNotifications = (data) => extractNotifications(ServerMessage.decode(data instanceof Uint8Array ? data : new Uint8Array(data)));
+var verifyWebhookSignature = (body, signature, secret) => {
+  const expected = (0, import_node_crypto.createHmac)("sha256", secret).update(body instanceof Uint8Array ? body : new Uint8Array(body)).digest("hex");
+  const provided = Buffer.from(signature.trim().replace(/^sha256=/, ""), "utf8");
+  const wanted = Buffer.from(expected, "utf8");
+  return provided.length === wanted.length && (0, import_node_crypto.timingSafeEqual)(provided, wanted);
+};
 
 // src/agent.ts
 var import_events2 = require("events");
@@ -6044,23 +6538,32 @@ var expectedEventsList2 = ["trackData"];
 var FishjamAgent = class extends import_events2.EventEmitter {
   client;
   resolveConnectionPromise = null;
+  rejectConnectionPromise = null;
   connectionPromise;
   pendingImageCaptures = /* @__PURE__ */ new Map();
-  constructor(config, agentToken, callbacks) {
+  constructor(config, agentToken, callbacks, peerWebsocketUrl) {
     super();
-    const fishjamUrl = getFishjamUrl(config);
-    const websocketUrl = `${httpToWebsocket(fishjamUrl)}/socket/agent/websocket`;
+    const websocketUrl = getAgentWebsocketUrl(config, peerWebsocketUrl);
     this.client = new WebSocket(websocketUrl);
     this.client.binaryType = "arraybuffer";
     this.client.onclose = (message) => {
       this.rejectPendingCaptures("WebSocket closed");
+      this.rejectConnectionPromise?.(
+        new Error(
+          `Agent websocket closed before connecting (code ${message.code}${message.reason ? `: ${message.reason}` : ""})`
+        )
+      );
+      this.settleConnection();
       callbacks?.onClose?.(message.code, message.reason);
     };
     this.client.onerror = (message) => callbacks?.onError?.(message);
     this.client.onmessage = (message) => this.dispatchNotification(message);
     this.client.onopen = () => this.setupConnection(agentToken);
-    this.connectionPromise = new Promise((resolve) => {
+    this.connectionPromise = new Promise((resolve, reject) => {
       this.resolveConnectionPromise = resolve;
+      this.rejectConnectionPromise = reject;
+    });
+    this.connectionPromise.catch(() => {
     });
   }
   /**
@@ -6171,10 +6674,12 @@ var FishjamAgent = class extends import_events2.EventEmitter {
   setupConnection(agentToken) {
     const auth = AgentRequest.encode({ authRequest: { token: agentToken } }).finish();
     this.client.send(auth);
-    if (this.resolveConnectionPromise) {
-      this.resolveConnectionPromise();
-      this.resolveConnectionPromise = null;
-    }
+    this.resolveConnectionPromise?.();
+    this.settleConnection();
+  }
+  settleConnection() {
+    this.resolveConnectionPromise = null;
+    this.rejectConnectionPromise = null;
   }
   isExpectedEvent(notification) {
     return expectedEventsList2.includes(notification);
@@ -6185,48 +6690,53 @@ var toProtoEncoding = (encoding) => {
   return TrackEncoding.TRACK_ENCODING_OPUS;
 };
 
-// src/client.ts
-var import_axios3 = __toESM(require("axios"));
-
 // src/exceptions/mapper.ts
-function isAxiosException(error) {
-  return !!error && typeof error === "object" && "isAxiosError" in error && !!error.isAxiosError;
-}
-var mapException = (error, entity) => {
-  if (isAxiosException(error)) {
-    switch (error.response?.status) {
-      case 400:
-        return new BadRequestException(error);
-      case 402:
-        return new QuotaExceededException(error);
-      case 401:
-        throw new UnauthorizedException(error);
-      case 404:
-        if (error.request.path.includes("validate")) {
-          return new InvalidFishjamCredentialsException(error);
-        }
-        switch (entity) {
-          case "peer":
-            return new PeerNotFoundException(error);
-          case "room":
-            return new RoomNotFoundException(error);
-          default:
-            return new FishjamNotFoundException(error);
-        }
-      case 503:
-        return new ServiceUnavailableException(error);
-      default:
-        return new UnknownException(error);
-    }
-  } else {
+var notFoundException = (info, entity) => {
+  switch (entity) {
+    case "credentials":
+      return new InvalidFishjamCredentialsException(info);
+    case "peer":
+      return new PeerNotFoundException(info);
+    case "room":
+      return new RoomNotFoundException(info);
+    default:
+      return new FishjamNotFoundException(info);
+  }
+};
+var mapException = async (error, entity) => {
+  if (error instanceof FetchError) {
+    return new UnknownException({ message: error.cause.message, statusCode: 500, details: error.cause.message });
+  }
+  if (!(error instanceof ResponseError)) {
     return error;
   }
+  const status = error.response.status;
+  const body = await error.response.json().catch(() => ({}));
+  const info = {
+    message: `Request failed with status code ${status}`,
+    statusCode: status,
+    details: body["detail"] ?? body["errors"] ?? "Unknown error"
+  };
+  switch (status) {
+    case 400:
+      return new BadRequestException(info);
+    case 402:
+      return new QuotaExceededException(info);
+    case 401:
+      return new UnauthorizedException(info);
+    case 404:
+      return notFoundException(info, entity);
+    case 503:
+      return new ServiceUnavailableException(info);
+    default:
+      return new UnknownException(info);
+  }
 };
 
 // package.json
 var package_default = {
   name: "@fishjam-cloud/js-server-sdk",
-  version: "0.29.0-rc.2",
+  version: "0.29.0",
   description: "Fishjam server SDK for JavaScript",
   homepage: "https://github.com/fishjam-cloud/js-server-sdk",
   author: "Fishjam Team",
@@ -6288,9 +6798,11 @@ var package_default = {
     outDir: "dist"
   },
   dependencies: {
-    axios: "^1.7.9",
     uuid: "^11.1.0"
   },
+  engines: {
+    node: ">=18"
+  },
   peerDependencies: {
     "@google/genai": "^1.0.0"
   },
@@ -6315,8 +6827,7 @@ var package_default = {
     "*.{js,ts,tsx,mjs,cjs}": [
       "eslint --fix --config eslint.config.mjs"
     ]
-  },
-  stableVersion: "0.28.1"
+  }
 };
 
 // src/client.ts
@@ -6344,22 +6855,25 @@ var FishjamClient = class _FishjamClient {
    * ```
    */
   constructor(config) {
-    const client = import_axios3.default.create({
+    const deprecationMiddleware = {
+      post: async ({ response }) => {
+        this.handleDeprecationHeader(response.headers);
+        return response;
+      }
+    };
+    const apiConfig = new Configuration({
+      basePath: getFishjamUrl(config),
       headers: {
         Authorization: `Bearer ${config.managementToken}`,
         "x-fishjam-api-client": `js-server/${package_default.version}`
-      }
-    });
-    client.interceptors.response.use((response) => {
-      this.handleDeprecationHeader(response.headers);
-      return response;
+      },
+      middleware: [deprecationMiddleware]
     });
-    const fishjamUrl = getFishjamUrl(config);
-    this.moqApi = new MoQApi(void 0, fishjamUrl, client);
-    this.roomApi = new RoomsApi(void 0, fishjamUrl, client);
-    this.viewerApi = new ViewersApi(void 0, fishjamUrl, client);
-    this.streamerApi = new StreamersApi(void 0, fishjamUrl, client);
-    this.credentialsApi = new CredentialsApi(void 0, fishjamUrl, client);
+    this.moqApi = new MoQApi(apiConfig);
+    this.roomApi = new RoomsApi(apiConfig);
+    this.viewerApi = new ViewersApi(apiConfig);
+    this.streamerApi = new StreamersApi(apiConfig);
+    this.credentialsApi = new CredentialsApi(apiConfig);
     this.fishjamConfig = config;
   }
   /**
@@ -6392,12 +6906,12 @@ var FishjamClient = class _FishjamClient {
     try {
       await this.credentialsApi.validateCredentials();
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error, "credentials");
     }
   }
   handleDeprecationHeader(headers) {
     try {
-      const deprecationHeader = headers["x-fishjam-api-deprecated"];
+      const deprecationHeader = headers.get("x-fishjam-api-deprecated");
       if (!deprecationHeader || this.deprecationWarningShown) return;
       const deprecationStatus = JSON.parse(deprecationHeader);
       if (deprecationStatus.status === "unsupported") {
@@ -6414,15 +6928,10 @@ var FishjamClient = class _FishjamClient {
    */
   async createRoom(config = {}) {
     try {
-      const response = await this.roomApi.createRoom(config);
-      const {
-        data: {
-          data: { room }
-        }
-      } = response;
-      return room;
+      const { data } = await this.roomApi.createRoom({ roomConfig: config });
+      return data.room;
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6430,9 +6939,9 @@ var FishjamClient = class _FishjamClient {
    */
   async deleteRoom(roomId) {
     try {
-      await this.roomApi.deleteRoom(roomId);
+      await this.roomApi.deleteRoom({ roomId });
     } catch (error) {
-      throw mapException(error, "room");
+      throw await mapException(error, "room");
     }
   }
   /**
@@ -6440,10 +6949,10 @@ var FishjamClient = class _FishjamClient {
    */
   async getAllRooms() {
     try {
-      const getAllRoomsResponse = await this.roomApi.getAllRooms();
-      return getAllRoomsResponse.data.data ?? [];
+      const { data } = await this.roomApi.getAllRooms();
+      return data ?? [];
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6451,16 +6960,13 @@ var FishjamClient = class _FishjamClient {
    */
   async createPeer(roomId, options = {}) {
     try {
-      const response = await this.roomApi.addPeer(roomId, {
-        type: "webrtc",
-        options
+      const { data } = await this.roomApi.addPeer({
+        roomId,
+        peerConfig: { type: "webrtc", options }
       });
-      const {
-        data: { data }
-      } = response;
       return { peer: data.peer, peerToken: data.token };
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6468,18 +6974,15 @@ var FishjamClient = class _FishjamClient {
    */
   async createAgent(roomId, options = {}, callbacks) {
     try {
-      const response = await this.roomApi.addPeer(roomId, {
-        type: "agent",
-        options
+      const { data } = await this.roomApi.addPeer({
+        roomId,
+        peerConfig: { type: "agent", options }
       });
-      const {
-        data: { data }
-      } = response;
-      const agent = new FishjamAgent(this.fishjamConfig, data.token, callbacks);
+      const agent = new FishjamAgent(this.fishjamConfig, data.token, callbacks, data.peer_websocket_url);
       await agent.awaitConnected();
       return { agent, peer: data.peer };
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6487,16 +6990,13 @@ var FishjamClient = class _FishjamClient {
    */
   async createVapiAgent(roomId, options) {
     try {
-      const response = await this.roomApi.addPeer(roomId, {
-        type: "vapi",
-        options
+      const { data } = await this.roomApi.addPeer({
+        roomId,
+        peerConfig: { type: "vapi", options }
       });
-      const {
-        data: { data }
-      } = response;
       return { peer: data.peer };
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6504,10 +7004,10 @@ var FishjamClient = class _FishjamClient {
    */
   async getRoom(roomId) {
     try {
-      const getRoomResponse = await this.roomApi.getRoom(roomId);
-      return getRoomResponse.data.data;
+      const { data } = await this.roomApi.getRoom({ roomId });
+      return data;
     } catch (error) {
-      throw mapException(error, "room");
+      throw await mapException(error, "room");
     }
   }
   /**
@@ -6515,9 +7015,9 @@ var FishjamClient = class _FishjamClient {
    */
   async deletePeer(roomId, peerId) {
     try {
-      await this.roomApi.deletePeer(roomId, peerId);
+      await this.roomApi.deletePeer({ roomId, id: peerId });
     } catch (error) {
-      throw mapException(error, "peer");
+      throw await mapException(error, "peer");
     }
   }
   /**
@@ -6526,9 +7026,9 @@ var FishjamClient = class _FishjamClient {
    */
   async subscribePeer(roomId, subscriberPeerId, publisherPeerId) {
     try {
-      await this.roomApi.subscribePeer(roomId, subscriberPeerId, publisherPeerId);
+      await this.roomApi.subscribePeer({ roomId, id: subscriberPeerId, peerId: publisherPeerId });
     } catch (error) {
-      throw mapException(error, "peer");
+      throw await mapException(error, "peer");
     }
   }
   /**
@@ -6537,9 +7037,13 @@ var FishjamClient = class _FishjamClient {
    */
   async subscribeTracks(roomId, subscriberPeerId, tracks) {
     try {
-      await this.roomApi.subscribeTracks(roomId, subscriberPeerId, { track_ids: tracks });
+      await this.roomApi.subscribeTracks({
+        roomId,
+        id: subscriberPeerId,
+        subscribeTracksRequest: { track_ids: tracks }
+      });
     } catch (error) {
-      throw mapException(error, "peer");
+      throw await mapException(error, "peer");
     }
   }
   /**
@@ -6549,10 +7053,10 @@ var FishjamClient = class _FishjamClient {
    */
   async refreshPeerToken(roomId, peerId) {
     try {
-      const refreshTokenResponse = await this.roomApi.refreshToken(roomId, peerId);
-      return refreshTokenResponse.data.data.token;
+      const { data } = await this.roomApi.refreshToken({ roomId, id: peerId });
+      return data.token;
     } catch (error) {
-      throw mapException(error, "peer");
+      throw await mapException(error, "peer");
     }
   }
   /**
@@ -6561,10 +7065,9 @@ var FishjamClient = class _FishjamClient {
    */
   async createLivestreamViewerToken(roomId) {
     try {
-      const tokenResponse = await this.viewerApi.generateViewerToken(roomId);
-      return tokenResponse.data;
+      return await this.viewerApi.generateViewerToken({ roomId });
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6573,10 +7076,9 @@ var FishjamClient = class _FishjamClient {
    */
   async createLivestreamStreamerToken(roomId) {
     try {
-      const tokenResponse = await this.streamerApi.generateStreamerToken(roomId);
-      return tokenResponse.data;
+      return await this.streamerApi.generateStreamerToken({ roomId });
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
   /**
@@ -6585,10 +7087,9 @@ var FishjamClient = class _FishjamClient {
    */
   async createMoqAccess(config) {
     try {
-      const accessResponse = await this.moqApi.createMoqAccess(config);
-      return accessResponse.data;
+      return await this.moqApi.createMoqAccess({ moqAccessConfig: config });
     } catch (error) {
-      throw mapException(error);
+      throw await mapException(error);
     }
   }
 };
@@ -6613,5 +7114,6 @@ var FishjamClient = class _FishjamClient {
   UnauthorizedException,
   UnknownException,
   VideoCodec,
-  decodeServerNotifications
+  decodeServerNotifications,
+  verifyWebhookSignature
 });