@fishjam-cloud/js-server-sdk 0.29.0 → 0.30.0

package/dist/index.js

@@ -20,22 +20,32 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AudioFormat: () => AudioFormat,
+  AudioSampleRate: () => AudioSampleRate,
   BadRequestException: () => BadRequestException,
+  CompositionClient: () => CompositionClient,
+  CompositionNotFoundException: () => CompositionNotFoundException,
   FishjamAgent: () => FishjamAgent,
   FishjamBaseException: () => FishjamBaseException,
   FishjamClient: () => FishjamClient,
   FishjamNotFoundException: () => FishjamNotFoundException,
   FishjamWSNotifier: () => FishjamWSNotifier,
   ForbiddenException: () => ForbiddenException,
+  InputNotFoundException: () => InputNotFoundException,
   InvalidFishjamCredentialsException: () => InvalidFishjamCredentialsException,
   MissingFishjamIdException: () => MissingFishjamIdException,
+  OutputNotFoundException: () => OutputNotFoundException,
   PeerNotFoundException: () => PeerNotFoundException,
   PeerStatus: () => PeerStatus,
   QuotaExceededException: () => QuotaExceededException,
+  RecordingNotFoundException: () => RecordingNotFoundException,
+  RendererNotFoundException: () => RendererNotFoundException,
   RoomNotFoundException: () => RoomNotFoundException,
   RoomType: () => RoomType,
   ServerMessage: () => ServerMessage,
   ServiceUnavailableException: () => ServiceUnavailableException,
+  StaleSdkException: () => StaleSdkException,
+  SubscribeMode: () => SubscribeMode,
   UnauthorizedException: () => UnauthorizedException,
   UnknownException: () => UnknownException,
   VideoCodec: () => VideoCodec,
@@ -410,9 +420,336 @@ var MoQApi = class extends BaseAPI {
     return await response.value();
   }
 };
+function RecordingSourceFromJSON(json) {
+  return RecordingSourceFromJSONTyped(json, false);
+}
+function RecordingSourceFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "compositionURL": json["compositionURL"],
+    "outputId": json["outputId"],
+    "scaleRatio": json["scaleRatio"] == null ? void 0 : json["scaleRatio"]
+  };
+}
+function RecordingSourceToJSON(json) {
+  return RecordingSourceToJSONTyped(json, false);
+}
+function RecordingSourceToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "compositionURL": value["compositionURL"],
+    "outputId": value["outputId"],
+    "scaleRatio": value["scaleRatio"]
+  };
+}
+function RecordingConfigToJSON(json) {
+  return RecordingConfigToJSONTyped(json, false);
+}
+function RecordingConfigToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "metadata": value["metadata"],
+    "source": RecordingSourceToJSON(value["source"])
+  };
+}
+function RecordingStatusFromJSON(json) {
+  return RecordingStatusFromJSONTyped(json, false);
+}
+function RecordingStatusFromJSONTyped(json, ignoreDiscriminator) {
+  return json;
+}
+function RecordingFileFromJSON(json) {
+  return RecordingFileFromJSONTyped(json, false);
+}
+function RecordingFileFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "url": json["url"]
+  };
+}
+function RecordingFromJSON(json) {
+  return RecordingFromJSONTyped(json, false);
+}
+function RecordingFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "files": json["files"].map(RecordingFileFromJSON),
+    "id": json["id"],
+    "metadata": json["metadata"] == null ? void 0 : json["metadata"],
+    "source": RecordingSourceFromJSON(json["source"]),
+    "status": RecordingStatusFromJSON(json["status"])
+  };
+}
+function RecordingDetailsResponseFromJSON(json) {
+  return RecordingDetailsResponseFromJSONTyped(json, false);
+}
+function RecordingDetailsResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": RecordingFromJSON(json["data"])
+  };
+}
+function RecordingListResponseFromJSON(json) {
+  return RecordingListResponseFromJSONTyped(json, false);
+}
+function RecordingListResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    "data": json["data"].map(RecordingFromJSON)
+  };
+}
+var RecordingsApi = class extends BaseAPI {
+  /**
+   * Creates request options for createRecording without sending the request
+   */
+  async createRecordingRequestOpts(requestParameters) {
+    if (requestParameters["recordingConfig"] == null) {
+      throw new RequiredError(
+        "recordingConfig",
+        'Required parameter "recordingConfig" was null or undefined when calling createRecording().'
+      );
+    }
+    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 = `/recordings`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: RecordingConfigToJSON(requestParameters["recordingConfig"])
+    };
+  }
+  /**
+   * Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+   * Create a recording
+   */
+  async createRecordingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createRecordingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RecordingDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create a recording resource. Capturing starts synchronously, so it is returned with status `active`.
+   * Create a recording
+   */
+  async createRecording(requestParameters, initOverrides) {
+    const response = await this.createRecordingRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for deleteRecording without sending the request
+   */
+  async deleteRecordingRequestOpts(requestParameters) {
+    if (requestParameters["recordingId"] == null) {
+      throw new RequiredError(
+        "recordingId",
+        'Required parameter "recordingId" was null or undefined when calling deleteRecording().'
+      );
+    }
+    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 = `/recordings/{recording_id}`;
+    urlPath = urlPath.replace("{recording_id}", encodeURIComponent(String(requestParameters["recordingId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Delete a recording by id. The recording disappears from the API immediately; its stored media is removed asynchronously by a background job. A recording that is still `active` cannot be deleted — wait for it to finish or fail.
+   * Delete a recording
+   */
+  async deleteRecordingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteRecordingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Delete a recording by id. The recording disappears from the API immediately; its stored media is removed asynchronously by a background job. A recording that is still `active` cannot be deleted — wait for it to finish or fail.
+   * Delete a recording
+   */
+  async deleteRecording(requestParameters, initOverrides) {
+    await this.deleteRecordingRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for getRecording without sending the request
+   */
+  async getRecordingRequestOpts(requestParameters) {
+    if (requestParameters["recordingId"] == null) {
+      throw new RequiredError(
+        "recordingId",
+        'Required parameter "recordingId" was null or undefined when calling getRecording().'
+      );
+    }
+    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 = `/recordings/{recording_id}`;
+    urlPath = urlPath.replace("{recording_id}", encodeURIComponent(String(requestParameters["recordingId"])));
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Get a recording by id.
+   * Get a recording
+   */
+  async getRecordingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.getRecordingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RecordingDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Get a recording by id.
+   * Get a recording
+   */
+  async getRecording(requestParameters, initOverrides) {
+    const response = await this.getRecordingRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for listRecordings without sending the request
+   */
+  async listRecordingsRequestOpts(requestParameters) {
+    const queryParameters = {};
+    if (requestParameters["metadata"] != null) {
+      for (let key of Object.keys(requestParameters["metadata"])) {
+        queryParameters[key] = requestParameters["metadata"][key];
+      }
+    }
+    if (requestParameters["status"] != null) {
+      queryParameters["status"] = requestParameters["status"];
+    }
+    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 = `/recordings`;
+    return {
+      path: urlPath,
+      method: "GET",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * List recordings for the tenant, optionally filtered by metadata and status.
+   * List recordings
+   */
+  async listRecordingsRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.listRecordingsRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RecordingListResponseFromJSON(jsonValue));
+  }
+  /**
+   * List recordings for the tenant, optionally filtered by metadata and status.
+   * List recordings
+   */
+  async listRecordings(requestParameters = {}, initOverrides) {
+    const response = await this.listRecordingsRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for stopRecording without sending the request
+   */
+  async stopRecordingRequestOpts(requestParameters) {
+    if (requestParameters["recordingId"] == null) {
+      throw new RequiredError(
+        "recordingId",
+        'Required parameter "recordingId" was null or undefined when calling stopRecording().'
+      );
+    }
+    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 = `/recordings/{recording_id}/stop`;
+    urlPath = urlPath.replace("{recording_id}", encodeURIComponent(String(requestParameters["recordingId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Request the recorder to stop capturing. Finalization is asynchronous: the recording stays `active` until the capture is finalized, then becomes `finished`. Stopping a recording that is no longer active is a no-op.
+   * Stop a recording
+   */
+  async stopRecordingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.stopRecordingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse(response, (jsonValue) => RecordingDetailsResponseFromJSON(jsonValue));
+  }
+  /**
+   * Request the recorder to stop capturing. Finalization is asynchronous: the recording stays `active` until the capture is finalized, then becomes `finished`. Stopping a recording that is no longer active is a no-op.
+   * Stop a recording
+   */
+  async stopRecording(requestParameters, initOverrides) {
+    const response = await this.stopRecordingRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+var AudioSampleRate = {
+  NUMBER_16000: 16e3,
+  NUMBER_24000: 24e3
+};
 function AudioSampleRateToJSON(value) {
   return value;
 }
+var AudioFormat = {
+  Pcm16: "pcm16"
+};
 function AudioFormatToJSON(value) {
   return value;
 }
@@ -428,6 +765,10 @@ function AgentOutputToJSONTyped(value, ignoreDiscriminator = false) {
     "audioSampleRate": AudioSampleRateToJSON(value["audioSampleRate"])
   };
 }
+var SubscribeMode = {
+  Auto: "auto",
+  Manual: "manual"
+};
 function SubscribeModeFromJSON(json) {
   return SubscribeModeFromJSONTyped(json, false);
 }
@@ -1411,6 +1752,72 @@ function ViewerFromJSONTyped(json, ignoreDiscriminator) {
     "token": json["token"]
   };
 }
+function TrackForwardingToJSON(json) {
+  return TrackForwardingToJSONTyped(json, false);
+}
+function TrackForwardingToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    "compositionURL": value["compositionURL"],
+    "selector": value["selector"]
+  };
+}
+var TrackForwardingsApi = class extends BaseAPI {
+  /**
+   * Creates request options for createTrackForwarding without sending the request
+   */
+  async createTrackForwardingRequestOpts(requestParameters) {
+    if (requestParameters["roomId"] == null) {
+      throw new RequiredError(
+        "roomId",
+        'Required parameter "roomId" was null or undefined when calling createTrackForwarding().'
+      );
+    }
+    if (requestParameters["trackForwarding"] == null) {
+      throw new RequiredError(
+        "trackForwarding",
+        'Required parameter "trackForwarding" was null or undefined when calling createTrackForwarding().'
+      );
+    }
+    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}/track_forwardings`;
+    urlPath = urlPath.replace("{room_id}", encodeURIComponent(String(requestParameters["roomId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: TrackForwardingToJSON(requestParameters["trackForwarding"])
+    };
+  }
+  /**
+   * Forward a room\'s tracks into an external composition.
+   * Create a track forwarding
+   */
+  async createTrackForwardingRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createTrackForwardingRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse(response);
+  }
+  /**
+   * Forward a room\'s tracks into an external composition.
+   * Create a track forwarding
+   */
+  async createTrackForwarding(requestParameters, initOverrides) {
+    await this.createTrackForwardingRaw(requestParameters, initOverrides);
+  }
+};
 function ViewerDetailsResponseFromJSON(json) {
   return ViewerDetailsResponseFromJSONTyped(json, false);
 }
@@ -2557,13 +2964,62 @@ function serverMessage_VadNotification_StatusToJSON(object) {
       return "UNRECOGNIZED";
   }
 }
-function createBaseServerMessage() {
-  return {
-    authenticated: void 0,
-    authRequest: void 0,
-    subscribeRequest: void 0,
-    subscribeResponse: void 0,
-    roomCreated: void 0,
+var ServerMessage_RecordingStatusChanged_Status = /* @__PURE__ */ ((ServerMessage_RecordingStatusChanged_Status2) => {
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["STATUS_UNSPECIFIED"] = 0] = "STATUS_UNSPECIFIED";
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["STATUS_ACTIVE"] = 1] = "STATUS_ACTIVE";
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["STATUS_FINISHED"] = 2] = "STATUS_FINISHED";
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["STATUS_AVAILABLE"] = 3] = "STATUS_AVAILABLE";
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["STATUS_FAILED"] = 4] = "STATUS_FAILED";
+  ServerMessage_RecordingStatusChanged_Status2[ServerMessage_RecordingStatusChanged_Status2["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+  return ServerMessage_RecordingStatusChanged_Status2;
+})(ServerMessage_RecordingStatusChanged_Status || {});
+function serverMessage_RecordingStatusChanged_StatusFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "STATUS_UNSPECIFIED":
+      return 0;
+    case 1:
+    case "STATUS_ACTIVE":
+      return 1;
+    case 2:
+    case "STATUS_FINISHED":
+      return 2;
+    case 3:
+    case "STATUS_AVAILABLE":
+      return 3;
+    case 4:
+    case "STATUS_FAILED":
+      return 4;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1;
+  }
+}
+function serverMessage_RecordingStatusChanged_StatusToJSON(object) {
+  switch (object) {
+    case 0:
+      return "STATUS_UNSPECIFIED";
+    case 1:
+      return "STATUS_ACTIVE";
+    case 2:
+      return "STATUS_FINISHED";
+    case 3:
+      return "STATUS_AVAILABLE";
+    case 4:
+      return "STATUS_FAILED";
+    case -1:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function createBaseServerMessage() {
+  return {
+    authenticated: void 0,
+    authRequest: void 0,
+    subscribeRequest: void 0,
+    subscribeResponse: void 0,
+    roomCreated: void 0,
     roomDeleted: void 0,
     roomCrashed: void 0,
     peerConnected: void 0,
@@ -2584,6 +3040,7 @@ function createBaseServerMessage() {
     viewerDisconnected: void 0,
     streamerConnected: void 0,
     streamerDisconnected: void 0,
+    recordingStatusChanged: void 0,
     notificationBatch: void 0,
     streamConnected: void 0,
     streamDisconnected: void 0,
@@ -2670,6 +3127,9 @@ var ServerMessage = {
     if (message.streamerDisconnected !== void 0) {
       ServerMessage_StreamerDisconnected.encode(message.streamerDisconnected, writer.uint32(218).fork()).join();
     }
+    if (message.recordingStatusChanged !== void 0) {
+      ServerMessage_RecordingStatusChanged.encode(message.recordingStatusChanged, writer.uint32(274).fork()).join();
+    }
     if (message.notificationBatch !== void 0) {
       ServerMessage_NotificationBatch.encode(message.notificationBatch, writer.uint32(266).fork()).join();
     }
@@ -2875,6 +3335,13 @@ var ServerMessage = {
           message.streamerDisconnected = ServerMessage_StreamerDisconnected.decode(reader, reader.uint32());
           continue;
         }
+        case 34: {
+          if (tag !== 274) {
+            break;
+          }
+          message.recordingStatusChanged = ServerMessage_RecordingStatusChanged.decode(reader, reader.uint32());
+          continue;
+        }
         case 33: {
           if (tag !== 266) {
             break;
@@ -2959,6 +3426,7 @@ var ServerMessage = {
       viewerDisconnected: isSet2(object.viewerDisconnected) ? ServerMessage_ViewerDisconnected.fromJSON(object.viewerDisconnected) : void 0,
       streamerConnected: isSet2(object.streamerConnected) ? ServerMessage_StreamerConnected.fromJSON(object.streamerConnected) : void 0,
       streamerDisconnected: isSet2(object.streamerDisconnected) ? ServerMessage_StreamerDisconnected.fromJSON(object.streamerDisconnected) : void 0,
+      recordingStatusChanged: isSet2(object.recordingStatusChanged) ? ServerMessage_RecordingStatusChanged.fromJSON(object.recordingStatusChanged) : void 0,
       notificationBatch: isSet2(object.notificationBatch) ? ServerMessage_NotificationBatch.fromJSON(object.notificationBatch) : void 0,
       streamConnected: isSet2(object.streamConnected) ? ServerMessage_StreamConnected.fromJSON(object.streamConnected) : void 0,
       streamDisconnected: isSet2(object.streamDisconnected) ? ServerMessage_StreamDisconnected.fromJSON(object.streamDisconnected) : void 0,
@@ -3045,6 +3513,9 @@ var ServerMessage = {
     if (message.streamerDisconnected !== void 0) {
       obj.streamerDisconnected = ServerMessage_StreamerDisconnected.toJSON(message.streamerDisconnected);
     }
+    if (message.recordingStatusChanged !== void 0) {
+      obj.recordingStatusChanged = ServerMessage_RecordingStatusChanged.toJSON(message.recordingStatusChanged);
+    }
     if (message.notificationBatch !== void 0) {
       obj.notificationBatch = ServerMessage_NotificationBatch.toJSON(message.notificationBatch);
     }
@@ -3098,6 +3569,7 @@ var ServerMessage = {
     message.viewerDisconnected = object.viewerDisconnected !== void 0 && object.viewerDisconnected !== null ? ServerMessage_ViewerDisconnected.fromPartial(object.viewerDisconnected) : void 0;
     message.streamerConnected = object.streamerConnected !== void 0 && object.streamerConnected !== null ? ServerMessage_StreamerConnected.fromPartial(object.streamerConnected) : void 0;
     message.streamerDisconnected = object.streamerDisconnected !== void 0 && object.streamerDisconnected !== null ? ServerMessage_StreamerDisconnected.fromPartial(object.streamerDisconnected) : void 0;
+    message.recordingStatusChanged = object.recordingStatusChanged !== void 0 && object.recordingStatusChanged !== null ? ServerMessage_RecordingStatusChanged.fromPartial(object.recordingStatusChanged) : void 0;
     message.notificationBatch = object.notificationBatch !== void 0 && object.notificationBatch !== null ? ServerMessage_NotificationBatch.fromPartial(object.notificationBatch) : void 0;
     message.streamConnected = object.streamConnected !== void 0 && object.streamConnected !== null ? ServerMessage_StreamConnected.fromPartial(object.streamConnected) : void 0;
     message.streamDisconnected = object.streamDisconnected !== void 0 && object.streamDisconnected !== null ? ServerMessage_StreamDisconnected.fromPartial(object.streamDisconnected) : void 0;
@@ -5405,6 +5877,89 @@ var ServerMessage_StreamerDisconnected = {
     return message;
   }
 };
+function createBaseServerMessage_RecordingStatusChanged() {
+  return { recordingId: "", status: 0, metadata: "" };
+}
+var ServerMessage_RecordingStatusChanged = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.recordingId !== "") {
+      writer.uint32(10).string(message.recordingId);
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    if (message.metadata !== "") {
+      writer.uint32(26).string(message.metadata);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseServerMessage_RecordingStatusChanged();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.recordingId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.status = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.metadata = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      recordingId: isSet2(object.recordingId) ? globalThis.String(object.recordingId) : "",
+      status: isSet2(object.status) ? serverMessage_RecordingStatusChanged_StatusFromJSON(object.status) : 0,
+      metadata: isSet2(object.metadata) ? globalThis.String(object.metadata) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.recordingId !== "") {
+      obj.recordingId = message.recordingId;
+    }
+    if (message.status !== 0) {
+      obj.status = serverMessage_RecordingStatusChanged_StatusToJSON(message.status);
+    }
+    if (message.metadata !== "") {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  },
+  create(base) {
+    return ServerMessage_RecordingStatusChanged.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseServerMessage_RecordingStatusChanged();
+    message.recordingId = object.recordingId ?? "";
+    message.status = object.status ?? 0;
+    message.metadata = object.metadata ?? "";
+    return message;
+  }
+};
 function createBaseServerMessage_NotificationBatch() {
   return { notifications: [] };
 }
@@ -6335,12 +6890,25 @@ function isSet3(value) {
 // src/ws_notifier.ts
 var import_events = require("events");
 
+// src/utils.ts
+var import_promises = require("fs/promises");
+
 // src/exceptions/index.ts
 var MissingFishjamIdException = class extends Error {
   constructor() {
     super("Fishjam ID is required");
   }
 };
+var StaleSdkException = class extends Error {
+  /** Raw wire value received from the server. */
+  status;
+  constructor(status) {
+    super(
+      `Received a recording status this SDK cannot parse (${status}). You are probably using an outdated version of @fishjam-cloud/js-server-sdk \u2014 please update it.`
+    );
+    this.status = status;
+  }
+};
 var FishjamBaseException = class extends Error {
   statusCode;
   details;
@@ -6364,6 +6932,16 @@ var InvalidFishjamCredentialsException = class extends FishjamBaseException {
 };
 var PeerNotFoundException = class extends FishjamBaseException {
 };
+var RecordingNotFoundException = class extends FishjamBaseException {
+};
+var CompositionNotFoundException = class extends FishjamBaseException {
+};
+var InputNotFoundException = class extends FishjamBaseException {
+};
+var OutputNotFoundException = class extends FishjamBaseException {
+};
+var RendererNotFoundException = class extends FishjamBaseException {
+};
 var ServiceUnavailableException = class extends FishjamBaseException {
 };
 var QuotaExceededException = class extends FishjamBaseException {
@@ -6372,6 +6950,7 @@ var UnknownException = class extends FishjamBaseException {
 };
 
 // src/utils.ts
+var FISHJAM_URL = "https://fishjam.io";
 var httpToWebsocket = (httpUrl) => {
   const url = new URL(httpUrl);
   url.protocol = url.protocol.replace("http", "ws");
@@ -6382,7 +6961,7 @@ var getFishjamUrl = (config) => {
   try {
     return new URL(config.fishjamId).href;
   } catch {
-    return `https://fishjam.io/api/v1/connect/${config.fishjamId}`;
+    return `${FISHJAM_URL}/api/v1/connect/${config.fishjamId}`;
   }
 };
 var AGENT_SOCKET_PATH = "/socket/agent/websocket";
@@ -6395,6 +6974,10 @@ var getAgentWebsocketUrl = (config, peerWebsocketUrl) => {
   }
   return `${httpToWebsocket(getFishjamUrl(config))}${AGENT_SOCKET_PATH}`;
 };
+var COMPOSITION_URL = "https://rtc.fishjam.io";
+var getCompositionOrigin = (config) => new URL(config.compositionUrl ?? COMPOSITION_URL).origin;
+var toBlob = async (file) => typeof file === "string" ? new Blob([await (0, import_promises.readFile)(file)]) : file;
+var getLivestreamWhipUrl = (config) => `${new URL(getFishjamUrl(config)).origin}/api/v1/live/api/whip`;
 
 // src/notifications.ts
 var peerTypeMap = {
@@ -6416,6 +6999,20 @@ var vadStatusMap = {
   [ServerMessage_VadNotification_Status.STATUS_SPEECH]: "speech",
   [ServerMessage_VadNotification_Status.UNRECOGNIZED]: "silence"
 };
+var mapRecordingStatus = (status) => {
+  switch (status) {
+    case ServerMessage_RecordingStatusChanged_Status.STATUS_ACTIVE:
+      return "active";
+    case ServerMessage_RecordingStatusChanged_Status.STATUS_FINISHED:
+      return "finished";
+    case ServerMessage_RecordingStatusChanged_Status.STATUS_AVAILABLE:
+      return "available";
+    case ServerMessage_RecordingStatusChanged_Status.STATUS_FAILED:
+      return "failed";
+    default:
+      throw new StaleSdkException(status);
+  }
+};
 var expectedEventsList = [
   "roomCreated",
   "roomDeleted",
@@ -6437,7 +7034,8 @@ var expectedEventsList = [
   "trackForwardingRemoved",
   "vadNotification",
   "channelAdded",
-  "channelRemoved"
+  "channelRemoved",
+  "recordingStatusChanged"
 ];
 var peerEventsWithPeerType = /* @__PURE__ */ new Set([
   "peerAdded",
@@ -6466,6 +7064,10 @@ var mapNotification = (event, msg) => {
     const vad = msg;
     return { ...vad, status: vadStatusMap[vad.status] };
   }
+  if (event === "recordingStatusChanged") {
+    const recording = msg;
+    return { ...recording, status: mapRecordingStatus(recording.status) };
+  }
   return msg;
 };
 var isExpectedEvent = (event) => expectedEventsList.includes(event);
@@ -6690,129 +7292,2278 @@ var toProtoEncoding = (encoding) => {
   return TrackEncoding.TRACK_ENCODING_OPUS;
 };
 
-// src/exceptions/mapper.ts
-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);
+// ../composition-openapi/dist/index.js
+var BASE_PATH2 = "https://rtc.fishjam.io".replace(/\/+$/, "");
+var Configuration2 = class {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
   }
-};
-var mapException = async (error, entity) => {
-  if (error instanceof FetchError) {
-    return new UnknownException({ message: error.cause.message, statusCode: 500, details: error.cause.message });
+  set config(configuration) {
+    this.configuration = configuration;
   }
-  if (!(error instanceof ResponseError)) {
-    return error;
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH2;
   }
-  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);
+  get fetchApi() {
+    return this.configuration.fetchApi;
   }
-};
-
-// package.json
-var package_default = {
-  name: "@fishjam-cloud/js-server-sdk",
-  version: "0.29.0",
-  description: "Fishjam server SDK for JavaScript",
-  homepage: "https://github.com/fishjam-cloud/js-server-sdk",
-  author: "Fishjam Team",
-  repository: {
-    type: "git",
-    url: "https://github.com/fishjam-cloud/js-server-sdk.git"
-  },
-  bugs: {
-    url: "https://github.com/fishjam-cloud/js-server-sdk/issues"
-  },
-  license: "Apache-2.0",
-  keywords: [
-    "webrtc",
-    "fishjam",
-    "server",
-    "membrane"
-  ],
-  main: "./dist/index.js",
-  types: "./dist/index.d.ts",
-  files: [
-    "dist"
-  ],
-  exports: {
-    ".": {
-      types: "./dist/index.d.ts",
-      import: "./dist/index.mjs",
-      require: "./dist/index.js"
-    },
-    "./gemini": {
-      types: "./dist/integrations/gemini.d.ts",
-      import: "./dist/integrations/gemini.mjs",
-      require: "./dist/integrations/gemini.js"
-    }
-  },
-  scripts: {
-    build: "tsup --dts-resolve",
-    format: "prettier --write .",
-    "format:check": "prettier --check .",
-    typecheck: "tsc --noEmit",
-    lint: "eslint . --fix",
-    "lint:check": "eslint .",
-    test: "vitest run"
-  },
-  tsup: {
-    entry: [
-      "src/index.ts",
-      "src/integrations/gemini.ts",
-      "src/proto.ts"
-    ],
-    noExternal: [
-      "fishjam-openapi",
-      "fishjam-proto"
-    ],
-    minify: false,
-    format: [
-      "cjs",
-      "esm"
-    ],
-    outDir: "dist"
-  },
-  dependencies: {
-    uuid: "^11.1.0"
-  },
-  engines: {
-    node: ">=18"
-  },
-  peerDependencies: {
-    "@google/genai": "^1.0.0"
-  },
-  peerDependenciesMeta: {
-    "@google/genai": {
-      optional: true
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring2;
+  }
+  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;
     }
-  },
-  devDependencies: {
-    "@fishjam-cloud/fishjam-openapi": "workspace:*",
+    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 DefaultConfig2 = new Configuration2();
+var BaseAPI2 = class _BaseAPI2 {
+  constructor(configuration = DefaultConfig2) {
+    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 _BaseAPI2.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 ResponseError2(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 (isFormData2(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob2(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 FetchError2(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 isBlob2(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData2(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+var ResponseError2 = 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 FetchError2 = 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 RequiredError2 = 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 querystring2(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey2(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey2(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 querystringSingleKey2(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring2(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+function canConsumeForm(consumes) {
+  for (const consume of consumes) {
+    if (consume.contentType?.startsWith("multipart/form-data") == true) {
+      return true;
+    }
+  }
+  return false;
+}
+var JSONApiResponse2 = class {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+};
+var VoidApiResponse2 = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return void 0;
+  }
+};
+var TextApiResponse = class {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.text();
+  }
+};
+function CompositionCreatedResponseFromJSON(json) {
+  return CompositionCreatedResponseFromJSONTyped(json, false);
+}
+function CompositionCreatedResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    compositionId: json["composition_id"],
+    apiUrl: json["api_url"]
+  };
+}
+function CreateCompositionRequestToJSON(json) {
+  return CreateCompositionRequestToJSONTyped(json, false);
+}
+function CreateCompositionRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    autostart: value["autostart"],
+    cleanup_without_inputs: value["cleanupWithoutInputs"]
+  };
+}
+var CompositionsApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for createComposition without sending the request
+   */
+  async createCompositionRequestOpts(requestParameters) {
+    if (requestParameters["createCompositionRequest"] == null) {
+      throw new RequiredError2(
+        "createCompositionRequest",
+        'Required parameter "createCompositionRequest" was null or undefined when calling createComposition().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition`;
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: CreateCompositionRequestToJSON(requestParameters["createCompositionRequest"])
+    };
+  }
+  /**
+   * Create a composition
+   */
+  async createCompositionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.createCompositionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response, (jsonValue) => CompositionCreatedResponseFromJSON(jsonValue));
+  }
+  /**
+   * Create a composition
+   */
+  async createComposition(requestParameters, initOverrides) {
+    const response = await this.createCompositionRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for deleteComposition without sending the request
+   */
+  async deleteCompositionRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling deleteComposition().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    return {
+      path: urlPath,
+      method: "DELETE",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Delete a composition
+   */
+  async deleteCompositionRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.deleteCompositionRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new VoidApiResponse2(response);
+  }
+  /**
+   * Delete a composition
+   */
+  async deleteComposition(requestParameters, initOverrides) {
+    await this.deleteCompositionRaw(requestParameters, initOverrides);
+  }
+  /**
+   * Creates request options for reset without sending the request
+   */
+  async resetRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling reset().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/reset`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Reset a composition
+   */
+  async resetRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.resetRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Reset a composition
+   */
+  async reset(requestParameters, initOverrides) {
+    const response = await this.resetRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for start without sending the request
+   */
+  async startRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling start().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/start`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Start a composition
+   */
+  async startRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.startRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Start a composition
+   */
+  async start(requestParameters, initOverrides) {
+    const response = await this.startRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+function SendCompositionEventRequestToJSON(json) {
+  return SendCompositionEventRequestToJSONTyped(json, false);
+}
+function SendCompositionEventRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    event_name: value["eventName"],
+    data: value["data"]
+  };
+}
+var EventsApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for sendCompositionEvent without sending the request
+   */
+  async sendCompositionEventRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling sendCompositionEvent().'
+      );
+    }
+    if (requestParameters["sendCompositionEventRequest"] == null) {
+      throw new RequiredError2(
+        "sendCompositionEventRequest",
+        'Required parameter "sendCompositionEventRequest" was null or undefined when calling sendCompositionEvent().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/event`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: SendCompositionEventRequestToJSON(requestParameters["sendCompositionEventRequest"])
+    };
+  }
+  /**
+   * Send an event to templates
+   */
+  async sendCompositionEventRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.sendCompositionEventRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Send an event to templates
+   */
+  async sendCompositionEvent(requestParameters, initOverrides) {
+    const response = await this.sendCompositionEventRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+function instanceOfMp4Input(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "mp4") return false;
+  return true;
+}
+function Mp4InputToJSON(json) {
+  return Mp4InputToJSONTyped(json, false);
+}
+function Mp4InputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    loop: value["loop"],
+    type: value["type"]
+  };
+}
+function instanceOfRtmpInput(value) {
+  if (!("streamKey" in value) && !("stream_key" in value) || value["streamKey"] === void 0 && value["stream_key"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "rtmp_server") return false;
+  return true;
+}
+function RtmpInputToJSON(json) {
+  return RtmpInputToJSONTyped(json, false);
+}
+function RtmpInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    stream_key: value["streamKey"],
+    type: value["type"]
+  };
+}
+function instanceOfWhepInput(value) {
+  if (!("endpointUrl" in value) && !("endpoint_url" in value) || value["endpointUrl"] === void 0 && value["endpoint_url"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "whep_client") return false;
+  return true;
+}
+function WhepInputToJSON(json) {
+  return WhepInputToJSONTyped(json, false);
+}
+function WhepInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    endpoint_url: value["endpointUrl"],
+    bearer_token: value["bearerToken"],
+    video: value["video"],
+    type: value["type"]
+  };
+}
+function instanceOfWhipInput(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "whip_server") return false;
+  return true;
+}
+function WhipInputToJSON(json) {
+  return WhipInputToJSONTyped(json, false);
+}
+function WhipInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    bearer_token: value["bearerToken"],
+    video: value["video"],
+    type: value["type"]
+  };
+}
+function RegisterInputToJSON(json) {
+  return RegisterInputToJSONTyped(json, false);
+}
+function RegisterInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfMp4Input(value)) {
+    return Mp4InputToJSON(value);
+  }
+  if (instanceOfRtmpInput(value)) {
+    return RtmpInputToJSON(value);
+  }
+  if (instanceOfWhepInput(value)) {
+    return WhepInputToJSON(value);
+  }
+  if (instanceOfWhipInput(value)) {
+    return WhipInputToJSON(value);
+  }
+  return {};
+}
+function RegisterInputResponseFromJSON(json) {
+  return RegisterInputResponseFromJSONTyped(json, false);
+}
+function RegisterInputResponseFromJSONTyped(json, ignoreDiscriminator) {
+  if (json == null) {
+    return json;
+  }
+  return {
+    bearerToken: json["bearer_token"] === void 0 ? void 0 : json["bearer_token"] === null ? null : json["bearer_token"],
+    endpointRoute: json["endpoint_route"] === void 0 ? void 0 : json["endpoint_route"] === null ? null : json["endpoint_route"],
+    videoDurationMs: json["video_duration_ms"] === void 0 ? void 0 : json["video_duration_ms"] === null ? null : json["video_duration_ms"],
+    audioDurationMs: json["audio_duration_ms"] === void 0 ? void 0 : json["audio_duration_ms"] === null ? null : json["audio_duration_ms"],
+    port: json["port"] === void 0 ? void 0 : json["port"] === null ? null : json["port"]
+  };
+}
+function UnregisterInputToJSON(json) {
+  return UnregisterInputToJSONTyped(json, false);
+}
+function UnregisterInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    schedule_time_ms: value["scheduleTimeMs"]
+  };
+}
+var InputsApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for registerInput without sending the request
+   */
+  async registerInputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling registerInput().'
+      );
+    }
+    if (requestParameters["inputId"] == null) {
+      throw new RequiredError2(
+        "inputId",
+        'Required parameter "inputId" was null or undefined when calling registerInput().'
+      );
+    }
+    if (requestParameters["registerInput"] == null) {
+      throw new RequiredError2(
+        "registerInput",
+        'Required parameter "registerInput" was null or undefined when calling registerInput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/input/{input_id}/register`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{input_id}", encodeURIComponent(String(requestParameters["inputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: RegisterInputToJSON(requestParameters["registerInput"])
+    };
+  }
+  /**
+   * Register an input
+   */
+  async registerInputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.registerInputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response, (jsonValue) => RegisterInputResponseFromJSON(jsonValue));
+  }
+  /**
+   * Register an input
+   */
+  async registerInput(requestParameters, initOverrides) {
+    const response = await this.registerInputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for unregisterInput without sending the request
+   */
+  async unregisterInputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling unregisterInput().'
+      );
+    }
+    if (requestParameters["inputId"] == null) {
+      throw new RequiredError2(
+        "inputId",
+        'Required parameter "inputId" was null or undefined when calling unregisterInput().'
+      );
+    }
+    if (requestParameters["unregisterInput"] == null) {
+      throw new RequiredError2(
+        "unregisterInput",
+        'Required parameter "unregisterInput" was null or undefined when calling unregisterInput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/input/{input_id}/unregister`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{input_id}", encodeURIComponent(String(requestParameters["inputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UnregisterInputToJSON(requestParameters["unregisterInput"])
+    };
+  }
+  /**
+   * Unregister an input
+   */
+  async unregisterInputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.unregisterInputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Unregister an input
+   */
+  async unregisterInput(requestParameters, initOverrides) {
+    const response = await this.unregisterInputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+var MediaTransportApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for whepOffer without sending the request
+   */
+  async whepOfferRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling whepOffer().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling whepOffer().'
+      );
+    }
+    if (requestParameters["body"] == null) {
+      throw new RequiredError2(
+        "body",
+        'Required parameter "body" was null or undefined when calling whepOffer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/sdp";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/whep/{output_id}`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    };
+  }
+  /**
+   * Play an output over WHEP
+   */
+  async whepOfferRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.whepOfferRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse2(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Play an output over WHEP
+   */
+  async whepOffer(requestParameters, initOverrides) {
+    const response = await this.whepOfferRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for whipOffer without sending the request
+   */
+  async whipOfferRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling whipOffer().'
+      );
+    }
+    if (requestParameters["inputId"] == null) {
+      throw new RequiredError2(
+        "inputId",
+        'Required parameter "inputId" was null or undefined when calling whipOffer().'
+      );
+    }
+    if (requestParameters["body"] == null) {
+      throw new RequiredError2(
+        "body",
+        'Required parameter "body" was null or undefined when calling whipOffer().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/sdp";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/whip/{input_id}`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{input_id}", encodeURIComponent(String(requestParameters["inputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: requestParameters["body"]
+    };
+  }
+  /**
+   * Publish to an input over WHIP
+   */
+  async whipOfferRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.whipOfferRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    if (this.isJsonMime(response.headers.get("content-type"))) {
+      return new JSONApiResponse2(response);
+    } else {
+      return new TextApiResponse(response);
+    }
+  }
+  /**
+   * Publish to an input over WHIP
+   */
+  async whipOffer(requestParameters, initOverrides) {
+    const response = await this.whipOfferRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+function instanceOfImage(value) {
+  if (!("imageId" in value) && !("image_id" in value) || value["imageId"] === void 0 && value["image_id"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "image") return false;
+  return true;
+}
+function ImageToJSON(json) {
+  return ImageToJSONTyped(json, false);
+}
+function ImageToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    image_id: value["imageId"],
+    width: value["width"],
+    height: value["height"],
+    type: value["type"]
+  };
+}
+function instanceOfInputStream(value) {
+  if (!("inputId" in value) && !("input_id" in value) || value["inputId"] === void 0 && value["input_id"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "input_stream") return false;
+  return true;
+}
+function InputStreamToJSON(json) {
+  return InputStreamToJSONTyped(json, false);
+}
+function InputStreamToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    input_id: value["inputId"],
+    type: value["type"]
+  };
+}
+function RescaleModeToJSON(value) {
+  return value;
+}
+function VerticalAlignToJSON(value) {
+  return value;
+}
+function BoxShadowToJSON(json) {
+  return BoxShadowToJSONTyped(json, false);
+}
+function BoxShadowToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    offset_x: value["offsetX"],
+    offset_y: value["offsetY"],
+    color: value["color"],
+    blur_radius: value["blurRadius"]
+  };
+}
+function HorizontalAlignToJSON(value) {
+  return value;
+}
+function instanceOfEasingFunctionBounce(value) {
+  if (!("functionName" in value) && !("function_name" in value) || value["functionName"] === void 0 && value["function_name"] === void 0)
+    return false;
+  if (value["functionName"] !== "bounce" && value["function_name"] !== "bounce")
+    return false;
+  return true;
+}
+function EasingFunctionBounceToJSON(json) {
+  return EasingFunctionBounceToJSONTyped(json, false);
+}
+function EasingFunctionBounceToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    function_name: value["functionName"]
+  };
+}
+function instanceOfEasingFunctionCubicBezier(value) {
+  if (!("points" in value) || value["points"] === void 0) return false;
+  if (!("functionName" in value) && !("function_name" in value) || value["functionName"] === void 0 && value["function_name"] === void 0)
+    return false;
+  if (value["functionName"] !== "cubic_bezier" && value["function_name"] !== "cubic_bezier")
+    return false;
+  return true;
+}
+function EasingFunctionCubicBezierToJSON(json) {
+  return EasingFunctionCubicBezierToJSONTyped(json, false);
+}
+function EasingFunctionCubicBezierToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    points: value["points"],
+    function_name: value["functionName"]
+  };
+}
+function instanceOfEasingFunctionLinear(value) {
+  if (!("functionName" in value) && !("function_name" in value) || value["functionName"] === void 0 && value["function_name"] === void 0)
+    return false;
+  if (value["functionName"] !== "linear" && value["function_name"] !== "linear")
+    return false;
+  return true;
+}
+function EasingFunctionLinearToJSON(json) {
+  return EasingFunctionLinearToJSONTyped(json, false);
+}
+function EasingFunctionLinearToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    function_name: value["functionName"]
+  };
+}
+function EasingFunctionToJSON(json) {
+  return EasingFunctionToJSONTyped(json, false);
+}
+function EasingFunctionToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfEasingFunctionBounce(value)) {
+    return EasingFunctionBounceToJSON(value);
+  }
+  if (instanceOfEasingFunctionCubicBezier(value)) {
+    return EasingFunctionCubicBezierToJSON(value);
+  }
+  if (instanceOfEasingFunctionLinear(value)) {
+    return EasingFunctionLinearToJSON(value);
+  }
+  return {};
+}
+function TransitionToJSON(json) {
+  return TransitionToJSONTyped(json, false);
+}
+function TransitionToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    duration_ms: value["durationMs"],
+    easing_function: EasingFunctionToJSON(value["easingFunction"]),
+    should_interrupt: value["shouldInterrupt"]
+  };
+}
+function instanceOfRescaler(value) {
+  if (!("child" in value) || value["child"] === void 0) return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "rescaler") return false;
+  return true;
+}
+function RescalerToJSON(json) {
+  return RescalerToJSONTyped(json, false);
+}
+function RescalerToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    child: ComponentToJSON(value["child"]),
+    mode: RescaleModeToJSON(value["mode"]),
+    horizontal_align: HorizontalAlignToJSON(value["horizontalAlign"]),
+    vertical_align: VerticalAlignToJSON(value["verticalAlign"]),
+    width: value["width"],
+    height: value["height"],
+    top: value["top"],
+    left: value["left"],
+    bottom: value["bottom"],
+    right: value["right"],
+    rotation: value["rotation"],
+    transition: TransitionToJSON(value["transition"]),
+    border_radius: value["borderRadius"],
+    border_width: value["borderWidth"],
+    border_color: value["borderColor"],
+    box_shadow: value["boxShadow"] == null ? void 0 : value["boxShadow"].map(BoxShadowToJSON),
+    type: value["type"]
+  };
+}
+function TextStyleToJSON(value) {
+  return value;
+}
+function TextWeightToJSON(value) {
+  return value;
+}
+function TextWrapModeToJSON(value) {
+  return value;
+}
+function instanceOfText(value) {
+  if (!("text" in value) || value["text"] === void 0) return false;
+  if (!("fontSize" in value) && !("font_size" in value) || value["fontSize"] === void 0 && value["font_size"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "text") return false;
+  return true;
+}
+function TextToJSON(json) {
+  return TextToJSONTyped(json, false);
+}
+function TextToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    text: value["text"],
+    width: value["width"],
+    height: value["height"],
+    max_width: value["maxWidth"],
+    max_height: value["maxHeight"],
+    font_size: value["fontSize"],
+    line_height: value["lineHeight"],
+    color: value["color"],
+    background_color: value["backgroundColor"],
+    font_family: value["fontFamily"],
+    style: TextStyleToJSON(value["style"]),
+    align: HorizontalAlignToJSON(value["align"]),
+    wrap: TextWrapModeToJSON(value["wrap"]),
+    weight: TextWeightToJSON(value["weight"]),
+    type: value["type"]
+  };
+}
+function instanceOfTiles(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "tiles") return false;
+  return true;
+}
+function TilesToJSON(json) {
+  return TilesToJSONTyped(json, false);
+}
+function TilesToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    children: value["children"] == null ? void 0 : value["children"].map(ComponentToJSON),
+    width: value["width"],
+    height: value["height"],
+    background_color: value["backgroundColor"],
+    tile_aspect_ratio: value["tileAspectRatio"],
+    margin: value["margin"],
+    padding: value["padding"],
+    horizontal_align: HorizontalAlignToJSON(value["horizontalAlign"]),
+    vertical_align: VerticalAlignToJSON(value["verticalAlign"]),
+    transition: TransitionToJSON(value["transition"]),
+    type: value["type"]
+  };
+}
+function ViewDirectionToJSON(value) {
+  return value;
+}
+function OverflowToJSON(value) {
+  return value;
+}
+function instanceOfView(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "view") return false;
+  return true;
+}
+function ViewToJSON(json) {
+  return ViewToJSONTyped(json, false);
+}
+function ViewToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    id: value["id"],
+    children: value["children"] == null ? void 0 : value["children"].map(ComponentToJSON),
+    width: value["width"],
+    height: value["height"],
+    direction: ViewDirectionToJSON(value["direction"]),
+    top: value["top"],
+    left: value["left"],
+    bottom: value["bottom"],
+    right: value["right"],
+    rotation: value["rotation"],
+    transition: TransitionToJSON(value["transition"]),
+    overflow: OverflowToJSON(value["overflow"]),
+    background_color: value["backgroundColor"],
+    border_radius: value["borderRadius"],
+    border_width: value["borderWidth"],
+    border_color: value["borderColor"],
+    box_shadow: value["boxShadow"] == null ? void 0 : value["boxShadow"].map(BoxShadowToJSON),
+    padding: value["padding"],
+    padding_vertical: value["paddingVertical"],
+    padding_horizontal: value["paddingHorizontal"],
+    padding_top: value["paddingTop"],
+    padding_right: value["paddingRight"],
+    padding_bottom: value["paddingBottom"],
+    padding_left: value["paddingLeft"],
+    type: value["type"]
+  };
+}
+function ComponentToJSON(json) {
+  return ComponentToJSONTyped4(json, false);
+}
+function ComponentToJSONTyped4(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfImage(value)) {
+    return ImageToJSON(value);
+  }
+  if (instanceOfInputStream(value)) {
+    return InputStreamToJSON(value);
+  }
+  if (instanceOfRescaler(value)) {
+    return RescalerToJSON(value);
+  }
+  if (instanceOfText(value)) {
+    return TextToJSON(value);
+  }
+  if (instanceOfTiles(value)) {
+    return TilesToJSON(value);
+  }
+  if (instanceOfView(value)) {
+    return ViewToJSON(value);
+  }
+  return {};
+}
+function VideoSceneToJSON(json) {
+  return VideoSceneToJSONTyped(json, false);
+}
+function VideoSceneToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    root: ComponentToJSON(value["root"])
+  };
+}
+function OutputEndConditionToJSON(json) {
+  return OutputEndConditionToJSONTyped(json, false);
+}
+function OutputEndConditionToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    any_of: value["anyOf"],
+    all_of: value["allOf"],
+    any_input: value["anyInput"],
+    all_inputs: value["allInputs"]
+  };
+}
+function ResolutionToJSON(json) {
+  return ResolutionToJSONTyped(json, false);
+}
+function ResolutionToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    width: value["width"],
+    height: value["height"]
+  };
+}
+function OutputRtmpClientVideoOptionsToJSON(json) {
+  return OutputRtmpClientVideoOptionsToJSONTyped(json, false);
+}
+function OutputRtmpClientVideoOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resolution: ResolutionToJSON(value["resolution"]),
+    send_eos_when: OutputEndConditionToJSON(value["sendEosWhen"]),
+    initial: VideoSceneToJSON(value["initial"])
+  };
+}
+function AudioChannelsToJSON(value) {
+  return value;
+}
+function AudioMixingStrategyToJSON(value) {
+  return value;
+}
+function AudioSceneInputToJSON(json) {
+  return AudioSceneInputToJSONTyped(json, false);
+}
+function AudioSceneInputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    input_id: value["inputId"],
+    volume: value["volume"]
+  };
+}
+function AudioSceneToJSON(json) {
+  return AudioSceneToJSONTyped(json, false);
+}
+function AudioSceneToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    inputs: value["inputs"].map(AudioSceneInputToJSON)
+  };
+}
+function OutputRtmpClientAudioOptionsToJSON(json) {
+  return OutputRtmpClientAudioOptionsToJSONTyped(json, false);
+}
+function OutputRtmpClientAudioOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    mixing_strategy: AudioMixingStrategyToJSON(value["mixingStrategy"]),
+    send_eos_when: OutputEndConditionToJSON(value["sendEosWhen"]),
+    channels: AudioChannelsToJSON(value["channels"]),
+    initial: AudioSceneToJSON(value["initial"])
+  };
+}
+function instanceOfRtmpOutput(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "rtmp_client") return false;
+  return true;
+}
+function RtmpOutputToJSON(json) {
+  return RtmpOutputToJSONTyped(json, false);
+}
+function RtmpOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    video: OutputRtmpClientVideoOptionsToJSON(value["video"]),
+    audio: OutputRtmpClientAudioOptionsToJSON(value["audio"]),
+    type: value["type"]
+  };
+}
+function OutputWhipVideoOptionsToJSON(json) {
+  return OutputWhipVideoOptionsToJSONTyped(json, false);
+}
+function OutputWhipVideoOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    resolution: ResolutionToJSON(value["resolution"]),
+    send_eos_when: OutputEndConditionToJSON(value["sendEosWhen"]),
+    initial: VideoSceneToJSON(value["initial"])
+  };
+}
+function instanceOfWhipAudioEncoderOptionsAny(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "any") return false;
+  return true;
+}
+function WhipAudioEncoderOptionsAnyToJSON(json) {
+  return WhipAudioEncoderOptionsAnyToJSONTyped(json, false);
+}
+function WhipAudioEncoderOptionsAnyToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    type: value["type"]
+  };
+}
+function OpusEncoderPresetToJSON(value) {
+  return value;
+}
+function instanceOfWhipAudioEncoderOptionsOpus(value) {
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "opus") return false;
+  return true;
+}
+function WhipAudioEncoderOptionsOpusToJSON(json) {
+  return WhipAudioEncoderOptionsOpusToJSONTyped(json, false);
+}
+function WhipAudioEncoderOptionsOpusToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    preset: OpusEncoderPresetToJSON(value["preset"]),
+    sample_rate: value["sampleRate"],
+    forward_error_correction: value["forwardErrorCorrection"],
+    type: value["type"]
+  };
+}
+function WhipAudioEncoderOptionsToJSON(json) {
+  return WhipAudioEncoderOptionsToJSONTyped(json, false);
+}
+function WhipAudioEncoderOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfWhipAudioEncoderOptionsAny(value)) {
+    return WhipAudioEncoderOptionsAnyToJSON(value);
+  }
+  if (instanceOfWhipAudioEncoderOptionsOpus(value)) {
+    return WhipAudioEncoderOptionsOpusToJSON(value);
+  }
+  return {};
+}
+function OutputWhipAudioOptionsToJSON(json) {
+  return OutputWhipAudioOptionsToJSONTyped(json, false);
+}
+function OutputWhipAudioOptionsToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    mixing_strategy: AudioMixingStrategyToJSON(value["mixingStrategy"]),
+    send_eos_when: OutputEndConditionToJSON(value["sendEosWhen"]),
+    channels: AudioChannelsToJSON(value["channels"]),
+    encoder_preferences: value["encoderPreferences"] == null ? void 0 : value["encoderPreferences"].map(WhipAudioEncoderOptionsToJSON),
+    initial: AudioSceneToJSON(value["initial"])
+  };
+}
+function instanceOfWhipOutput(value) {
+  if (!("endpointUrl" in value) && !("endpoint_url" in value) || value["endpointUrl"] === void 0 && value["endpoint_url"] === void 0)
+    return false;
+  if (!("type" in value) || value["type"] === void 0) return false;
+  if (value["type"] !== "whip_client") return false;
+  return true;
+}
+function WhipOutputToJSON(json) {
+  return WhipOutputToJSONTyped(json, false);
+}
+function WhipOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    endpoint_url: value["endpointUrl"],
+    bearer_token: value["bearerToken"],
+    video: OutputWhipVideoOptionsToJSON(value["video"]),
+    audio: OutputWhipAudioOptionsToJSON(value["audio"]),
+    type: value["type"]
+  };
+}
+function RegisterOutputToJSON(json) {
+  return RegisterOutputToJSONTyped(json, false);
+}
+function RegisterOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfRtmpOutput(value)) {
+    return RtmpOutputToJSON(value);
+  }
+  if (instanceOfWhipOutput(value)) {
+    return WhipOutputToJSON(value);
+  }
+  return {};
+}
+function UnregisterOutputToJSON(json) {
+  return UnregisterOutputToJSONTyped(json, false);
+}
+function UnregisterOutputToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    schedule_time_ms: value["scheduleTimeMs"]
+  };
+}
+function UpdateOutputRequestToJSON(json) {
+  return UpdateOutputRequestToJSONTyped(json, false);
+}
+function UpdateOutputRequestToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    video: VideoSceneToJSON(value["video"]),
+    audio: AudioSceneToJSON(value["audio"]),
+    schedule_time_ms: value["scheduleTimeMs"]
+  };
+}
+var OutputsApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for registerOutput without sending the request
+   */
+  async registerOutputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling registerOutput().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling registerOutput().'
+      );
+    }
+    if (requestParameters["registerOutput"] == null) {
+      throw new RequiredError2(
+        "registerOutput",
+        'Required parameter "registerOutput" was null or undefined when calling registerOutput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/output/{output_id}/register`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: RegisterOutputToJSON(requestParameters["registerOutput"])
+    };
+  }
+  /**
+   * Register an output
+   */
+  async registerOutputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.registerOutputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Register an output
+   */
+  async registerOutput(requestParameters, initOverrides) {
+    const response = await this.registerOutputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for registerTemplateOutput without sending the request
+   */
+  async registerTemplateOutputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling registerTemplateOutput().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling registerTemplateOutput().'
+      );
+    }
+    if (requestParameters["config"] == null) {
+      throw new RequiredError2(
+        "config",
+        'Required parameter "config" was null or undefined when calling registerTemplateOutput().'
+      );
+    }
+    if (requestParameters["template"] == null) {
+      throw new RequiredError2(
+        "template",
+        'Required parameter "template" was null or undefined when calling registerTemplateOutput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const consumes = [{ contentType: "multipart/form-data" }];
+    const canConsumeForm2 = canConsumeForm(consumes);
+    let formParams;
+    let useForm = false;
+    useForm = canConsumeForm2;
+    if (useForm) {
+      formParams = new FormData();
+    } else {
+      formParams = new URLSearchParams();
+    }
+    if (requestParameters["config"] != null) {
+      formParams.append(
+        "config",
+        new Blob([JSON.stringify(RegisterOutputToJSON(requestParameters["config"]))], { type: "application/json" })
+      );
+    }
+    if (requestParameters["template"] != null) {
+      formParams.append("template", requestParameters["template"]);
+    }
+    let urlPath = `/api/composition/{composition_id}/output/{output_id}/template`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: formParams
+    };
+  }
+  /**
+   * Register a templated output
+   */
+  async registerTemplateOutputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.registerTemplateOutputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Register a templated output
+   */
+  async registerTemplateOutput(requestParameters, initOverrides) {
+    const response = await this.registerTemplateOutputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for requestKeyframe without sending the request
+   */
+  async requestKeyframeRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling requestKeyframe().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling requestKeyframe().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/output/{output_id}/request_keyframe`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters
+    };
+  }
+  /**
+   * Request a keyframe
+   */
+  async requestKeyframeRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.requestKeyframeRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Request a keyframe
+   */
+  async requestKeyframe(requestParameters, initOverrides) {
+    const response = await this.requestKeyframeRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for unregisterOutput without sending the request
+   */
+  async unregisterOutputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling unregisterOutput().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling unregisterOutput().'
+      );
+    }
+    if (requestParameters["unregisterOutput"] == null) {
+      throw new RequiredError2(
+        "unregisterOutput",
+        'Required parameter "unregisterOutput" was null or undefined when calling unregisterOutput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/output/{output_id}/unregister`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UnregisterOutputToJSON(requestParameters["unregisterOutput"])
+    };
+  }
+  /**
+   * Unregister an output
+   */
+  async unregisterOutputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.unregisterOutputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Unregister an output
+   */
+  async unregisterOutput(requestParameters, initOverrides) {
+    const response = await this.unregisterOutputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for updateOutput without sending the request
+   */
+  async updateOutputRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling updateOutput().'
+      );
+    }
+    if (requestParameters["outputId"] == null) {
+      throw new RequiredError2(
+        "outputId",
+        'Required parameter "outputId" was null or undefined when calling updateOutput().'
+      );
+    }
+    if (requestParameters["updateOutputRequest"] == null) {
+      throw new RequiredError2(
+        "updateOutputRequest",
+        'Required parameter "updateOutputRequest" was null or undefined when calling updateOutput().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/output/{output_id}/update`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{output_id}", encodeURIComponent(String(requestParameters["outputId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UpdateOutputRequestToJSON(requestParameters["updateOutputRequest"])
+    };
+  }
+  /**
+   * Update an output\'s scene
+   */
+  async updateOutputRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.updateOutputRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Update an output\'s scene
+   */
+  async updateOutput(requestParameters, initOverrides) {
+    const response = await this.updateOutputRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+function instanceOfImageSpecAuto(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("assetType" in value) && !("asset_type" in value) || value["assetType"] === void 0 && value["asset_type"] === void 0)
+    return false;
+  if (value["assetType"] !== "auto" && value["asset_type"] !== "auto")
+    return false;
+  return true;
+}
+function ImageSpecAutoToJSON(json) {
+  return ImageSpecAutoToJSONTyped(json, false);
+}
+function ImageSpecAutoToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    asset_type: value["assetType"]
+  };
+}
+function instanceOfImageSpecGif(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("assetType" in value) && !("asset_type" in value) || value["assetType"] === void 0 && value["asset_type"] === void 0)
+    return false;
+  if (value["assetType"] !== "gif" && value["asset_type"] !== "gif")
+    return false;
+  return true;
+}
+function ImageSpecGifToJSON(json) {
+  return ImageSpecGifToJSONTyped(json, false);
+}
+function ImageSpecGifToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    asset_type: value["assetType"]
+  };
+}
+function instanceOfImageSpecJpeg(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("assetType" in value) && !("asset_type" in value) || value["assetType"] === void 0 && value["asset_type"] === void 0)
+    return false;
+  if (value["assetType"] !== "jpeg" && value["asset_type"] !== "jpeg")
+    return false;
+  return true;
+}
+function ImageSpecJpegToJSON(json) {
+  return ImageSpecJpegToJSONTyped(json, false);
+}
+function ImageSpecJpegToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    asset_type: value["assetType"]
+  };
+}
+function instanceOfImageSpecPng(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("assetType" in value) && !("asset_type" in value) || value["assetType"] === void 0 && value["asset_type"] === void 0)
+    return false;
+  if (value["assetType"] !== "png" && value["asset_type"] !== "png")
+    return false;
+  return true;
+}
+function ImageSpecPngToJSON(json) {
+  return ImageSpecPngToJSONTyped(json, false);
+}
+function ImageSpecPngToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    asset_type: value["assetType"]
+  };
+}
+function instanceOfImageSpecSvg(value) {
+  if (!("url" in value) || value["url"] === void 0) return false;
+  if (!("assetType" in value) && !("asset_type" in value) || value["assetType"] === void 0 && value["asset_type"] === void 0)
+    return false;
+  if (value["assetType"] !== "svg" && value["asset_type"] !== "svg")
+    return false;
+  return true;
+}
+function ImageSpecSvgToJSON(json) {
+  return ImageSpecSvgToJSONTyped(json, false);
+}
+function ImageSpecSvgToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    url: value["url"],
+    resolution: ResolutionToJSON(value["resolution"]),
+    asset_type: value["assetType"]
+  };
+}
+function ImageSpecToJSON(json) {
+  return ImageSpecToJSONTyped(json, false);
+}
+function ImageSpecToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  if (typeof value !== "object") {
+    return value;
+  }
+  if (instanceOfImageSpecAuto(value)) {
+    return ImageSpecAutoToJSON(value);
+  }
+  if (instanceOfImageSpecGif(value)) {
+    return ImageSpecGifToJSON(value);
+  }
+  if (instanceOfImageSpecJpeg(value)) {
+    return ImageSpecJpegToJSON(value);
+  }
+  if (instanceOfImageSpecPng(value)) {
+    return ImageSpecPngToJSON(value);
+  }
+  if (instanceOfImageSpecSvg(value)) {
+    return ImageSpecSvgToJSON(value);
+  }
+  return {};
+}
+function UnregisterRendererToJSON(json) {
+  return UnregisterRendererToJSONTyped(json, false);
+}
+function UnregisterRendererToJSONTyped(value, ignoreDiscriminator = false) {
+  if (value == null) {
+    return value;
+  }
+  return {
+    schedule_time_ms: value["scheduleTimeMs"]
+  };
+}
+var RenderersApi = class extends BaseAPI2 {
+  /**
+   * Creates request options for registerFont without sending the request
+   */
+  async registerFontRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling registerFont().'
+      );
+    }
+    if (requestParameters["font"] == null) {
+      throw new RequiredError2(
+        "font",
+        'Required parameter "font" was null or undefined when calling registerFont().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    const consumes = [{ contentType: "multipart/form-data" }];
+    const canConsumeForm2 = canConsumeForm(consumes);
+    let formParams;
+    let useForm = false;
+    useForm = canConsumeForm2;
+    if (useForm) {
+      formParams = new FormData();
+    } else {
+      formParams = new URLSearchParams();
+    }
+    if (requestParameters["font"] != null) {
+      formParams.append("font", requestParameters["font"]);
+    }
+    let urlPath = `/api/composition/{composition_id}/font/register`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: formParams
+    };
+  }
+  /**
+   * Register a font
+   */
+  async registerFontRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.registerFontRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Register a font
+   */
+  async registerFont(requestParameters, initOverrides) {
+    const response = await this.registerFontRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for registerImage without sending the request
+   */
+  async registerImageRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling registerImage().'
+      );
+    }
+    if (requestParameters["imageId"] == null) {
+      throw new RequiredError2(
+        "imageId",
+        'Required parameter "imageId" was null or undefined when calling registerImage().'
+      );
+    }
+    if (requestParameters["imageSpec"] == null) {
+      throw new RequiredError2(
+        "imageSpec",
+        'Required parameter "imageSpec" was null or undefined when calling registerImage().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/image/{image_id}/register`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{image_id}", encodeURIComponent(String(requestParameters["imageId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: ImageSpecToJSON(requestParameters["imageSpec"])
+    };
+  }
+  /**
+   * Register an image
+   */
+  async registerImageRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.registerImageRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Register an image
+   */
+  async registerImage(requestParameters, initOverrides) {
+    const response = await this.registerImageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+  /**
+   * Creates request options for unregisterImage without sending the request
+   */
+  async unregisterImageRequestOpts(requestParameters) {
+    if (requestParameters["compositionId"] == null) {
+      throw new RequiredError2(
+        "compositionId",
+        'Required parameter "compositionId" was null or undefined when calling unregisterImage().'
+      );
+    }
+    if (requestParameters["imageId"] == null) {
+      throw new RequiredError2(
+        "imageId",
+        'Required parameter "imageId" was null or undefined when calling unregisterImage().'
+      );
+    }
+    if (requestParameters["unregisterRenderer"] == null) {
+      throw new RequiredError2(
+        "unregisterRenderer",
+        'Required parameter "unregisterRenderer" was null or undefined when calling unregisterImage().'
+      );
+    }
+    const queryParameters = {};
+    const headerParameters = {};
+    headerParameters["Content-Type"] = "application/json";
+    if (this.configuration && this.configuration.accessToken) {
+      const token = this.configuration.accessToken;
+      const tokenString = await token("BearerAuth", []);
+      if (tokenString) {
+        headerParameters["Authorization"] = `Bearer ${tokenString}`;
+      }
+    }
+    let urlPath = `/api/composition/{composition_id}/image/{image_id}/unregister`;
+    urlPath = urlPath.replace("{composition_id}", encodeURIComponent(String(requestParameters["compositionId"])));
+    urlPath = urlPath.replace("{image_id}", encodeURIComponent(String(requestParameters["imageId"])));
+    return {
+      path: urlPath,
+      method: "POST",
+      headers: headerParameters,
+      query: queryParameters,
+      body: UnregisterRendererToJSON(requestParameters["unregisterRenderer"])
+    };
+  }
+  /**
+   * Unregister an image
+   */
+  async unregisterImageRaw(requestParameters, initOverrides) {
+    const requestOptions = await this.unregisterImageRequestOpts(requestParameters);
+    const response = await this.request(requestOptions, initOverrides);
+    return new JSONApiResponse2(response);
+  }
+  /**
+   * Unregister an image
+   */
+  async unregisterImage(requestParameters, initOverrides) {
+    const response = await this.unregisterImageRaw(requestParameters, initOverrides);
+    return await response.value();
+  }
+};
+
+// src/exceptions/mapper.ts
+var notFoundException = (info, entity) => {
+  switch (entity) {
+    case "composition":
+      return new CompositionNotFoundException(info);
+    case "credentials":
+      return new InvalidFishjamCredentialsException(info);
+    case "input":
+      return new InputNotFoundException(info);
+    case "output":
+      return new OutputNotFoundException(info);
+    case "peer":
+      return new PeerNotFoundException(info);
+    case "recording":
+      return new RecordingNotFoundException(info);
+    case "renderer":
+      return new RendererNotFoundException(info);
+    case "room":
+      return new RoomNotFoundException(info);
+    default:
+      return new FishjamNotFoundException(info);
+  }
+};
+var mapException = async (error, entity) => {
+  if (error instanceof FetchError || error instanceof FetchError2) {
+    return new UnknownException({ message: error.cause.message, statusCode: 500, details: error.cause.message });
+  }
+  if (!(error instanceof ResponseError) && !(error instanceof ResponseError2)) {
+    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"] ?? body["message"] ?? "Unknown error"
+  };
+  switch (status) {
+    case 400:
+    case 422:
+      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.30.0",
+  description: "Fishjam server SDK for JavaScript",
+  homepage: "https://github.com/fishjam-cloud/js-server-sdk",
+  author: "Fishjam Team",
+  repository: {
+    type: "git",
+    url: "https://github.com/fishjam-cloud/js-server-sdk.git"
+  },
+  bugs: {
+    url: "https://github.com/fishjam-cloud/js-server-sdk/issues"
+  },
+  license: "Apache-2.0",
+  keywords: [
+    "webrtc",
+    "fishjam",
+    "server",
+    "membrane"
+  ],
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  files: [
+    "dist"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.js"
+    },
+    "./gemini": {
+      types: "./dist/integrations/gemini.d.ts",
+      import: "./dist/integrations/gemini.mjs",
+      require: "./dist/integrations/gemini.js"
+    }
+  },
+  scripts: {
+    build: "tsup --dts-resolve",
+    format: "prettier --write .",
+    "format:check": "prettier --check .",
+    typecheck: "tsc --noEmit",
+    lint: "eslint . --fix",
+    "lint:check": "eslint .",
+    test: "vitest run"
+  },
+  tsup: {
+    entry: [
+      "src/index.ts",
+      "src/integrations/gemini.ts",
+      "src/proto.ts"
+    ],
+    noExternal: [
+      "composition-openapi",
+      "fishjam-openapi",
+      "fishjam-proto"
+    ],
+    minify: false,
+    format: [
+      "cjs",
+      "esm"
+    ],
+    outDir: "dist"
+  },
+  dependencies: {
+    uuid: "^11.1.0"
+  },
+  engines: {
+    node: ">=18"
+  },
+  peerDependencies: {
+    "@google/genai": "^1.0.0"
+  },
+  peerDependenciesMeta: {
+    "@google/genai": {
+      optional: true
+    }
+  },
+  devDependencies: {
+    "@fishjam-cloud/composition-openapi": "workspace:*",
+    "@fishjam-cloud/fishjam-openapi": "workspace:*",
     "@fishjam-cloud/fishjam-proto": "workspace:*",
     "@openapitools/openapi-generator-cli": "^2.18.4",
     "@types/node": "^22.13.16",
@@ -6837,6 +9588,8 @@ var FishjamClient = class _FishjamClient {
   viewerApi;
   streamerApi;
   credentialsApi;
+  recordingsApi;
+  trackForwardingsApi;
   fishjamConfig;
   deprecationWarningShown = false;
   /**
@@ -6874,6 +9627,8 @@ var FishjamClient = class _FishjamClient {
     this.viewerApi = new ViewersApi(apiConfig);
     this.streamerApi = new StreamersApi(apiConfig);
     this.credentialsApi = new CredentialsApi(apiConfig);
+    this.recordingsApi = new RecordingsApi(apiConfig);
+    this.trackForwardingsApi = new TrackForwardingsApi(apiConfig);
     this.fishjamConfig = config;
   }
   /**
@@ -7059,6 +9814,29 @@ var FishjamClient = class _FishjamClient {
       throw await mapException(error, "peer");
     }
   }
+  /**
+   * Forwards every track published in the room into a composition, which composes them into
+   * its outputs. Pass the composition's address, as returned by
+   * {@link CompositionClient.compositionUrl}.
+   */
+  async forwardRoomTracks(roomId, compositionUrl) {
+    try {
+      await this.trackForwardingsApi.createTrackForwarding({
+        roomId,
+        trackForwarding: { compositionURL: compositionUrl }
+      });
+    } catch (error) {
+      throw await mapException(error, "room");
+    }
+  }
+  /**
+   * Where to publish a livestream, paired with a token from
+   * {@link FishjamClient.createLivestreamStreamerToken}. A composition reaches viewers by
+   * sending a WHIP output here.
+   */
+  livestreamWhipUrl() {
+    return getLivestreamWhipUrl(this.fishjamConfig);
+  }
   /**
    * Creates a livestream viewer token for the given room.
    * @returns a livestream viewer token
@@ -7092,25 +9870,343 @@ var FishjamClient = class _FishjamClient {
       throw await mapException(error);
     }
   }
+  /**
+   * Create a new recording. Capturing starts synchronously, so the returned recording is `active`.
+   */
+  async createRecording(config) {
+    try {
+      const { data } = await this.recordingsApi.createRecording({ recordingConfig: config });
+      return data;
+    } catch (error) {
+      throw await mapException(error);
+    }
+  }
+  /**
+   * Get details about a given recording.
+   */
+  async getRecording(recordingId) {
+    try {
+      const { data } = await this.recordingsApi.getRecording({ recordingId });
+      return data;
+    } catch (error) {
+      throw await mapException(error, "recording");
+    }
+  }
+  /**
+   * Get a list of all recordings, optionally filtered by metadata.
+   * Returns recordings whose metadata contains all the given key-value pairs.
+   */
+  async getAllRecordings(metadata) {
+    const metadataQuery = metadata ? Object.fromEntries(Object.entries(metadata).map(([key, value]) => [`metadata[${key}]`, value])) : void 0;
+    try {
+      const { data } = await this.recordingsApi.listRecordings({ metadata: metadataQuery });
+      return data ?? [];
+    } catch (error) {
+      throw await mapException(error);
+    }
+  }
+  /**
+   * Stop an active recording. Finalization is asynchronous: the recording stays `active` until
+   * the capture is finalized, then becomes `finished`. Stopping a recording that is no longer active is a no-op.
+   */
+  async stopRecording(recordingId) {
+    try {
+      const { data } = await this.recordingsApi.stopRecording({ recordingId });
+      return data;
+    } catch (error) {
+      throw await mapException(error, "recording");
+    }
+  }
+  /**
+   * Delete a recording. Its stored media is removed asynchronously.
+   * A recording that is still `active` cannot be deleted — stop it first or wait for it to finish.
+   */
+  async deleteRecording(recordingId) {
+    try {
+      await this.recordingsApi.deleteRecording({ recordingId });
+    } catch (error) {
+      throw await mapException(error, "recording");
+    }
+  }
+};
+
+// src/composition.ts
+var CompositionClient = class {
+  compositionsApi;
+  eventsApi;
+  inputsApi;
+  mediaTransportApi;
+  outputsApi;
+  renderersApi;
+  baseUrl;
+  constructor(config) {
+    this.baseUrl = getCompositionOrigin(config);
+    const apiConfig = new Configuration2({
+      basePath: this.baseUrl,
+      headers: { Authorization: `Bearer ${config.managementToken}` }
+    });
+    this.compositionsApi = new CompositionsApi(apiConfig);
+    this.eventsApi = new EventsApi(apiConfig);
+    this.inputsApi = new InputsApi(apiConfig);
+    this.mediaTransportApi = new MediaTransportApi(apiConfig);
+    this.outputsApi = new OutputsApi(apiConfig);
+    this.renderersApi = new RenderersApi(apiConfig);
+  }
+  /**
+   * Create a new composition. Inputs registered on it are composed into the scenes its outputs render.
+   */
+  async createComposition(config = {}) {
+    try {
+      return await this.compositionsApi.createComposition({ createCompositionRequest: config });
+    } catch (error) {
+      throw await mapException(error);
+    }
+  }
+  /**
+   * The address of a composition, as other services refer to it. Fishjam needs it to forward a
+   * room's tracks with {@link FishjamClient.forwardRoomTracks}.
+   */
+  compositionUrl(compositionId) {
+    return new URL(`/api/composition/${compositionId}`, this.baseUrl).href;
+  }
+  /**
+   * Start a composition created with `autostart` disabled. Its outputs begin producing audio and video.
+   */
+  async startComposition(compositionId) {
+    try {
+      await this.compositionsApi.start({ compositionId });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Reset a composition, tearing down its scene while keeping the composition itself alive.
+   */
+  async resetComposition(compositionId) {
+    try {
+      await this.compositionsApi.reset({ compositionId });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Delete an existing composition. Its inputs and outputs are torn down with it.
+   */
+  async deleteComposition(compositionId) {
+    try {
+      await this.compositionsApi.deleteComposition({ compositionId });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register a media source on a composition. Prefer the variant methods, such as
+   * {@link CompositionClient.registerWhipInput}, which return what that input type produces.
+   */
+  async registerInput(compositionId, inputId, input) {
+    try {
+      return await this.inputsApi.registerInput({ compositionId, inputId, registerInput: input });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register an input that a WHIP publisher pushes media into.
+   * @returns the address and token to publish with, see {@link WhipInputTarget}
+   */
+  async registerWhipInput(compositionId, inputId, options = {}) {
+    const { bearerToken, endpointRoute } = await this.registerInput(compositionId, inputId, {
+      ...options,
+      type: "whip_server"
+    });
+    if (!bearerToken) {
+      throw new UnknownException({
+        message: `Could not obtain a publishing token for input "${inputId}", retry or report it`
+      });
+    }
+    const url = endpointRoute ? `${this.compositionUrl(compositionId)}/${endpointRoute.replace(/^\//, "")}` : await this.whipPath(compositionId, inputId);
+    return { url, bearerToken };
+  }
+  /**
+   * Where WHIP publishing is served, for servers that do not report the route themselves.
+   */
+  async whipPath(compositionId, inputId) {
+    const { path } = await this.mediaTransportApi.whipOfferRequestOpts({ compositionId, inputId, body: "" });
+    return new URL(path, this.baseUrl).href;
+  }
+  /**
+   * Register an input that pulls media from a WHEP endpoint.
+   */
+  async registerWhepInput(compositionId, inputId, options) {
+    await this.registerInput(compositionId, inputId, { ...options, type: "whep_client" });
+  }
+  /**
+   * Register an input that plays an MP4 file.
+   * @returns how much media the file holds, see {@link Mp4InputDurations}
+   */
+  async registerMp4Input(compositionId, inputId, options) {
+    const { videoDurationMs, audioDurationMs } = await this.registerInput(compositionId, inputId, {
+      ...options,
+      type: "mp4"
+    });
+    return { videoDurationMs: videoDurationMs ?? void 0, audioDurationMs: audioDurationMs ?? void 0 };
+  }
+  /**
+   * Register an input that an RTMP publisher pushes media into. The stream key identifies the
+   * input; the address to publish to belongs to the composition, not to this call.
+   */
+  async registerRtmpInput(compositionId, inputId, options) {
+    await this.registerInput(compositionId, inputId, { ...options, type: "rtmp_server" });
+  }
+  /**
+   * Unregister an input. Scenes referencing it stop receiving its media.
+   */
+  async unregisterInput(compositionId, inputId, options = {}) {
+    try {
+      await this.inputsApi.unregisterInput({ compositionId, inputId, unregisterInput: options });
+    } catch (error) {
+      throw await mapException(error, "input");
+    }
+  }
+  /**
+   * Register an output, the destination the composed result is sent to, carrying the scene to render.
+   */
+  async registerOutput(compositionId, outputId, output) {
+    try {
+      await this.outputsApi.registerOutput({ compositionId, outputId, registerOutput: output });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register an output rendering a template bundle, as built by `@fishjam-cloud/composition-cli`.
+   * The bundle is either a `Blob` or a path to read it from; never pass a path taken from
+   * untrusted input, since its contents are uploaded.
+   */
+  async registerTemplateOutput(compositionId, outputId, config, template) {
+    try {
+      await this.outputsApi.registerTemplateOutput({
+        compositionId,
+        outputId,
+        config,
+        template: await toBlob(template)
+      });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register an output sending the composed result to a WHIP endpoint.
+   */
+  async registerWhipOutput(compositionId, outputId, options) {
+    await this.registerOutput(compositionId, outputId, { ...options, type: "whip_client" });
+  }
+  /**
+   * Register an output sending the composed result to an RTMP endpoint.
+   */
+  async registerRtmpOutput(compositionId, outputId, options) {
+    await this.registerOutput(compositionId, outputId, { ...options, type: "rtmp_client" });
+  }
+  /**
+   * Unregister an output. It stops producing audio and video.
+   */
+  async unregisterOutput(compositionId, outputId, options = {}) {
+    try {
+      await this.outputsApi.unregisterOutput({ compositionId, outputId, unregisterOutput: options });
+    } catch (error) {
+      throw await mapException(error, "output");
+    }
+  }
+  /**
+   * Replace the scene an output renders.
+   */
+  async updateOutput(compositionId, outputId, update) {
+    try {
+      await this.outputsApi.updateOutput({ compositionId, outputId, updateOutputRequest: update });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Ask an output to emit a keyframe, so a viewer joining mid-stream renders a full picture sooner.
+   */
+  async requestKeyframe(compositionId, outputId) {
+    try {
+      await this.outputsApi.requestKeyframe({ compositionId, outputId });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register an image that scenes can reference by its renderer ID.
+   */
+  async registerImage(compositionId, imageId, image) {
+    try {
+      await this.renderersApi.registerImage({ compositionId, imageId, imageSpec: image });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Register a font that scenes can render text with. The font is either a `Blob` or a path
+   * to read it from; never pass a path taken from untrusted input, since its contents are uploaded.
+   */
+  async registerFont(compositionId, font) {
+    try {
+      await this.renderersApi.registerFont({ compositionId, font: await toBlob(font) });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
+  /**
+   * Unregister a previously registered image.
+   */
+  async unregisterImage(compositionId, imageId, options = {}) {
+    try {
+      await this.renderersApi.unregisterImage({ compositionId, imageId, unregisterRenderer: options });
+    } catch (error) {
+      throw await mapException(error, "renderer");
+    }
+  }
+  /**
+   * Deliver an event to the templates rendered by the composition's outputs.
+   */
+  async sendEvent(compositionId, event) {
+    try {
+      await this.eventsApi.sendCompositionEvent({ compositionId, sendCompositionEventRequest: event });
+    } catch (error) {
+      throw await mapException(error, "composition");
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AudioFormat,
+  AudioSampleRate,
   BadRequestException,
+  CompositionClient,
+  CompositionNotFoundException,
   FishjamAgent,
   FishjamBaseException,
   FishjamClient,
   FishjamNotFoundException,
   FishjamWSNotifier,
   ForbiddenException,
+  InputNotFoundException,
   InvalidFishjamCredentialsException,
   MissingFishjamIdException,
+  OutputNotFoundException,
   PeerNotFoundException,
   PeerStatus,
   QuotaExceededException,
+  RecordingNotFoundException,
+  RendererNotFoundException,
   RoomNotFoundException,
   RoomType,
   ServerMessage,
   ServiceUnavailableException,
+  StaleSdkException,
+  SubscribeMode,
   UnauthorizedException,
   UnknownException,
   VideoCodec,