@aws-sdk/client-ivs 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3028 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IvsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./IvsClient"), exports);
-tslib_1.__exportStar(require("./Ivs"), 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 IvsServiceException_1 = require("./models/IvsServiceException");
-Object.defineProperty(exports, "IvsServiceException", { enumerable: true, get: function () { return IvsServiceException_1.IvsServiceException; } });
+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,
+  BatchGetChannelCommand: () => BatchGetChannelCommand,
+  BatchGetStreamKeyCommand: () => BatchGetStreamKeyCommand,
+  BatchGetStreamKeyResponseFilterSensitiveLog: () => BatchGetStreamKeyResponseFilterSensitiveLog,
+  BatchStartViewerSessionRevocationCommand: () => BatchStartViewerSessionRevocationCommand,
+  ChannelLatencyMode: () => ChannelLatencyMode,
+  ChannelNotBroadcasting: () => ChannelNotBroadcasting,
+  ChannelType: () => ChannelType,
+  ConflictException: () => ConflictException,
+  CreateChannelCommand: () => CreateChannelCommand,
+  CreateChannelResponseFilterSensitiveLog: () => CreateChannelResponseFilterSensitiveLog,
+  CreateRecordingConfigurationCommand: () => CreateRecordingConfigurationCommand,
+  CreateStreamKeyCommand: () => CreateStreamKeyCommand,
+  CreateStreamKeyResponseFilterSensitiveLog: () => CreateStreamKeyResponseFilterSensitiveLog,
+  DeleteChannelCommand: () => DeleteChannelCommand,
+  DeletePlaybackKeyPairCommand: () => DeletePlaybackKeyPairCommand,
+  DeleteRecordingConfigurationCommand: () => DeleteRecordingConfigurationCommand,
+  DeleteStreamKeyCommand: () => DeleteStreamKeyCommand,
+  GetChannelCommand: () => GetChannelCommand,
+  GetPlaybackKeyPairCommand: () => GetPlaybackKeyPairCommand,
+  GetRecordingConfigurationCommand: () => GetRecordingConfigurationCommand,
+  GetStreamCommand: () => GetStreamCommand,
+  GetStreamKeyCommand: () => GetStreamKeyCommand,
+  GetStreamKeyResponseFilterSensitiveLog: () => GetStreamKeyResponseFilterSensitiveLog,
+  GetStreamSessionCommand: () => GetStreamSessionCommand,
+  ImportPlaybackKeyPairCommand: () => ImportPlaybackKeyPairCommand,
+  InternalServerException: () => InternalServerException,
+  Ivs: () => Ivs,
+  IvsClient: () => IvsClient,
+  IvsServiceException: () => IvsServiceException,
+  ListChannelsCommand: () => ListChannelsCommand,
+  ListPlaybackKeyPairsCommand: () => ListPlaybackKeyPairsCommand,
+  ListRecordingConfigurationsCommand: () => ListRecordingConfigurationsCommand,
+  ListStreamKeysCommand: () => ListStreamKeysCommand,
+  ListStreamSessionsCommand: () => ListStreamSessionsCommand,
+  ListStreamsCommand: () => ListStreamsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  PendingVerification: () => PendingVerification,
+  PutMetadataCommand: () => PutMetadataCommand,
+  PutMetadataRequestFilterSensitiveLog: () => PutMetadataRequestFilterSensitiveLog,
+  RecordingConfigurationState: () => RecordingConfigurationState,
+  RecordingMode: () => RecordingMode,
+  RenditionConfigurationRendition: () => RenditionConfigurationRendition,
+  RenditionConfigurationRenditionSelection: () => RenditionConfigurationRenditionSelection,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  StartViewerSessionRevocationCommand: () => StartViewerSessionRevocationCommand,
+  StopStreamCommand: () => StopStreamCommand,
+  StreamHealth: () => StreamHealth,
+  StreamKeyFilterSensitiveLog: () => StreamKeyFilterSensitiveLog,
+  StreamState: () => StreamState,
+  StreamUnavailable: () => StreamUnavailable,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  ThumbnailConfigurationResolution: () => ThumbnailConfigurationResolution,
+  ThumbnailConfigurationStorage: () => ThumbnailConfigurationStorage,
+  TranscodePreset: () => TranscodePreset,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateChannelCommand: () => UpdateChannelCommand,
+  ValidationException: () => ValidationException,
+  __Client: () => import_smithy_client.Client,
+  paginateListChannels: () => paginateListChannels,
+  paginateListPlaybackKeyPairs: () => paginateListPlaybackKeyPairs,
+  paginateListRecordingConfigurations: () => paginateListRecordingConfigurations,
+  paginateListStreamKeys: () => paginateListStreamKeys,
+  paginateListStreamSessions: () => paginateListStreamSessions,
+  paginateListStreams: () => paginateListStreams
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/IvsClient.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/IvsClient.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/IvsClient.ts
+var _IvsClient = class _IvsClient 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(_IvsClient, "IvsClient");
+var IvsClient = _IvsClient;
+
+// src/Ivs.ts
+
+
+// src/commands/BatchGetChannelCommand.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");
+
+
+// src/models/IvsServiceException.ts
+
+var _IvsServiceException = class _IvsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _IvsServiceException.prototype);
+  }
+};
+__name(_IvsServiceException, "IvsServiceException");
+var IvsServiceException = _IvsServiceException;
+
+// src/models/models_0.ts
+
+var _AccessDeniedException = class _AccessDeniedException extends IvsServiceException {
+  /**
+   * @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 ChannelLatencyMode = {
+  LowLatency: "LOW",
+  NormalLatency: "NORMAL"
+};
+var TranscodePreset = {
+  ConstrainedBandwidthTranscodePreset: "CONSTRAINED_BANDWIDTH_DELIVERY",
+  HigherBandwidthTranscodePreset: "HIGHER_BANDWIDTH_DELIVERY"
+};
+var ChannelType = {
+  AdvancedHDChannelType: "ADVANCED_HD",
+  AdvancedSDChannelType: "ADVANCED_SD",
+  BasicChannelType: "BASIC",
+  StandardChannelType: "STANDARD"
+};
+var _PendingVerification = class _PendingVerification extends IvsServiceException {
+  /**
+   * @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 _ThrottlingException = class _ThrottlingException extends IvsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends IvsServiceException {
+  /**
+   * @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 _ResourceNotFoundException = class _ResourceNotFoundException extends IvsServiceException {
+  /**
+   * @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 IvsServiceException {
+  /**
+   * @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 _ConflictException = class _ConflictException extends IvsServiceException {
+  /**
+   * @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 RenditionConfigurationRendition = {
+  FULL_HD: "FULL_HD",
+  HD: "HD",
+  LOWEST_RESOLUTION: "LOWEST_RESOLUTION",
+  SD: "SD"
+};
+var RenditionConfigurationRenditionSelection = {
+  ALL: "ALL",
+  CUSTOM: "CUSTOM",
+  NONE: "NONE"
+};
+var RecordingMode = {
+  Disabled: "DISABLED",
+  Interval: "INTERVAL"
+};
+var ThumbnailConfigurationResolution = {
+  FULL_HD: "FULL_HD",
+  HD: "HD",
+  LOWEST_RESOLUTION: "LOWEST_RESOLUTION",
+  SD: "SD"
+};
+var ThumbnailConfigurationStorage = {
+  LATEST: "LATEST",
+  SEQUENTIAL: "SEQUENTIAL"
+};
+var RecordingConfigurationState = {
+  Active: "ACTIVE",
+  CreateFailed: "CREATE_FAILED",
+  Creating: "CREATING"
+};
+var _InternalServerException = class _InternalServerException extends IvsServiceException {
+  /**
+   * @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 _ChannelNotBroadcasting = class _ChannelNotBroadcasting extends IvsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ChannelNotBroadcasting",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ChannelNotBroadcasting";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ChannelNotBroadcasting.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_ChannelNotBroadcasting, "ChannelNotBroadcasting");
+var ChannelNotBroadcasting = _ChannelNotBroadcasting;
+var StreamHealth = {
+  Starving: "STARVING",
+  StreamHealthy: "HEALTHY",
+  Unknown: "UNKNOWN"
+};
+var StreamState = {
+  StreamLive: "LIVE",
+  StreamOffline: "OFFLINE"
+};
+var _StreamUnavailable = class _StreamUnavailable extends IvsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "StreamUnavailable",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "StreamUnavailable";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _StreamUnavailable.prototype);
+    this.exceptionMessage = opts.exceptionMessage;
+  }
+};
+__name(_StreamUnavailable, "StreamUnavailable");
+var StreamUnavailable = _StreamUnavailable;
+var StreamKeyFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.value && { value: import_smithy_client.SENSITIVE_STRING }
+}), "StreamKeyFilterSensitiveLog");
+var BatchGetStreamKeyResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.streamKeys && { streamKeys: obj.streamKeys.map((item) => StreamKeyFilterSensitiveLog(item)) }
+}), "BatchGetStreamKeyResponseFilterSensitiveLog");
+var CreateChannelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }
+}), "CreateChannelResponseFilterSensitiveLog");
+var CreateStreamKeyResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }
+}), "CreateStreamKeyResponseFilterSensitiveLog");
+var GetStreamKeyResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.streamKey && { streamKey: StreamKeyFilterSensitiveLog(obj.streamKey) }
+}), "GetStreamKeyResponseFilterSensitiveLog");
+var PutMetadataRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj,
+  ...obj.metadata && { metadata: import_smithy_client.SENSITIVE_STRING }
+}), "PutMetadataRequestFilterSensitiveLog");
+
+// src/protocols/Aws_restJson1.ts
+var se_BatchGetChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/BatchGetChannel");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arns: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchGetChannelCommand");
+var se_BatchGetStreamKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/BatchGetStreamKey");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arns: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchGetStreamKeyCommand");
+var se_BatchStartViewerSessionRevocationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/BatchStartViewerSessionRevocation");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      viewerSessions: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchStartViewerSessionRevocationCommand");
+var se_CreateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateChannel");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      authorized: [],
+      insecureIngest: [],
+      latencyMode: [],
+      name: [],
+      preset: [],
+      recordingConfigurationArn: [],
+      tags: (_) => (0, import_smithy_client._json)(_),
+      type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateChannelCommand");
+var se_CreateRecordingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateRecordingConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      destinationConfiguration: (_) => (0, import_smithy_client._json)(_),
+      name: [],
+      recordingReconnectWindowSeconds: [],
+      renditionConfiguration: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      thumbnailConfiguration: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateRecordingConfigurationCommand");
+var se_CreateStreamKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/CreateStreamKey");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateStreamKeyCommand");
+var se_DeleteChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteChannel");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteChannelCommand");
+var se_DeletePlaybackKeyPairCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeletePlaybackKeyPair");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeletePlaybackKeyPairCommand");
+var se_DeleteRecordingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteRecordingConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteRecordingConfigurationCommand");
+var se_DeleteStreamKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/DeleteStreamKey");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteStreamKeyCommand");
+var se_GetChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetChannel");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetChannelCommand");
+var se_GetPlaybackKeyPairCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetPlaybackKeyPair");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetPlaybackKeyPairCommand");
+var se_GetRecordingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetRecordingConfiguration");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetRecordingConfigurationCommand");
+var se_GetStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStream");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStreamCommand");
+var se_GetStreamKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStreamKey");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStreamKeyCommand");
+var se_GetStreamSessionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/GetStreamSession");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      streamId: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_GetStreamSessionCommand");
+var se_ImportPlaybackKeyPairCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ImportPlaybackKeyPair");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      name: [],
+      publicKeyMaterial: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ImportPlaybackKeyPairCommand");
+var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListChannels");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filterByName: [],
+      filterByRecordingConfigurationArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListChannelsCommand");
+var se_ListPlaybackKeyPairsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListPlaybackKeyPairs");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListPlaybackKeyPairsCommand");
+var se_ListRecordingConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListRecordingConfigurations");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListRecordingConfigurationsCommand");
+var se_ListStreamKeysCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStreamKeys");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStreamKeysCommand");
+var se_ListStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStreams");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filterBy: (_) => (0, import_smithy_client._json)(_),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStreamsCommand");
+var se_ListStreamSessionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/ListStreamSessions");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListStreamSessionsCommand");
+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_PutMetadataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/PutMetadata");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      metadata: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutMetadataCommand");
+var se_StartViewerSessionRevocationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/StartViewerSessionRevocation");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: [],
+      viewerId: [],
+      viewerSessionVersionsLessThanOrEqualTo: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartViewerSessionRevocationCommand");
+var se_StopStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/StopStream");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      channelArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StopStreamCommand");
+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_UpdateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/UpdateChannel");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: [],
+      authorized: [],
+      insecureIngest: [],
+      latencyMode: [],
+      name: [],
+      preset: [],
+      recordingConfigurationArn: [],
+      type: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateChannelCommand");
+var de_BatchGetChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchGetChannelCommandError(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, {
+    channels: import_smithy_client._json,
+    errors: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchGetChannelCommand");
+var de_BatchGetChannelCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_BatchGetChannelCommandError");
+var de_BatchGetStreamKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchGetStreamKeyCommandError(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, {
+    errors: import_smithy_client._json,
+    streamKeys: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchGetStreamKeyCommand");
+var de_BatchGetStreamKeyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_BatchGetStreamKeyCommandError");
+var de_BatchStartViewerSessionRevocationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchStartViewerSessionRevocationCommandError(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, {
+    errors: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchStartViewerSessionRevocationCommand");
+var de_BatchStartViewerSessionRevocationCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ivs#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchStartViewerSessionRevocationCommandError");
+var de_CreateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateChannelCommandError(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, {
+    channel: import_smithy_client._json,
+    streamKey: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateChannelCommand");
+var de_CreateChannelCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivs#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateChannelCommandError");
+var de_CreateRecordingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateRecordingConfigurationCommandError(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, {
+    recordingConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateRecordingConfigurationCommand");
+var de_CreateRecordingConfigurationCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivs#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRecordingConfigurationCommandError");
+var de_CreateStreamKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateStreamKeyCommandError(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, {
+    streamKey: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateStreamKeyCommand");
+var de_CreateStreamKeyCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivs#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateStreamKeyCommandError");
+var de_DeleteChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteChannelCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteChannelCommand");
+var de_DeleteChannelCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteChannelCommandError");
+var de_DeletePlaybackKeyPairCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeletePlaybackKeyPairCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeletePlaybackKeyPairCommand");
+var de_DeletePlaybackKeyPairCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePlaybackKeyPairCommandError");
+var de_DeleteRecordingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteRecordingConfigurationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteRecordingConfigurationCommand");
+var de_DeleteRecordingConfigurationCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRecordingConfigurationCommandError");
+var de_DeleteStreamKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteStreamKeyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteStreamKeyCommand");
+var de_DeleteStreamKeyCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteStreamKeyCommandError");
+var de_GetChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetChannelCommandError(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, {
+    channel: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetChannelCommand");
+var de_GetChannelCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetChannelCommandError");
+var de_GetPlaybackKeyPairCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetPlaybackKeyPairCommandError(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, {
+    keyPair: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetPlaybackKeyPairCommand");
+var de_GetPlaybackKeyPairCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetPlaybackKeyPairCommandError");
+var de_GetRecordingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetRecordingConfigurationCommandError(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, {
+    recordingConfiguration: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetRecordingConfigurationCommand");
+var de_GetRecordingConfigurationCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetRecordingConfigurationCommandError");
+var de_GetStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStreamCommandError(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, {
+    stream: (_) => de__Stream(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStreamCommand");
+var de_GetStreamCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ChannelNotBroadcasting":
+    case "com.amazonaws.ivs#ChannelNotBroadcasting":
+      throw await de_ChannelNotBroadcastingRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStreamCommandError");
+var de_GetStreamKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStreamKeyCommandError(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, {
+    streamKey: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStreamKeyCommand");
+var de_GetStreamKeyCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStreamKeyCommandError");
+var de_GetStreamSessionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetStreamSessionCommandError(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, {
+    streamSession: (_) => de_StreamSession(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetStreamSessionCommand");
+var de_GetStreamSessionCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetStreamSessionCommandError");
+var de_ImportPlaybackKeyPairCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ImportPlaybackKeyPairCommandError(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, {
+    keyPair: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ImportPlaybackKeyPairCommand");
+var de_ImportPlaybackKeyPairCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ivs#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ImportPlaybackKeyPairCommandError");
+var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListChannelsCommandError(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, {
+    channels: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListChannelsCommand");
+var de_ListChannelsCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListChannelsCommandError");
+var de_ListPlaybackKeyPairsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListPlaybackKeyPairsCommandError(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, {
+    keyPairs: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListPlaybackKeyPairsCommand");
+var de_ListPlaybackKeyPairsCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPlaybackKeyPairsCommandError");
+var de_ListRecordingConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRecordingConfigurationsCommandError(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,
+    recordingConfigurations: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRecordingConfigurationsCommand");
+var de_ListRecordingConfigurationsCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRecordingConfigurationsCommandError");
+var de_ListStreamKeysCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStreamKeysCommandError(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,
+    streamKeys: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStreamKeysCommand");
+var de_ListStreamKeysCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStreamKeysCommandError");
+var de_ListStreamsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStreamsCommandError(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,
+    streams: (_) => de_StreamList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStreamsCommand");
+var de_ListStreamsCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStreamsCommandError");
+var de_ListStreamSessionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListStreamSessionsCommandError(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,
+    streamSessions: (_) => de_StreamSessionList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListStreamSessionsCommand");
+var de_ListStreamSessionsCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListStreamSessionsCommandError");
+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.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_PutMetadataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_PutMetadataCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_PutMetadataCommand");
+var de_PutMetadataCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ChannelNotBroadcasting":
+    case "com.amazonaws.ivs#ChannelNotBroadcasting":
+      throw await de_ChannelNotBroadcastingRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ivs#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutMetadataCommandError");
+var de_StartViewerSessionRevocationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartViewerSessionRevocationCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StartViewerSessionRevocationCommand");
+var de_StartViewerSessionRevocationCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ivs#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartViewerSessionRevocationCommandError");
+var de_StopStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StopStreamCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_StopStreamCommand");
+var de_StopStreamCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ChannelNotBroadcasting":
+    case "com.amazonaws.ivs#ChannelNotBroadcasting":
+      throw await de_ChannelNotBroadcastingRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "StreamUnavailable":
+    case "com.amazonaws.ivs#StreamUnavailable":
+      throw await de_StreamUnavailableRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopStreamCommandError");
+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.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#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.ivs#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateChannelCommandError(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, {
+    channel: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateChannelCommand");
+var de_UpdateChannelCommandError = /* @__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.ivs#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ivs#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "PendingVerification":
+    case "com.amazonaws.ivs#PendingVerification":
+      throw await de_PendingVerificationRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ivs#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ivs#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateChannelCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(IvsServiceException);
+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_ChannelNotBroadcastingRes = /* @__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 ChannelNotBroadcasting({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ChannelNotBroadcastingRes");
+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_StreamUnavailableRes = /* @__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 StreamUnavailable({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_StreamUnavailableRes");
+var de_ThrottlingExceptionRes = /* @__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 ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+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 de__Stream = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    channelArn: import_smithy_client.expectString,
+    health: import_smithy_client.expectString,
+    playbackUrl: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString,
+    streamId: import_smithy_client.expectString,
+    viewerCount: import_smithy_client.expectLong
+  });
+}, "de__Stream");
+var de_StreamEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    eventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    name: import_smithy_client.expectString,
+    type: import_smithy_client.expectString
+  });
+}, "de_StreamEvent");
+var de_StreamEvents = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StreamEvent(entry, context);
+  });
+  return retVal;
+}, "de_StreamEvents");
+var de_StreamList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StreamSummary(entry, context);
+  });
+  return retVal;
+}, "de_StreamList");
+var de_StreamSession = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    channel: import_smithy_client._json,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    ingestConfiguration: import_smithy_client._json,
+    recordingConfiguration: import_smithy_client._json,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    streamId: import_smithy_client.expectString,
+    truncatedEvents: (_) => de_StreamEvents(_, context)
+  });
+}, "de_StreamSession");
+var de_StreamSessionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_StreamSessionSummary(entry, context);
+  });
+  return retVal;
+}, "de_StreamSessionList");
+var de_StreamSessionSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    hasErrorEvent: import_smithy_client.expectBoolean,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    streamId: import_smithy_client.expectString
+  });
+}, "de_StreamSessionSummary");
+var de_StreamSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    channelArn: import_smithy_client.expectString,
+    health: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)),
+    state: import_smithy_client.expectString,
+    streamId: import_smithy_client.expectString,
+    viewerCount: import_smithy_client.expectLong
+  });
+}, "de_StreamSummary");
+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/BatchGetChannelCommand.ts
+var _BatchGetChannelCommand = class _BatchGetChannelCommand 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("AmazonInteractiveVideoService", "BatchGetChannel", {}).n("IvsClient", "BatchGetChannelCommand").f(void 0, void 0).ser(se_BatchGetChannelCommand).de(de_BatchGetChannelCommand).build() {
+};
+__name(_BatchGetChannelCommand, "BatchGetChannelCommand");
+var BatchGetChannelCommand = _BatchGetChannelCommand;
+
+// src/commands/BatchGetStreamKeyCommand.ts
+
+
+
+
+var _BatchGetStreamKeyCommand = class _BatchGetStreamKeyCommand 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("AmazonInteractiveVideoService", "BatchGetStreamKey", {}).n("IvsClient", "BatchGetStreamKeyCommand").f(void 0, BatchGetStreamKeyResponseFilterSensitiveLog).ser(se_BatchGetStreamKeyCommand).de(de_BatchGetStreamKeyCommand).build() {
+};
+__name(_BatchGetStreamKeyCommand, "BatchGetStreamKeyCommand");
+var BatchGetStreamKeyCommand = _BatchGetStreamKeyCommand;
+
+// src/commands/BatchStartViewerSessionRevocationCommand.ts
+
+
+
+
+var _BatchStartViewerSessionRevocationCommand = class _BatchStartViewerSessionRevocationCommand 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("AmazonInteractiveVideoService", "BatchStartViewerSessionRevocation", {}).n("IvsClient", "BatchStartViewerSessionRevocationCommand").f(void 0, void 0).ser(se_BatchStartViewerSessionRevocationCommand).de(de_BatchStartViewerSessionRevocationCommand).build() {
+};
+__name(_BatchStartViewerSessionRevocationCommand, "BatchStartViewerSessionRevocationCommand");
+var BatchStartViewerSessionRevocationCommand = _BatchStartViewerSessionRevocationCommand;
+
+// src/commands/CreateChannelCommand.ts
+
+
+
+
+var _CreateChannelCommand = class _CreateChannelCommand 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("AmazonInteractiveVideoService", "CreateChannel", {}).n("IvsClient", "CreateChannelCommand").f(void 0, CreateChannelResponseFilterSensitiveLog).ser(se_CreateChannelCommand).de(de_CreateChannelCommand).build() {
+};
+__name(_CreateChannelCommand, "CreateChannelCommand");
+var CreateChannelCommand = _CreateChannelCommand;
+
+// src/commands/CreateRecordingConfigurationCommand.ts
+
+
+
+
+var _CreateRecordingConfigurationCommand = class _CreateRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "CreateRecordingConfiguration", {}).n("IvsClient", "CreateRecordingConfigurationCommand").f(void 0, void 0).ser(se_CreateRecordingConfigurationCommand).de(de_CreateRecordingConfigurationCommand).build() {
+};
+__name(_CreateRecordingConfigurationCommand, "CreateRecordingConfigurationCommand");
+var CreateRecordingConfigurationCommand = _CreateRecordingConfigurationCommand;
+
+// src/commands/CreateStreamKeyCommand.ts
+
+
+
+
+var _CreateStreamKeyCommand = class _CreateStreamKeyCommand 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("AmazonInteractiveVideoService", "CreateStreamKey", {}).n("IvsClient", "CreateStreamKeyCommand").f(void 0, CreateStreamKeyResponseFilterSensitiveLog).ser(se_CreateStreamKeyCommand).de(de_CreateStreamKeyCommand).build() {
+};
+__name(_CreateStreamKeyCommand, "CreateStreamKeyCommand");
+var CreateStreamKeyCommand = _CreateStreamKeyCommand;
+
+// src/commands/DeleteChannelCommand.ts
+
+
+
+
+var _DeleteChannelCommand = class _DeleteChannelCommand 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("AmazonInteractiveVideoService", "DeleteChannel", {}).n("IvsClient", "DeleteChannelCommand").f(void 0, void 0).ser(se_DeleteChannelCommand).de(de_DeleteChannelCommand).build() {
+};
+__name(_DeleteChannelCommand, "DeleteChannelCommand");
+var DeleteChannelCommand = _DeleteChannelCommand;
+
+// src/commands/DeletePlaybackKeyPairCommand.ts
+
+
+
+
+var _DeletePlaybackKeyPairCommand = class _DeletePlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "DeletePlaybackKeyPair", {}).n("IvsClient", "DeletePlaybackKeyPairCommand").f(void 0, void 0).ser(se_DeletePlaybackKeyPairCommand).de(de_DeletePlaybackKeyPairCommand).build() {
+};
+__name(_DeletePlaybackKeyPairCommand, "DeletePlaybackKeyPairCommand");
+var DeletePlaybackKeyPairCommand = _DeletePlaybackKeyPairCommand;
+
+// src/commands/DeleteRecordingConfigurationCommand.ts
+
+
+
+
+var _DeleteRecordingConfigurationCommand = class _DeleteRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "DeleteRecordingConfiguration", {}).n("IvsClient", "DeleteRecordingConfigurationCommand").f(void 0, void 0).ser(se_DeleteRecordingConfigurationCommand).de(de_DeleteRecordingConfigurationCommand).build() {
+};
+__name(_DeleteRecordingConfigurationCommand, "DeleteRecordingConfigurationCommand");
+var DeleteRecordingConfigurationCommand = _DeleteRecordingConfigurationCommand;
+
+// src/commands/DeleteStreamKeyCommand.ts
+
+
+
+
+var _DeleteStreamKeyCommand = class _DeleteStreamKeyCommand 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("AmazonInteractiveVideoService", "DeleteStreamKey", {}).n("IvsClient", "DeleteStreamKeyCommand").f(void 0, void 0).ser(se_DeleteStreamKeyCommand).de(de_DeleteStreamKeyCommand).build() {
+};
+__name(_DeleteStreamKeyCommand, "DeleteStreamKeyCommand");
+var DeleteStreamKeyCommand = _DeleteStreamKeyCommand;
+
+// src/commands/GetChannelCommand.ts
+
+
+
+
+var _GetChannelCommand = class _GetChannelCommand 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("AmazonInteractiveVideoService", "GetChannel", {}).n("IvsClient", "GetChannelCommand").f(void 0, void 0).ser(se_GetChannelCommand).de(de_GetChannelCommand).build() {
+};
+__name(_GetChannelCommand, "GetChannelCommand");
+var GetChannelCommand = _GetChannelCommand;
+
+// src/commands/GetPlaybackKeyPairCommand.ts
+
+
+
+
+var _GetPlaybackKeyPairCommand = class _GetPlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "GetPlaybackKeyPair", {}).n("IvsClient", "GetPlaybackKeyPairCommand").f(void 0, void 0).ser(se_GetPlaybackKeyPairCommand).de(de_GetPlaybackKeyPairCommand).build() {
+};
+__name(_GetPlaybackKeyPairCommand, "GetPlaybackKeyPairCommand");
+var GetPlaybackKeyPairCommand = _GetPlaybackKeyPairCommand;
+
+// src/commands/GetRecordingConfigurationCommand.ts
+
+
+
+
+var _GetRecordingConfigurationCommand = class _GetRecordingConfigurationCommand 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("AmazonInteractiveVideoService", "GetRecordingConfiguration", {}).n("IvsClient", "GetRecordingConfigurationCommand").f(void 0, void 0).ser(se_GetRecordingConfigurationCommand).de(de_GetRecordingConfigurationCommand).build() {
+};
+__name(_GetRecordingConfigurationCommand, "GetRecordingConfigurationCommand");
+var GetRecordingConfigurationCommand = _GetRecordingConfigurationCommand;
+
+// src/commands/GetStreamCommand.ts
+
+
+
+
+var _GetStreamCommand = class _GetStreamCommand 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("AmazonInteractiveVideoService", "GetStream", {}).n("IvsClient", "GetStreamCommand").f(void 0, void 0).ser(se_GetStreamCommand).de(de_GetStreamCommand).build() {
+};
+__name(_GetStreamCommand, "GetStreamCommand");
+var GetStreamCommand = _GetStreamCommand;
+
+// src/commands/GetStreamKeyCommand.ts
+
+
+
+
+var _GetStreamKeyCommand = class _GetStreamKeyCommand 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("AmazonInteractiveVideoService", "GetStreamKey", {}).n("IvsClient", "GetStreamKeyCommand").f(void 0, GetStreamKeyResponseFilterSensitiveLog).ser(se_GetStreamKeyCommand).de(de_GetStreamKeyCommand).build() {
+};
+__name(_GetStreamKeyCommand, "GetStreamKeyCommand");
+var GetStreamKeyCommand = _GetStreamKeyCommand;
+
+// src/commands/GetStreamSessionCommand.ts
+
+
+
+
+var _GetStreamSessionCommand = class _GetStreamSessionCommand 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("AmazonInteractiveVideoService", "GetStreamSession", {}).n("IvsClient", "GetStreamSessionCommand").f(void 0, void 0).ser(se_GetStreamSessionCommand).de(de_GetStreamSessionCommand).build() {
+};
+__name(_GetStreamSessionCommand, "GetStreamSessionCommand");
+var GetStreamSessionCommand = _GetStreamSessionCommand;
+
+// src/commands/ImportPlaybackKeyPairCommand.ts
+
+
+
+
+var _ImportPlaybackKeyPairCommand = class _ImportPlaybackKeyPairCommand 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("AmazonInteractiveVideoService", "ImportPlaybackKeyPair", {}).n("IvsClient", "ImportPlaybackKeyPairCommand").f(void 0, void 0).ser(se_ImportPlaybackKeyPairCommand).de(de_ImportPlaybackKeyPairCommand).build() {
+};
+__name(_ImportPlaybackKeyPairCommand, "ImportPlaybackKeyPairCommand");
+var ImportPlaybackKeyPairCommand = _ImportPlaybackKeyPairCommand;
+
+// src/commands/ListChannelsCommand.ts
+
+
+
+
+var _ListChannelsCommand = class _ListChannelsCommand 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("AmazonInteractiveVideoService", "ListChannels", {}).n("IvsClient", "ListChannelsCommand").f(void 0, void 0).ser(se_ListChannelsCommand).de(de_ListChannelsCommand).build() {
+};
+__name(_ListChannelsCommand, "ListChannelsCommand");
+var ListChannelsCommand = _ListChannelsCommand;
+
+// src/commands/ListPlaybackKeyPairsCommand.ts
+
+
+
+
+var _ListPlaybackKeyPairsCommand = class _ListPlaybackKeyPairsCommand 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("AmazonInteractiveVideoService", "ListPlaybackKeyPairs", {}).n("IvsClient", "ListPlaybackKeyPairsCommand").f(void 0, void 0).ser(se_ListPlaybackKeyPairsCommand).de(de_ListPlaybackKeyPairsCommand).build() {
+};
+__name(_ListPlaybackKeyPairsCommand, "ListPlaybackKeyPairsCommand");
+var ListPlaybackKeyPairsCommand = _ListPlaybackKeyPairsCommand;
+
+// src/commands/ListRecordingConfigurationsCommand.ts
+
+
+
+
+var _ListRecordingConfigurationsCommand = class _ListRecordingConfigurationsCommand 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("AmazonInteractiveVideoService", "ListRecordingConfigurations", {}).n("IvsClient", "ListRecordingConfigurationsCommand").f(void 0, void 0).ser(se_ListRecordingConfigurationsCommand).de(de_ListRecordingConfigurationsCommand).build() {
+};
+__name(_ListRecordingConfigurationsCommand, "ListRecordingConfigurationsCommand");
+var ListRecordingConfigurationsCommand = _ListRecordingConfigurationsCommand;
+
+// src/commands/ListStreamKeysCommand.ts
+
+
+
+
+var _ListStreamKeysCommand = class _ListStreamKeysCommand 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("AmazonInteractiveVideoService", "ListStreamKeys", {}).n("IvsClient", "ListStreamKeysCommand").f(void 0, void 0).ser(se_ListStreamKeysCommand).de(de_ListStreamKeysCommand).build() {
+};
+__name(_ListStreamKeysCommand, "ListStreamKeysCommand");
+var ListStreamKeysCommand = _ListStreamKeysCommand;
+
+// src/commands/ListStreamsCommand.ts
+
+
+
+
+var _ListStreamsCommand = class _ListStreamsCommand 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("AmazonInteractiveVideoService", "ListStreams", {}).n("IvsClient", "ListStreamsCommand").f(void 0, void 0).ser(se_ListStreamsCommand).de(de_ListStreamsCommand).build() {
+};
+__name(_ListStreamsCommand, "ListStreamsCommand");
+var ListStreamsCommand = _ListStreamsCommand;
+
+// src/commands/ListStreamSessionsCommand.ts
+
+
+
+
+var _ListStreamSessionsCommand = class _ListStreamSessionsCommand 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("AmazonInteractiveVideoService", "ListStreamSessions", {}).n("IvsClient", "ListStreamSessionsCommand").f(void 0, void 0).ser(se_ListStreamSessionsCommand).de(de_ListStreamSessionsCommand).build() {
+};
+__name(_ListStreamSessionsCommand, "ListStreamSessionsCommand");
+var ListStreamSessionsCommand = _ListStreamSessionsCommand;
+
+// 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("AmazonInteractiveVideoService", "ListTagsForResource", {}).n("IvsClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/PutMetadataCommand.ts
+
+
+
+
+var _PutMetadataCommand = class _PutMetadataCommand 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("AmazonInteractiveVideoService", "PutMetadata", {}).n("IvsClient", "PutMetadataCommand").f(PutMetadataRequestFilterSensitiveLog, void 0).ser(se_PutMetadataCommand).de(de_PutMetadataCommand).build() {
+};
+__name(_PutMetadataCommand, "PutMetadataCommand");
+var PutMetadataCommand = _PutMetadataCommand;
+
+// src/commands/StartViewerSessionRevocationCommand.ts
+
+
+
+
+var _StartViewerSessionRevocationCommand = class _StartViewerSessionRevocationCommand 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("AmazonInteractiveVideoService", "StartViewerSessionRevocation", {}).n("IvsClient", "StartViewerSessionRevocationCommand").f(void 0, void 0).ser(se_StartViewerSessionRevocationCommand).de(de_StartViewerSessionRevocationCommand).build() {
+};
+__name(_StartViewerSessionRevocationCommand, "StartViewerSessionRevocationCommand");
+var StartViewerSessionRevocationCommand = _StartViewerSessionRevocationCommand;
+
+// src/commands/StopStreamCommand.ts
+
+
+
+
+var _StopStreamCommand = class _StopStreamCommand 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("AmazonInteractiveVideoService", "StopStream", {}).n("IvsClient", "StopStreamCommand").f(void 0, void 0).ser(se_StopStreamCommand).de(de_StopStreamCommand).build() {
+};
+__name(_StopStreamCommand, "StopStreamCommand");
+var StopStreamCommand = _StopStreamCommand;
+
+// 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("AmazonInteractiveVideoService", "TagResource", {}).n("IvsClient", "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("AmazonInteractiveVideoService", "UntagResource", {}).n("IvsClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateChannelCommand.ts
+
+
+
+
+var _UpdateChannelCommand = class _UpdateChannelCommand 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("AmazonInteractiveVideoService", "UpdateChannel", {}).n("IvsClient", "UpdateChannelCommand").f(void 0, void 0).ser(se_UpdateChannelCommand).de(de_UpdateChannelCommand).build() {
+};
+__name(_UpdateChannelCommand, "UpdateChannelCommand");
+var UpdateChannelCommand = _UpdateChannelCommand;
+
+// src/Ivs.ts
+var commands = {
+  BatchGetChannelCommand,
+  BatchGetStreamKeyCommand,
+  BatchStartViewerSessionRevocationCommand,
+  CreateChannelCommand,
+  CreateRecordingConfigurationCommand,
+  CreateStreamKeyCommand,
+  DeleteChannelCommand,
+  DeletePlaybackKeyPairCommand,
+  DeleteRecordingConfigurationCommand,
+  DeleteStreamKeyCommand,
+  GetChannelCommand,
+  GetPlaybackKeyPairCommand,
+  GetRecordingConfigurationCommand,
+  GetStreamCommand,
+  GetStreamKeyCommand,
+  GetStreamSessionCommand,
+  ImportPlaybackKeyPairCommand,
+  ListChannelsCommand,
+  ListPlaybackKeyPairsCommand,
+  ListRecordingConfigurationsCommand,
+  ListStreamKeysCommand,
+  ListStreamsCommand,
+  ListStreamSessionsCommand,
+  ListTagsForResourceCommand,
+  PutMetadataCommand,
+  StartViewerSessionRevocationCommand,
+  StopStreamCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateChannelCommand
+};
+var _Ivs = class _Ivs extends IvsClient {
+};
+__name(_Ivs, "Ivs");
+var Ivs = _Ivs;
+(0, import_smithy_client.createAggregatedClient)(commands, Ivs);
+
+// src/pagination/ListChannelsPaginator.ts
+
+var paginateListChannels = (0, import_core.createPaginator)(IvsClient, ListChannelsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListPlaybackKeyPairsPaginator.ts
+
+var paginateListPlaybackKeyPairs = (0, import_core.createPaginator)(IvsClient, ListPlaybackKeyPairsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListRecordingConfigurationsPaginator.ts
+
+var paginateListRecordingConfigurations = (0, import_core.createPaginator)(IvsClient, ListRecordingConfigurationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStreamKeysPaginator.ts
+
+var paginateListStreamKeys = (0, import_core.createPaginator)(IvsClient, ListStreamKeysCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStreamSessionsPaginator.ts
+
+var paginateListStreamSessions = (0, import_core.createPaginator)(IvsClient, ListStreamSessionsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListStreamsPaginator.ts
+
+var paginateListStreams = (0, import_core.createPaginator)(IvsClient, ListStreamsCommand, "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,
+  BatchGetChannelCommand,
+  BatchGetStreamKeyCommand,
+  BatchGetStreamKeyResponseFilterSensitiveLog,
+  BatchStartViewerSessionRevocationCommand,
+  ChannelLatencyMode,
+  ChannelNotBroadcasting,
+  ChannelType,
+  ConflictException,
+  CreateChannelCommand,
+  CreateChannelResponseFilterSensitiveLog,
+  CreateRecordingConfigurationCommand,
+  CreateStreamKeyCommand,
+  CreateStreamKeyResponseFilterSensitiveLog,
+  DeleteChannelCommand,
+  DeletePlaybackKeyPairCommand,
+  DeleteRecordingConfigurationCommand,
+  DeleteStreamKeyCommand,
+  GetChannelCommand,
+  GetPlaybackKeyPairCommand,
+  GetRecordingConfigurationCommand,
+  GetStreamCommand,
+  GetStreamKeyCommand,
+  GetStreamKeyResponseFilterSensitiveLog,
+  GetStreamSessionCommand,
+  ImportPlaybackKeyPairCommand,
+  InternalServerException,
+  Ivs,
+  IvsClient,
+  IvsServiceException,
+  ListChannelsCommand,
+  ListPlaybackKeyPairsCommand,
+  ListRecordingConfigurationsCommand,
+  ListStreamKeysCommand,
+  ListStreamSessionsCommand,
+  ListStreamsCommand,
+  ListTagsForResourceCommand,
+  PendingVerification,
+  PutMetadataCommand,
+  PutMetadataRequestFilterSensitiveLog,
+  RecordingConfigurationState,
+  RecordingMode,
+  RenditionConfigurationRendition,
+  RenditionConfigurationRenditionSelection,
+  ResourceNotFoundException,
+  ServiceQuotaExceededException,
+  StartViewerSessionRevocationCommand,
+  StopStreamCommand,
+  StreamHealth,
+  StreamKeyFilterSensitiveLog,
+  StreamState,
+  StreamUnavailable,
+  TagResourceCommand,
+  ThrottlingException,
+  ThumbnailConfigurationResolution,
+  ThumbnailConfigurationStorage,
+  TranscodePreset,
+  UntagResourceCommand,
+  UpdateChannelCommand,
+  ValidationException,
+  __Client,
+  paginateListChannels,
+  paginateListPlaybackKeyPairs,
+  paginateListRecordingConfigurations,
+  paginateListStreamKeys,
+  paginateListStreamSessions,
+  paginateListStreams
+});