@aws-sdk/client-ivs-realtime 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,2860 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IVSRealTimeServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./IVSRealTimeClient"), exports);
-tslib_1.__exportStar(require("./IVSRealTime"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var IVSRealTimeServiceException_1 = require("./models/IVSRealTimeServiceException");
-Object.defineProperty(exports, "IVSRealTimeServiceException", { enumerable: true, get: function () { return IVSRealTimeServiceException_1.IVSRealTimeServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessDeniedException: () => AccessDeniedException,
+  CompositionState: () => CompositionState,
+  ConflictException: () => ConflictException,
+  CreateEncoderConfigurationCommand: () => CreateEncoderConfigurationCommand,
+  CreateParticipantTokenCommand: () => CreateParticipantTokenCommand,
+  CreateParticipantTokenResponseFilterSensitiveLog: () => CreateParticipantTokenResponseFilterSensitiveLog,
+  CreateStageCommand: () => CreateStageCommand,
+  CreateStageResponseFilterSensitiveLog: () => CreateStageResponseFilterSensitiveLog,
+  CreateStorageConfigurationCommand: () => CreateStorageConfigurationCommand,
+  DeleteEncoderConfigurationCommand: () => DeleteEncoderConfigurationCommand,
+  DeleteStageCommand: () => DeleteStageCommand,
+  DeleteStorageConfigurationCommand: () => DeleteStorageConfigurationCommand,
+  DestinationState: () => DestinationState,
+  DisconnectParticipantCommand: () => DisconnectParticipantCommand,
+  EventErrorCode: () => EventErrorCode,
+  EventName: () => EventName,
+  GetCompositionCommand: () => GetCompositionCommand,
+  GetEncoderConfigurationCommand: () => GetEncoderConfigurationCommand,
+  GetParticipantCommand: () => GetParticipantCommand,
+  GetStageCommand: () => GetStageCommand,
+  GetStageSessionCommand: () => GetStageSessionCommand,
+  GetStorageConfigurationCommand: () => GetStorageConfigurationCommand,
+  IVSRealTime: () => IVSRealTime,
+  IVSRealTimeClient: () => IVSRealTimeClient,
+  IVSRealTimeServiceException: () => IVSRealTimeServiceException,
+  InternalServerException: () => InternalServerException,
+  ListCompositionsCommand: () => ListCompositionsCommand,
+  ListEncoderConfigurationsCommand: () => ListEncoderConfigurationsCommand,
+  ListParticipantEventsCommand: () => ListParticipantEventsCommand,
+  ListParticipantsCommand: () => ListParticipantsCommand,
+  ListStageSessionsCommand: () => ListStageSessionsCommand,
+  ListStagesCommand: () => ListStagesCommand,
+  ListStorageConfigurationsCommand: () => ListStorageConfigurationsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ParticipantState: () => ParticipantState,
+  ParticipantTokenCapability: () => ParticipantTokenCapability,
+  ParticipantTokenFilterSensitiveLog: () => ParticipantTokenFilterSensitiveLog,
+  PendingVerification: () => PendingVerification,
+  RecordingConfigurationFormat: () => RecordingConfigurationFormat,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartCompositionCommand: () => StartCompositionCommand,
+  StopCompositionCommand: () => StopCompositionCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateStageCommand: () => UpdateStageCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateListCompositions: () => paginateListCompositions,
+  paginateListEncoderConfigurations: () => paginateListEncoderConfigurations,
+  paginateListParticipantEvents: () => paginateListParticipantEvents,
+  paginateListParticipants: () => paginateListParticipants,
+  paginateListStageSessions: () => paginateListStageSessions,
+  paginateListStages: () => paginateListStages,
+  paginateListStorageConfigurations: () => paginateListStorageConfigurations
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/IVSRealTimeClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "ivs"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/IVSRealTimeClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/IVSRealTimeClient.ts
+var _IVSRealTimeClient = class _IVSRealTimeClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_IVSRealTimeClient, "IVSRealTimeClient");
+var IVSRealTimeClient = _IVSRealTimeClient;
+
+// src/IVSRealTime.ts
+
+
+// src/commands/CreateEncoderConfigurationCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/IVSRealTimeServiceException.ts
+
+var _IVSRealTimeServiceException = class _IVSRealTimeServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _IVSRealTimeServiceException.prototype);
+  }
+};
+__name(_IVSRealTimeServiceException, "IVSRealTimeServiceException");
+var IVSRealTimeServiceException = _IVSRealTimeServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var _ConflictException = class _ConflictException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _InternalServerException = class _InternalServerException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var _PendingVerification = class _PendingVerification extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PendingVerification",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PendingVerification";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PendingVerification.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_PendingVerification, "PendingVerification");
+var PendingVerification = _PendingVerification;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _ValidationException = class _ValidationException extends IVSRealTimeServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var ParticipantTokenCapability = {
+  PUBLISH: "PUBLISH",
+  SUBSCRIBE: "SUBSCRIBE"
+};
+var RecordingConfigurationFormat = {
+  HLS: "HLS"
+};
+var DestinationState = {
+  ACTIVE: "ACTIVE",
+  FAILED: "FAILED",
+  RECONNECTING: "RECONNECTING",
+  STARTING: "STARTING",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING"
+};
+var CompositionState = {
+  ACTIVE: "ACTIVE",
+  FAILED: "FAILED",
+  STARTING: "STARTING",
+  STOPPED: "STOPPED",
+  STOPPING: "STOPPING"
+};
+var ParticipantState = {
+  CONNECTED: "CONNECTED",
+  DISCONNECTED: "DISCONNECTED"
+};
+var EventErrorCode = {
+  INSUFFICIENT_CAPABILITIES: "INSUFFICIENT_CAPABILITIES",
+  PUBLISHER_NOT_FOUND: "PUBLISHER_NOT_FOUND",
+  QUOTA_EXCEEDED: "QUOTA_EXCEEDED"
+};
+var EventName = {
+  JOINED: "JOINED",
+  JOIN_ERROR: "JOIN_ERROR",
+  LEFT: "LEFT",
+  PUBLISH_ERROR: "PUBLISH_ERROR",
+  PUBLISH_STARTED: "PUBLISH_STARTED",
+  PUBLISH_STOPPED: "PUBLISH_STOPPED",
+  SUBSCRIBE_ERROR: "SUBSCRIBE_ERROR",
+  SUBSCRIBE_STARTED: "SUBSCRIBE_STARTED",
+  SUBSCRIBE_STOPPED: "SUBSCRIBE_STOPPED"
+};
+var ParticipantTokenFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.token && { token: import_smithy_client.SENSITIVE_STRING }
+}), "ParticipantTokenFilterSensitiveLog");
+var CreateParticipantTokenResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.participantToken && { participantToken: ParticipantTokenFilterSensitiveLog(obj.participantToken) }
+}), "CreateParticipantTokenResponseFilterSensitiveLog");
+var CreateStageResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.participantTokens && {
+    participantTokens: obj.participantTokens.map((item) => ParticipantTokenFilterSensitiveLog(item))
+  }
+}), "CreateStageResponseFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateEncoderConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateEncoderConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      name: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      video: (_) => se_Video(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateEncoderConfigurationCommand");
+var se_CreateParticipantTokenCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateParticipantToken");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      attributes: (_) => (0, import_smithy_client._json)(_),
+      capabilities: (_) => (0, import_smithy_client._json)(_),
+      duration: [],
+      stageArn: [],
+      userId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateParticipantTokenCommand");
+var se_CreateStageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateStage");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      name: [],
+      participantTokenConfigurations: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateStageCommand");
+var se_CreateStorageConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateStorageConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      name: [],
+      s3: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateStorageConfigurationCommand");
+var se_DeleteEncoderConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteEncoderConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteEncoderConfigurationCommand");
+var se_DeleteStageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteStage");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteStageCommand");
+var se_DeleteStorageConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteStorageConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteStorageConfigurationCommand");
+var se_DisconnectParticipantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DisconnectParticipant");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      participantId: [],
+      reason: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DisconnectParticipantCommand");
+var se_GetCompositionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetComposition");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetCompositionCommand");
+var se_GetEncoderConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetEncoderConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetEncoderConfigurationCommand");
+var se_GetParticipantCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetParticipant");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      participantId: [],
+      sessionId: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetParticipantCommand");
+var se_GetStageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStage");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStageCommand");
+var se_GetStageSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStageSession");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      sessionId: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStageSessionCommand");
+var se_GetStorageConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStorageConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStorageConfigurationCommand");
+var se_ListCompositionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListCompositions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filterByEncoderConfigurationArn: [],
+      filterByStageArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListCompositionsCommand");
+var se_ListEncoderConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListEncoderConfigurations");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListEncoderConfigurationsCommand");
+var se_ListParticipantEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListParticipantEvents");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: [],
+      participantId: [],
+      sessionId: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListParticipantEventsCommand");
+var se_ListParticipantsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListParticipants");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filterByPublished: [],
+      filterByState: [],
+      filterByUserId: [],
+      maxResults: [],
+      nextToken: [],
+      sessionId: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListParticipantsCommand");
+var se_ListStagesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStages");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStagesCommand");
+var se_ListStageSessionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStageSessions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: [],
+      stageArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStageSessionsCommand");
+var se_ListStorageConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStorageConfigurations");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStorageConfigurationsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_StartCompositionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/StartComposition");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      destinations: (_) => (0, import_smithy_client._json)(_),
+      idempotencyToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      layout: (_) => (0, import_smithy_client._json)(_),
+      stageArn: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartCompositionCommand");
+var se_StopCompositionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/StopComposition");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopCompositionCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateStageCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/UpdateStage");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: [],
+      name: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateStageCommand");
+var de_CreateEncoderConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateEncoderConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    encoderConfiguration: (_) => de_EncoderConfiguration(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateEncoderConfigurationCommand");
+var de_CreateEncoderConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateEncoderConfigurationCommandError");
+var de_CreateParticipantTokenCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateParticipantTokenCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    participantToken: (_) => de_ParticipantToken(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateParticipantTokenCommand");
+var de_CreateParticipantTokenCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateParticipantTokenCommandError");
+var de_CreateStageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateStageCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    participantTokens: (_) => de_ParticipantTokenList(_, context),
+    stage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateStageCommand");
+var de_CreateStageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateStageCommandError");
+var de_CreateStorageConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateStorageConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    storageConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateStorageConfigurationCommand");
+var de_CreateStorageConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateStorageConfigurationCommandError");
+var de_DeleteEncoderConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteEncoderConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteEncoderConfigurationCommand");
+var de_DeleteEncoderConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteEncoderConfigurationCommandError");
+var de_DeleteStageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteStageCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteStageCommand");
+var de_DeleteStageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStageCommandError");
+var de_DeleteStorageConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteStorageConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteStorageConfigurationCommand");
+var de_DeleteStorageConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStorageConfigurationCommandError");
+var de_DisconnectParticipantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DisconnectParticipantCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DisconnectParticipantCommand");
+var de_DisconnectParticipantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisconnectParticipantCommandError");
+var de_GetCompositionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetCompositionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    composition: (_) => de_Composition(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetCompositionCommand");
+var de_GetCompositionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetCompositionCommandError");
+var de_GetEncoderConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetEncoderConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    encoderConfiguration: (_) => de_EncoderConfiguration(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetEncoderConfigurationCommand");
+var de_GetEncoderConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetEncoderConfigurationCommandError");
+var de_GetParticipantCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetParticipantCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    participant: (_) => de_Participant(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetParticipantCommand");
+var de_GetParticipantCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetParticipantCommandError");
+var de_GetStageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStageCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    stage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStageCommand");
+var de_GetStageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStageCommandError");
+var de_GetStageSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStageSessionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    stageSession: (_) => de_StageSession(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStageSessionCommand");
+var de_GetStageSessionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStageSessionCommandError");
+var de_GetStorageConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStorageConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    storageConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStorageConfigurationCommand");
+var de_GetStorageConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStorageConfigurationCommandError");
+var de_ListCompositionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListCompositionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    compositions: (_) => de_CompositionSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListCompositionsCommand");
+var de_ListCompositionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListCompositionsCommandError");
+var de_ListEncoderConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListEncoderConfigurationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    encoderConfigurations: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListEncoderConfigurationsCommand");
+var de_ListEncoderConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListEncoderConfigurationsCommandError");
+var de_ListParticipantEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListParticipantEventsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    events: (_) => de_EventList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListParticipantEventsCommand");
+var de_ListParticipantEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListParticipantEventsCommandError");
+var de_ListParticipantsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListParticipantsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    participants: (_) => de_ParticipantList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListParticipantsCommand");
+var de_ListParticipantsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListParticipantsCommandError");
+var de_ListStagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStagesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    stages: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStagesCommand");
+var de_ListStagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStagesCommandError");
+var de_ListStageSessionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStageSessionsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    stageSessions: (_) => de_StageSessionList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStageSessionsCommand");
+var de_ListStageSessionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStageSessionsCommandError");
+var de_ListStorageConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStorageConfigurationsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    storageConfigurations: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStorageConfigurationsCommand");
+var de_ListStorageConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStorageConfigurationsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_StartCompositionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartCompositionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    composition: (_) => de_Composition(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartCompositionCommand");
+var de_StartCompositionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartCompositionCommandError");
+var de_StopCompositionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopCompositionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StopCompositionCommand");
+var de_StopCompositionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivsrealtime#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopCompositionCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerException":
+    case "com.amazonaws.ivsrealtime#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateStageCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateStageCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    stage: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateStageCommand");
+var de_UpdateStageCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ivsrealtime#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivsrealtime#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivsrealtime#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivsrealtime#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivsrealtime#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateStageCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(IVSRealTimeServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_PendingVerificationRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new PendingVerification({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_PendingVerificationRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    exceptionMessage: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_Video = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    bitrate: [],
+    framerate: import_smithy_client.serializeFloat,
+    height: [],
+    width: []
+  });
+}, "se_Video");
+var de_Composition = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    destinations: (_) => de_DestinationList(_, context),
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    layout: import_smithy_client._json,
+    stageArn: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_Composition");
+var de_CompositionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    destinations: (_) => de_DestinationSummaryList(_, context),
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    stageArn: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_CompositionSummary");
+var de_CompositionSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CompositionSummary(entry, context);
+  });
+  return retVal;
+}, "de_CompositionSummaryList");
+var de_Destination = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    configuration: import_smithy_client._json,
+    detail: import_smithy_client._json,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    id: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString
+  });
+}, "de_Destination");
+var de_DestinationList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Destination(entry, context);
+  });
+  return retVal;
+}, "de_DestinationList");
+var de_DestinationSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    id: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString
+  });
+}, "de_DestinationSummary");
+var de_DestinationSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_DestinationSummary(entry, context);
+  });
+  return retVal;
+}, "de_DestinationSummaryList");
+var de_EncoderConfiguration = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    name: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    video: (_) => de_Video(_, context)
+  });
+}, "de_EncoderConfiguration");
+var de_Event = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    errorCode: import_smithy_client.expectString,
+    eventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    name: import_smithy_client.expectString,
+    participantId: import_smithy_client.expectString,
+    remoteParticipantId: import_smithy_client.expectString
+  });
+}, "de_Event");
+var de_EventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Event(entry, context);
+  });
+  return retVal;
+}, "de_EventList");
+var de_Participant = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    attributes: import_smithy_client._json,
+    browserName: import_smithy_client.expectString,
+    browserVersion: import_smithy_client.expectString,
+    firstJoinTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ispName: import_smithy_client.expectString,
+    osName: import_smithy_client.expectString,
+    osVersion: import_smithy_client.expectString,
+    participantId: import_smithy_client.expectString,
+    published: import_smithy_client.expectBoolean,
+    sdkVersion: import_smithy_client.expectString,
+    state: import_smithy_client.expectString,
+    userId: import_smithy_client.expectString
+  });
+}, "de_Participant");
+var de_ParticipantList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ParticipantSummary(entry, context);
+  });
+  return retVal;
+}, "de_ParticipantList");
+var de_ParticipantSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    firstJoinTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    participantId: import_smithy_client.expectString,
+    published: import_smithy_client.expectBoolean,
+    state: import_smithy_client.expectString,
+    userId: import_smithy_client.expectString
+  });
+}, "de_ParticipantSummary");
+var de_ParticipantToken = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    attributes: import_smithy_client._json,
+    capabilities: import_smithy_client._json,
+    duration: import_smithy_client.expectInt32,
+    expirationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    participantId: import_smithy_client.expectString,
+    token: import_smithy_client.expectString,
+    userId: import_smithy_client.expectString
+  });
+}, "de_ParticipantToken");
+var de_ParticipantTokenList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_ParticipantToken(entry, context);
+  });
+  return retVal;
+}, "de_ParticipantTokenList");
+var de_StageSession = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    sessionId: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_StageSession");
+var de_StageSessionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StageSessionSummary(entry, context);
+  });
+  return retVal;
+}, "de_StageSessionList");
+var de_StageSessionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    sessionId: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_))
+  });
+}, "de_StageSessionSummary");
+var de_Video = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    bitrate: import_smithy_client.expectInt32,
+    framerate: import_smithy_client.limitedParseFloat32,
+    height: import_smithy_client.expectInt32,
+    width: import_smithy_client.expectInt32
+  });
+}, "de_Video");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _tK = "tagKeys";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateEncoderConfigurationCommand.ts
+var _CreateEncoderConfigurationCommand = class _CreateEncoderConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "CreateEncoderConfiguration", {}).n("IVSRealTimeClient", "CreateEncoderConfigurationCommand").f(void 0, void 0).ser(se_CreateEncoderConfigurationCommand).de(de_CreateEncoderConfigurationCommand).build() {
+};
+__name(_CreateEncoderConfigurationCommand, "CreateEncoderConfigurationCommand");
+var CreateEncoderConfigurationCommand = _CreateEncoderConfigurationCommand;
+
+// src/commands/CreateParticipantTokenCommand.ts
+
+
+
+
+var _CreateParticipantTokenCommand = class _CreateParticipantTokenCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "CreateParticipantToken", {}).n("IVSRealTimeClient", "CreateParticipantTokenCommand").f(void 0, CreateParticipantTokenResponseFilterSensitiveLog).ser(se_CreateParticipantTokenCommand).de(de_CreateParticipantTokenCommand).build() {
+};
+__name(_CreateParticipantTokenCommand, "CreateParticipantTokenCommand");
+var CreateParticipantTokenCommand = _CreateParticipantTokenCommand;
+
+// src/commands/CreateStageCommand.ts
+
+
+
+
+var _CreateStageCommand = class _CreateStageCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "CreateStage", {}).n("IVSRealTimeClient", "CreateStageCommand").f(void 0, CreateStageResponseFilterSensitiveLog).ser(se_CreateStageCommand).de(de_CreateStageCommand).build() {
+};
+__name(_CreateStageCommand, "CreateStageCommand");
+var CreateStageCommand = _CreateStageCommand;
+
+// src/commands/CreateStorageConfigurationCommand.ts
+
+
+
+
+var _CreateStorageConfigurationCommand = class _CreateStorageConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "CreateStorageConfiguration", {}).n("IVSRealTimeClient", "CreateStorageConfigurationCommand").f(void 0, void 0).ser(se_CreateStorageConfigurationCommand).de(de_CreateStorageConfigurationCommand).build() {
+};
+__name(_CreateStorageConfigurationCommand, "CreateStorageConfigurationCommand");
+var CreateStorageConfigurationCommand = _CreateStorageConfigurationCommand;
+
+// src/commands/DeleteEncoderConfigurationCommand.ts
+
+
+
+
+var _DeleteEncoderConfigurationCommand = class _DeleteEncoderConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "DeleteEncoderConfiguration", {}).n("IVSRealTimeClient", "DeleteEncoderConfigurationCommand").f(void 0, void 0).ser(se_DeleteEncoderConfigurationCommand).de(de_DeleteEncoderConfigurationCommand).build() {
+};
+__name(_DeleteEncoderConfigurationCommand, "DeleteEncoderConfigurationCommand");
+var DeleteEncoderConfigurationCommand = _DeleteEncoderConfigurationCommand;
+
+// src/commands/DeleteStageCommand.ts
+
+
+
+
+var _DeleteStageCommand = class _DeleteStageCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "DeleteStage", {}).n("IVSRealTimeClient", "DeleteStageCommand").f(void 0, void 0).ser(se_DeleteStageCommand).de(de_DeleteStageCommand).build() {
+};
+__name(_DeleteStageCommand, "DeleteStageCommand");
+var DeleteStageCommand = _DeleteStageCommand;
+
+// src/commands/DeleteStorageConfigurationCommand.ts
+
+
+
+
+var _DeleteStorageConfigurationCommand = class _DeleteStorageConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "DeleteStorageConfiguration", {}).n("IVSRealTimeClient", "DeleteStorageConfigurationCommand").f(void 0, void 0).ser(se_DeleteStorageConfigurationCommand).de(de_DeleteStorageConfigurationCommand).build() {
+};
+__name(_DeleteStorageConfigurationCommand, "DeleteStorageConfigurationCommand");
+var DeleteStorageConfigurationCommand = _DeleteStorageConfigurationCommand;
+
+// src/commands/DisconnectParticipantCommand.ts
+
+
+
+
+var _DisconnectParticipantCommand = class _DisconnectParticipantCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "DisconnectParticipant", {}).n("IVSRealTimeClient", "DisconnectParticipantCommand").f(void 0, void 0).ser(se_DisconnectParticipantCommand).de(de_DisconnectParticipantCommand).build() {
+};
+__name(_DisconnectParticipantCommand, "DisconnectParticipantCommand");
+var DisconnectParticipantCommand = _DisconnectParticipantCommand;
+
+// src/commands/GetCompositionCommand.ts
+
+
+
+
+var _GetCompositionCommand = class _GetCompositionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetComposition", {}).n("IVSRealTimeClient", "GetCompositionCommand").f(void 0, void 0).ser(se_GetCompositionCommand).de(de_GetCompositionCommand).build() {
+};
+__name(_GetCompositionCommand, "GetCompositionCommand");
+var GetCompositionCommand = _GetCompositionCommand;
+
+// src/commands/GetEncoderConfigurationCommand.ts
+
+
+
+
+var _GetEncoderConfigurationCommand = class _GetEncoderConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetEncoderConfiguration", {}).n("IVSRealTimeClient", "GetEncoderConfigurationCommand").f(void 0, void 0).ser(se_GetEncoderConfigurationCommand).de(de_GetEncoderConfigurationCommand).build() {
+};
+__name(_GetEncoderConfigurationCommand, "GetEncoderConfigurationCommand");
+var GetEncoderConfigurationCommand = _GetEncoderConfigurationCommand;
+
+// src/commands/GetParticipantCommand.ts
+
+
+
+
+var _GetParticipantCommand = class _GetParticipantCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetParticipant", {}).n("IVSRealTimeClient", "GetParticipantCommand").f(void 0, void 0).ser(se_GetParticipantCommand).de(de_GetParticipantCommand).build() {
+};
+__name(_GetParticipantCommand, "GetParticipantCommand");
+var GetParticipantCommand = _GetParticipantCommand;
+
+// src/commands/GetStageCommand.ts
+
+
+
+
+var _GetStageCommand = class _GetStageCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetStage", {}).n("IVSRealTimeClient", "GetStageCommand").f(void 0, void 0).ser(se_GetStageCommand).de(de_GetStageCommand).build() {
+};
+__name(_GetStageCommand, "GetStageCommand");
+var GetStageCommand = _GetStageCommand;
+
+// src/commands/GetStageSessionCommand.ts
+
+
+
+
+var _GetStageSessionCommand = class _GetStageSessionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetStageSession", {}).n("IVSRealTimeClient", "GetStageSessionCommand").f(void 0, void 0).ser(se_GetStageSessionCommand).de(de_GetStageSessionCommand).build() {
+};
+__name(_GetStageSessionCommand, "GetStageSessionCommand");
+var GetStageSessionCommand = _GetStageSessionCommand;
+
+// src/commands/GetStorageConfigurationCommand.ts
+
+
+
+
+var _GetStorageConfigurationCommand = class _GetStorageConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "GetStorageConfiguration", {}).n("IVSRealTimeClient", "GetStorageConfigurationCommand").f(void 0, void 0).ser(se_GetStorageConfigurationCommand).de(de_GetStorageConfigurationCommand).build() {
+};
+__name(_GetStorageConfigurationCommand, "GetStorageConfigurationCommand");
+var GetStorageConfigurationCommand = _GetStorageConfigurationCommand;
+
+// src/commands/ListCompositionsCommand.ts
+
+
+
+
+var _ListCompositionsCommand = class _ListCompositionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListCompositions", {}).n("IVSRealTimeClient", "ListCompositionsCommand").f(void 0, void 0).ser(se_ListCompositionsCommand).de(de_ListCompositionsCommand).build() {
+};
+__name(_ListCompositionsCommand, "ListCompositionsCommand");
+var ListCompositionsCommand = _ListCompositionsCommand;
+
+// src/commands/ListEncoderConfigurationsCommand.ts
+
+
+
+
+var _ListEncoderConfigurationsCommand = class _ListEncoderConfigurationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListEncoderConfigurations", {}).n("IVSRealTimeClient", "ListEncoderConfigurationsCommand").f(void 0, void 0).ser(se_ListEncoderConfigurationsCommand).de(de_ListEncoderConfigurationsCommand).build() {
+};
+__name(_ListEncoderConfigurationsCommand, "ListEncoderConfigurationsCommand");
+var ListEncoderConfigurationsCommand = _ListEncoderConfigurationsCommand;
+
+// src/commands/ListParticipantEventsCommand.ts
+
+
+
+
+var _ListParticipantEventsCommand = class _ListParticipantEventsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListParticipantEvents", {}).n("IVSRealTimeClient", "ListParticipantEventsCommand").f(void 0, void 0).ser(se_ListParticipantEventsCommand).de(de_ListParticipantEventsCommand).build() {
+};
+__name(_ListParticipantEventsCommand, "ListParticipantEventsCommand");
+var ListParticipantEventsCommand = _ListParticipantEventsCommand;
+
+// src/commands/ListParticipantsCommand.ts
+
+
+
+
+var _ListParticipantsCommand = class _ListParticipantsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListParticipants", {}).n("IVSRealTimeClient", "ListParticipantsCommand").f(void 0, void 0).ser(se_ListParticipantsCommand).de(de_ListParticipantsCommand).build() {
+};
+__name(_ListParticipantsCommand, "ListParticipantsCommand");
+var ListParticipantsCommand = _ListParticipantsCommand;
+
+// src/commands/ListStagesCommand.ts
+
+
+
+
+var _ListStagesCommand = class _ListStagesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListStages", {}).n("IVSRealTimeClient", "ListStagesCommand").f(void 0, void 0).ser(se_ListStagesCommand).de(de_ListStagesCommand).build() {
+};
+__name(_ListStagesCommand, "ListStagesCommand");
+var ListStagesCommand = _ListStagesCommand;
+
+// src/commands/ListStageSessionsCommand.ts
+
+
+
+
+var _ListStageSessionsCommand = class _ListStageSessionsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListStageSessions", {}).n("IVSRealTimeClient", "ListStageSessionsCommand").f(void 0, void 0).ser(se_ListStageSessionsCommand).de(de_ListStageSessionsCommand).build() {
+};
+__name(_ListStageSessionsCommand, "ListStageSessionsCommand");
+var ListStageSessionsCommand = _ListStageSessionsCommand;
+
+// src/commands/ListStorageConfigurationsCommand.ts
+
+
+
+
+var _ListStorageConfigurationsCommand = class _ListStorageConfigurationsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListStorageConfigurations", {}).n("IVSRealTimeClient", "ListStorageConfigurationsCommand").f(void 0, void 0).ser(se_ListStorageConfigurationsCommand).de(de_ListStorageConfigurationsCommand).build() {
+};
+__name(_ListStorageConfigurationsCommand, "ListStorageConfigurationsCommand");
+var ListStorageConfigurationsCommand = _ListStorageConfigurationsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "ListTagsForResource", {}).n("IVSRealTimeClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/StartCompositionCommand.ts
+
+
+
+
+var _StartCompositionCommand = class _StartCompositionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "StartComposition", {}).n("IVSRealTimeClient", "StartCompositionCommand").f(void 0, void 0).ser(se_StartCompositionCommand).de(de_StartCompositionCommand).build() {
+};
+__name(_StartCompositionCommand, "StartCompositionCommand");
+var StartCompositionCommand = _StartCompositionCommand;
+
+// src/commands/StopCompositionCommand.ts
+
+
+
+
+var _StopCompositionCommand = class _StopCompositionCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "StopComposition", {}).n("IVSRealTimeClient", "StopCompositionCommand").f(void 0, void 0).ser(se_StopCompositionCommand).de(de_StopCompositionCommand).build() {
+};
+__name(_StopCompositionCommand, "StopCompositionCommand");
+var StopCompositionCommand = _StopCompositionCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "TagResource", {}).n("IVSRealTimeClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "UntagResource", {}).n("IVSRealTimeClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateStageCommand.ts
+
+
+
+
+var _UpdateStageCommand = class _UpdateStageCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonInteractiveVideoServiceRealTime", "UpdateStage", {}).n("IVSRealTimeClient", "UpdateStageCommand").f(void 0, void 0).ser(se_UpdateStageCommand).de(de_UpdateStageCommand).build() {
+};
+__name(_UpdateStageCommand, "UpdateStageCommand");
+var UpdateStageCommand = _UpdateStageCommand;
+
+// src/IVSRealTime.ts
+var commands = {
+  CreateEncoderConfigurationCommand,
+  CreateParticipantTokenCommand,
+  CreateStageCommand,
+  CreateStorageConfigurationCommand,
+  DeleteEncoderConfigurationCommand,
+  DeleteStageCommand,
+  DeleteStorageConfigurationCommand,
+  DisconnectParticipantCommand,
+  GetCompositionCommand,
+  GetEncoderConfigurationCommand,
+  GetParticipantCommand,
+  GetStageCommand,
+  GetStageSessionCommand,
+  GetStorageConfigurationCommand,
+  ListCompositionsCommand,
+  ListEncoderConfigurationsCommand,
+  ListParticipantEventsCommand,
+  ListParticipantsCommand,
+  ListStagesCommand,
+  ListStageSessionsCommand,
+  ListStorageConfigurationsCommand,
+  ListTagsForResourceCommand,
+  StartCompositionCommand,
+  StopCompositionCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateStageCommand
+};
+var _IVSRealTime = class _IVSRealTime extends IVSRealTimeClient {
+};
+__name(_IVSRealTime, "IVSRealTime");
+var IVSRealTime = _IVSRealTime;
+(0, import_smithy_client.createAggregatedClient)(commands, IVSRealTime);
+
+// src/pagination/ListCompositionsPaginator.ts
+
+var paginateListCompositions = (0, import_core.createPaginator)(IVSRealTimeClient, ListCompositionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListEncoderConfigurationsPaginator.ts
+
+var paginateListEncoderConfigurations = (0, import_core.createPaginator)(IVSRealTimeClient, ListEncoderConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListParticipantEventsPaginator.ts
+
+var paginateListParticipantEvents = (0, import_core.createPaginator)(IVSRealTimeClient, ListParticipantEventsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListParticipantsPaginator.ts
+
+var paginateListParticipants = (0, import_core.createPaginator)(IVSRealTimeClient, ListParticipantsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStageSessionsPaginator.ts
+
+var paginateListStageSessions = (0, import_core.createPaginator)(IVSRealTimeClient, ListStageSessionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStagesPaginator.ts
+
+var paginateListStages = (0, import_core.createPaginator)(IVSRealTimeClient, ListStagesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStorageConfigurationsPaginator.ts
+
+var paginateListStorageConfigurations = (0, import_core.createPaginator)(IVSRealTimeClient, ListStorageConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AccessDeniedException,
+  CompositionState,
+  ConflictException,
+  CreateEncoderConfigurationCommand,
+  CreateParticipantTokenCommand,
+  CreateParticipantTokenResponseFilterSensitiveLog,
+  CreateStageCommand,
+  CreateStageResponseFilterSensitiveLog,
+  CreateStorageConfigurationCommand,
+  DeleteEncoderConfigurationCommand,
+  DeleteStageCommand,
+  DeleteStorageConfigurationCommand,
+  DestinationState,
+  DisconnectParticipantCommand,
+  EventErrorCode,
+  EventName,
+  GetCompositionCommand,
+  GetEncoderConfigurationCommand,
+  GetParticipantCommand,
+  GetStageCommand,
+  GetStageSessionCommand,
+  GetStorageConfigurationCommand,
+  IVSRealTime,
+  IVSRealTimeClient,
+  IVSRealTimeServiceException,
+  InternalServerException,
+  ListCompositionsCommand,
+  ListEncoderConfigurationsCommand,
+  ListParticipantEventsCommand,
+  ListParticipantsCommand,
+  ListStageSessionsCommand,
+  ListStagesCommand,
+  ListStorageConfigurationsCommand,
+  ListTagsForResourceCommand,
+  ParticipantState,
+  ParticipantTokenCapability,
+  ParticipantTokenFilterSensitiveLog,
+  PendingVerification,
+  RecordingConfigurationFormat,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  StartCompositionCommand,
+  StopCompositionCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateStageCommand,
+  ValidationException,
+  __Client,
+  paginateListCompositions,
+  paginateListEncoderConfigurations,
+  paginateListParticipantEvents,
+  paginateListParticipants,
+  paginateListStageSessions,
+  paginateListStages,
+  paginateListStorageConfigurations
+});