awscdk-construct-live-channel-from-mp4-file/node_modules/@aws-sdk/client-mediapackage/dist-cjs/index.js

CDK Construct for setting up a simple live channel for testing

"use strict";
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 index_exports = {};
__export(index_exports, {
  AdMarkers: () => AdMarkers,
  AdsOnDeliveryRestrictions: () => AdsOnDeliveryRestrictions,
  ChannelFilterSensitiveLog: () => ChannelFilterSensitiveLog,
  CmafEncryptionMethod: () => CmafEncryptionMethod,
  ConfigureLogsCommand: () => ConfigureLogsCommand,
  ConfigureLogsResponseFilterSensitiveLog: () => ConfigureLogsResponseFilterSensitiveLog,
  CreateChannelCommand: () => CreateChannelCommand,
  CreateChannelResponseFilterSensitiveLog: () => CreateChannelResponseFilterSensitiveLog,
  CreateHarvestJobCommand: () => CreateHarvestJobCommand,
  CreateOriginEndpointCommand: () => CreateOriginEndpointCommand,
  DeleteChannelCommand: () => DeleteChannelCommand,
  DeleteOriginEndpointCommand: () => DeleteOriginEndpointCommand,
  DescribeChannelCommand: () => DescribeChannelCommand,
  DescribeChannelResponseFilterSensitiveLog: () => DescribeChannelResponseFilterSensitiveLog,
  DescribeHarvestJobCommand: () => DescribeHarvestJobCommand,
  DescribeOriginEndpointCommand: () => DescribeOriginEndpointCommand,
  EncryptionMethod: () => EncryptionMethod,
  ForbiddenException: () => ForbiddenException,
  HlsIngestFilterSensitiveLog: () => HlsIngestFilterSensitiveLog,
  IngestEndpointFilterSensitiveLog: () => IngestEndpointFilterSensitiveLog,
  InternalServerErrorException: () => InternalServerErrorException,
  ListChannelsCommand: () => ListChannelsCommand,
  ListChannelsResponseFilterSensitiveLog: () => ListChannelsResponseFilterSensitiveLog,
  ListHarvestJobsCommand: () => ListHarvestJobsCommand,
  ListOriginEndpointsCommand: () => ListOriginEndpointsCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ManifestLayout: () => ManifestLayout,
  MediaPackage: () => MediaPackage,
  MediaPackageClient: () => MediaPackageClient,
  MediaPackageServiceException: () => MediaPackageServiceException,
  NotFoundException: () => NotFoundException,
  Origination: () => Origination,
  PlaylistType: () => PlaylistType,
  PresetSpeke20Audio: () => PresetSpeke20Audio,
  PresetSpeke20Video: () => PresetSpeke20Video,
  Profile: () => Profile,
  RotateChannelCredentialsCommand: () => RotateChannelCredentialsCommand,
  RotateChannelCredentialsResponseFilterSensitiveLog: () => RotateChannelCredentialsResponseFilterSensitiveLog,
  RotateIngestEndpointCredentialsCommand: () => RotateIngestEndpointCredentialsCommand,
  RotateIngestEndpointCredentialsResponseFilterSensitiveLog: () => RotateIngestEndpointCredentialsResponseFilterSensitiveLog,
  SegmentTemplateFormat: () => SegmentTemplateFormat,
  ServiceUnavailableException: () => ServiceUnavailableException,
  Status: () => Status,
  StreamOrder: () => StreamOrder,
  TagResourceCommand: () => TagResourceCommand,
  TooManyRequestsException: () => TooManyRequestsException,
  UnprocessableEntityException: () => UnprocessableEntityException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateChannelCommand: () => UpdateChannelCommand,
  UpdateChannelResponseFilterSensitiveLog: () => UpdateChannelResponseFilterSensitiveLog,
  UpdateOriginEndpointCommand: () => UpdateOriginEndpointCommand,
  UtcTiming: () => UtcTiming,
  __AdTriggersElement: () => __AdTriggersElement,
  __Client: () => import_smithy_client.Client,
  __PeriodTriggersElement: () => __PeriodTriggersElement,
  paginateListChannels: () => paginateListChannels,
  paginateListHarvestJobs: () => paginateListHarvestJobs,
  paginateListOriginEndpoints: () => paginateListOriginEndpoints
});
module.exports = __toCommonJS(index_exports);

// src/MediaPackageClient.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_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
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");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return Object.assign(options, {
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "mediapackage"
  });
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/MediaPackageClient.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");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = Object.assign(
    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
    getHttpAuthExtensionConfiguration(runtimeConfig)
  );
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return Object.assign(
    runtimeConfig,
    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    resolveHttpAuthRuntimeConfig(extensionConfiguration)
  );
}, "resolveRuntimeExtensions");

// src/MediaPackageClient.ts
var MediaPackageClient = class extends import_smithy_client.Client {
  static {
    __name(this, "MediaPackageClient");
  }
  /**
   * The resolved configuration of MediaPackageClient class. This is resolved and normalized from the {@link MediaPackageClientConfig | constructor configuration interface}.
   */
  config;
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    super(_config_0);
    this.initConfig = _config_0;
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
    this.config = _config_8;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultMediaPackageHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        }), "identityProviderConfigProvider")
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
  }
};

// src/MediaPackage.ts


// src/commands/ConfigureLogsCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/models/models_0.ts


// src/models/MediaPackageServiceException.ts

var MediaPackageServiceException = class _MediaPackageServiceException extends import_smithy_client.ServiceException {
  static {
    __name(this, "MediaPackageServiceException");
  }
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _MediaPackageServiceException.prototype);
  }
};

// src/models/models_0.ts
var __AdTriggersElement = {
  BREAK: "BREAK",
  DISTRIBUTOR_ADVERTISEMENT: "DISTRIBUTOR_ADVERTISEMENT",
  DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY: "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY",
  DISTRIBUTOR_PLACEMENT_OPPORTUNITY: "DISTRIBUTOR_PLACEMENT_OPPORTUNITY",
  PROVIDER_ADVERTISEMENT: "PROVIDER_ADVERTISEMENT",
  PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY: "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY",
  PROVIDER_PLACEMENT_OPPORTUNITY: "PROVIDER_PLACEMENT_OPPORTUNITY",
  SPLICE_INSERT: "SPLICE_INSERT"
};
var __PeriodTriggersElement = {
  ADS: "ADS"
};
var Status = {
  FAILED: "FAILED",
  IN_PROGRESS: "IN_PROGRESS",
  SUCCEEDED: "SUCCEEDED"
};
var AdMarkers = {
  DATERANGE: "DATERANGE",
  NONE: "NONE",
  PASSTHROUGH: "PASSTHROUGH",
  SCTE35_ENHANCED: "SCTE35_ENHANCED"
};
var AdsOnDeliveryRestrictions = {
  BOTH: "BOTH",
  NONE: "NONE",
  RESTRICTED: "RESTRICTED",
  UNRESTRICTED: "UNRESTRICTED"
};
var PlaylistType = {
  EVENT: "EVENT",
  NONE: "NONE",
  VOD: "VOD"
};
var CmafEncryptionMethod = {
  AES_CTR: "AES_CTR",
  SAMPLE_AES: "SAMPLE_AES"
};
var PresetSpeke20Audio = {
  PRESET_AUDIO_1: "PRESET-AUDIO-1",
  PRESET_AUDIO_2: "PRESET-AUDIO-2",
  PRESET_AUDIO_3: "PRESET-AUDIO-3",
  SHARED: "SHARED",
  UNENCRYPTED: "UNENCRYPTED"
};
var PresetSpeke20Video = {
  PRESET_VIDEO_1: "PRESET-VIDEO-1",
  PRESET_VIDEO_2: "PRESET-VIDEO-2",
  PRESET_VIDEO_3: "PRESET-VIDEO-3",
  PRESET_VIDEO_4: "PRESET-VIDEO-4",
  PRESET_VIDEO_5: "PRESET-VIDEO-5",
  PRESET_VIDEO_6: "PRESET-VIDEO-6",
  PRESET_VIDEO_7: "PRESET-VIDEO-7",
  PRESET_VIDEO_8: "PRESET-VIDEO-8",
  SHARED: "SHARED",
  UNENCRYPTED: "UNENCRYPTED"
};
var StreamOrder = {
  ORIGINAL: "ORIGINAL",
  VIDEO_BITRATE_ASCENDING: "VIDEO_BITRATE_ASCENDING",
  VIDEO_BITRATE_DESCENDING: "VIDEO_BITRATE_DESCENDING"
};
var ManifestLayout = {
  COMPACT: "COMPACT",
  DRM_TOP_LEVEL_COMPACT: "DRM_TOP_LEVEL_COMPACT",
  FULL: "FULL"
};
var Profile = {
  DVB_DASH_2014: "DVB_DASH_2014",
  HBBTV_1_5: "HBBTV_1_5",
  HYBRIDCAST: "HYBRIDCAST",
  NONE: "NONE"
};
var SegmentTemplateFormat = {
  NUMBER_WITH_DURATION: "NUMBER_WITH_DURATION",
  NUMBER_WITH_TIMELINE: "NUMBER_WITH_TIMELINE",
  TIME_WITH_TIMELINE: "TIME_WITH_TIMELINE"
};
var UtcTiming = {
  HTTP_HEAD: "HTTP-HEAD",
  HTTP_ISO: "HTTP-ISO",
  HTTP_XSDATE: "HTTP-XSDATE",
  NONE: "NONE"
};
var EncryptionMethod = {
  AES_128: "AES_128",
  SAMPLE_AES: "SAMPLE_AES"
};
var Origination = {
  ALLOW: "ALLOW",
  DENY: "DENY"
};
var ForbiddenException = class _ForbiddenException extends MediaPackageServiceException {
  static {
    __name(this, "ForbiddenException");
  }
  name = "ForbiddenException";
  $fault = "client";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ForbiddenException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _ForbiddenException.prototype);
    this.Message = opts.Message;
  }
};
var InternalServerErrorException = class _InternalServerErrorException extends MediaPackageServiceException {
  static {
    __name(this, "InternalServerErrorException");
  }
  name = "InternalServerErrorException";
  $fault = "server";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InternalServerErrorException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
    this.Message = opts.Message;
  }
};
var NotFoundException = class _NotFoundException extends MediaPackageServiceException {
  static {
    __name(this, "NotFoundException");
  }
  name = "NotFoundException";
  $fault = "client";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NotFoundException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _NotFoundException.prototype);
    this.Message = opts.Message;
  }
};
var ServiceUnavailableException = class _ServiceUnavailableException extends MediaPackageServiceException {
  static {
    __name(this, "ServiceUnavailableException");
  }
  name = "ServiceUnavailableException";
  $fault = "server";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceUnavailableException",
      $fault: "server",
      ...opts
    });
    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
    this.Message = opts.Message;
  }
};
var TooManyRequestsException = class _TooManyRequestsException extends MediaPackageServiceException {
  static {
    __name(this, "TooManyRequestsException");
  }
  name = "TooManyRequestsException";
  $fault = "client";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyRequestsException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
    this.Message = opts.Message;
  }
};
var UnprocessableEntityException = class _UnprocessableEntityException extends MediaPackageServiceException {
  static {
    __name(this, "UnprocessableEntityException");
  }
  name = "UnprocessableEntityException";
  $fault = "client";
  Message;
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnprocessableEntityException",
      $fault: "client",
      ...opts
    });
    Object.setPrototypeOf(this, _UnprocessableEntityException.prototype);
    this.Message = opts.Message;
  }
};
var IngestEndpointFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING },
  ...obj.Username && { Username: import_smithy_client.SENSITIVE_STRING }
}), "IngestEndpointFilterSensitiveLog");
var HlsIngestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.IngestEndpoints && {
    IngestEndpoints: obj.IngestEndpoints.map((item) => IngestEndpointFilterSensitiveLog(item))
  }
}), "HlsIngestFilterSensitiveLog");
var ChannelFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "ChannelFilterSensitiveLog");
var ConfigureLogsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "ConfigureLogsResponseFilterSensitiveLog");
var CreateChannelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "CreateChannelResponseFilterSensitiveLog");
var DescribeChannelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "DescribeChannelResponseFilterSensitiveLog");
var ListChannelsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj
}), "ListChannelsResponseFilterSensitiveLog");
var RotateChannelCredentialsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "RotateChannelCredentialsResponseFilterSensitiveLog");
var RotateIngestEndpointCredentialsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "RotateIngestEndpointCredentialsResponseFilterSensitiveLog");
var UpdateChannelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HlsIngest && { HlsIngest: HlsIngestFilterSensitiveLog(obj.HlsIngest) }
}), "UpdateChannelResponseFilterSensitiveLog");

// src/protocols/Aws_restJson1.ts
var import_core2 = require("@aws-sdk/core");


var se_ConfigureLogsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/channels/{Id}/configure_logs");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      egressAccessLogs: [, (_) => se_EgressAccessLogs(_, context), `EgressAccessLogs`],
      ingressAccessLogs: [, (_) => se_IngressAccessLogs(_, context), `IngressAccessLogs`]
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_ConfigureLogsCommand");
var se_CreateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/channels");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      description: [, , `Description`],
      id: [, , `Id`],
      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateChannelCommand");
var se_CreateHarvestJobCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/harvest_jobs");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      endTime: [, , `EndTime`],
      id: [, , `Id`],
      originEndpointId: [, , `OriginEndpointId`],
      s3Destination: [, (_) => se_S3Destination(_, context), `S3Destination`],
      startTime: [, , `StartTime`]
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateHarvestJobCommand");
var se_CreateOriginEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/origin_endpoints");
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      authorization: [, (_) => se_Authorization(_, context), `Authorization`],
      channelId: [, , `ChannelId`],
      cmafPackage: [, (_) => se_CmafPackageCreateOrUpdateParameters(_, context), `CmafPackage`],
      dashPackage: [, (_) => se_DashPackage(_, context), `DashPackage`],
      description: [, , `Description`],
      hlsPackage: [, (_) => se_HlsPackage(_, context), `HlsPackage`],
      id: [, , `Id`],
      manifestName: [, , `ManifestName`],
      mssPackage: [, (_) => se_MssPackage(_, context), `MssPackage`],
      origination: [, , `Origination`],
      startoverWindowSeconds: [, , `StartoverWindowSeconds`],
      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`],
      timeDelaySeconds: [, , `TimeDelaySeconds`],
      whitelist: [, (_) => (0, import_smithy_client._json)(_), `Whitelist`]
    })
  );
  b.m("POST").h(headers).b(body);
  return b.build();
}, "se_CreateOriginEndpointCommand");
var se_DeleteChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/channels/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteChannelCommand");
var se_DeleteOriginEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/origin_endpoints/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("DELETE").h(headers).b(body);
  return b.build();
}, "se_DeleteOriginEndpointCommand");
var se_DescribeChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/channels/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_DescribeChannelCommand");
var se_DescribeHarvestJobCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/harvest_jobs/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_DescribeHarvestJobCommand");
var se_DescribeOriginEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/origin_endpoints/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("GET").h(headers).b(body);
  return b.build();
}, "se_DescribeOriginEndpointCommand");
var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/channels");
  const query = (0, import_smithy_client.map)({
    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
    [_nT]: [, input[_NT]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListChannelsCommand");
var se_ListHarvestJobsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/harvest_jobs");
  const query = (0, import_smithy_client.map)({
    [_iCI]: [, input[_ICI]],
    [_iS]: [, input[_IS]],
    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
    [_nT]: [, input[_NT]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListHarvestJobsCommand");
var se_ListOriginEndpointsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/origin_endpoints");
  const query = (0, import_smithy_client.map)({
    [_cI]: [, input[_CI]],
    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
    [_nT]: [, input[_NT]]
  });
  let body;
  b.m("GET").h(headers).q(query).b(body);
  return b.build();
}, "se_ListOriginEndpointsCommand");
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_RotateChannelCredentialsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/channels/{Id}/credentials");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_RotateChannelCredentialsCommand");
var se_RotateIngestEndpointCredentialsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {};
  b.bp("/channels/{Id}/ingest_endpoints/{IngestEndpointId}/credentials");
  b.p("Id", () => input.Id, "{Id}", false);
  b.p("IngestEndpointId", () => input.IngestEndpointId, "{IngestEndpointId}", false);
  let body;
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_RotateIngestEndpointCredentialsCommand");
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)(_), `Tags`]
    })
  );
  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] || []]
  });
  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("/channels/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      description: [, , `Description`]
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateChannelCommand");
var se_UpdateOriginEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const b = (0, import_core.requestBuilder)(input, context);
  const headers = {
    "content-type": "application/json"
  };
  b.bp("/origin_endpoints/{Id}");
  b.p("Id", () => input.Id, "{Id}", false);
  let body;
  body = JSON.stringify(
    (0, import_smithy_client.take)(input, {
      authorization: [, (_) => se_Authorization(_, context), `Authorization`],
      cmafPackage: [, (_) => se_CmafPackageCreateOrUpdateParameters(_, context), `CmafPackage`],
      dashPackage: [, (_) => se_DashPackage(_, context), `DashPackage`],
      description: [, , `Description`],
      hlsPackage: [, (_) => se_HlsPackage(_, context), `HlsPackage`],
      manifestName: [, , `ManifestName`],
      mssPackage: [, (_) => se_MssPackage(_, context), `MssPackage`],
      origination: [, , `Origination`],
      startoverWindowSeconds: [, , `StartoverWindowSeconds`],
      timeDelaySeconds: [, , `TimeDelaySeconds`],
      whitelist: [, (_) => (0, import_smithy_client._json)(_), `Whitelist`]
    })
  );
  b.m("PUT").h(headers).b(body);
  return b.build();
}, "se_UpdateOriginEndpointCommand");
var de_ConfigureLogsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ConfigureLogsCommand");
var de_CreateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateChannelCommand");
var de_CreateHarvestJobCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    ChannelId: [, import_smithy_client.expectString, `channelId`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    EndTime: [, import_smithy_client.expectString, `endTime`],
    Id: [, import_smithy_client.expectString, `id`],
    OriginEndpointId: [, import_smithy_client.expectString, `originEndpointId`],
    S3Destination: [, (_) => de_S3Destination(_, context), `s3Destination`],
    StartTime: [, import_smithy_client.expectString, `startTime`],
    Status: [, import_smithy_client.expectString, `status`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateHarvestJobCommand");
var de_CreateOriginEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    Authorization: [, (_) => de_Authorization(_, context), `authorization`],
    ChannelId: [, import_smithy_client.expectString, `channelId`],
    CmafPackage: [, (_) => de_CmafPackage(_, context), `cmafPackage`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    DashPackage: [, (_) => de_DashPackage(_, context), `dashPackage`],
    Description: [, import_smithy_client.expectString, `description`],
    HlsPackage: [, (_) => de_HlsPackage(_, context), `hlsPackage`],
    Id: [, import_smithy_client.expectString, `id`],
    ManifestName: [, import_smithy_client.expectString, `manifestName`],
    MssPackage: [, (_) => de_MssPackage(_, context), `mssPackage`],
    Origination: [, import_smithy_client.expectString, `origination`],
    StartoverWindowSeconds: [, import_smithy_client.expectInt32, `startoverWindowSeconds`],
    Tags: [, import_smithy_client._json, `tags`],
    TimeDelaySeconds: [, import_smithy_client.expectInt32, `timeDelaySeconds`],
    Url: [, import_smithy_client.expectString, `url`],
    Whitelist: [, import_smithy_client._json, `whitelist`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_CreateOriginEndpointCommand");
var de_DeleteChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(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_DeleteOriginEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 202 && output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const contents = (0, import_smithy_client.map)({
    $metadata: deserializeMetadata(output)
  });
  await (0, import_smithy_client.collectBody)(output.body, context);
  return contents;
}, "de_DeleteOriginEndpointCommand");
var de_DescribeChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_DescribeChannelCommand");
var de_DescribeHarvestJobCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    ChannelId: [, import_smithy_client.expectString, `channelId`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    EndTime: [, import_smithy_client.expectString, `endTime`],
    Id: [, import_smithy_client.expectString, `id`],
    OriginEndpointId: [, import_smithy_client.expectString, `originEndpointId`],
    S3Destination: [, (_) => de_S3Destination(_, context), `s3Destination`],
    StartTime: [, import_smithy_client.expectString, `startTime`],
    Status: [, import_smithy_client.expectString, `status`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_DescribeHarvestJobCommand");
var de_DescribeOriginEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    Authorization: [, (_) => de_Authorization(_, context), `authorization`],
    ChannelId: [, import_smithy_client.expectString, `channelId`],
    CmafPackage: [, (_) => de_CmafPackage(_, context), `cmafPackage`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    DashPackage: [, (_) => de_DashPackage(_, context), `dashPackage`],
    Description: [, import_smithy_client.expectString, `description`],
    HlsPackage: [, (_) => de_HlsPackage(_, context), `hlsPackage`],
    Id: [, import_smithy_client.expectString, `id`],
    ManifestName: [, import_smithy_client.expectString, `manifestName`],
    MssPackage: [, (_) => de_MssPackage(_, context), `mssPackage`],
    Origination: [, import_smithy_client.expectString, `origination`],
    StartoverWindowSeconds: [, import_smithy_client.expectInt32, `startoverWindowSeconds`],
    Tags: [, import_smithy_client._json, `tags`],
    TimeDelaySeconds: [, import_smithy_client.expectInt32, `timeDelaySeconds`],
    Url: [, import_smithy_client.expectString, `url`],
    Whitelist: [, import_smithy_client._json, `whitelist`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_DescribeOriginEndpointCommand");
var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Channels: [, (_) => de___listOfChannel(_, context), `channels`],
    NextToken: [, import_smithy_client.expectString, `nextToken`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListChannelsCommand");
var de_ListHarvestJobsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    HarvestJobs: [, (_) => de___listOfHarvestJob(_, context), `harvestJobs`],
    NextToken: [, import_smithy_client.expectString, `nextToken`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListHarvestJobsCommand");
var de_ListOriginEndpointsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    NextToken: [, import_smithy_client.expectString, `nextToken`],
    OriginEndpoints: [, (_) => de___listOfOriginEndpoint(_, context), `originEndpoints`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListOriginEndpointsCommand");
var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_ListTagsForResourceCommand");
var de_RotateChannelCredentialsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_RotateChannelCredentialsCommand");
var de_RotateIngestEndpointCredentialsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_RotateIngestEndpointCredentialsCommand");
var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(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_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 204 && output.statusCode >= 300) {
    return de_CommandError(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_UpdateChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    Description: [, import_smithy_client.expectString, `description`],
    EgressAccessLogs: [, (_) => de_EgressAccessLogs(_, context), `egressAccessLogs`],
    HlsIngest: [, (_) => de_HlsIngest(_, context), `hlsIngest`],
    Id: [, import_smithy_client.expectString, `id`],
    IngressAccessLogs: [, (_) => de_IngressAccessLogs(_, context), `ingressAccessLogs`],
    Tags: [, import_smithy_client._json, `tags`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateChannelCommand");
var de_UpdateOriginEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode !== 200 && output.statusCode >= 300) {
    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
  const doc = (0, import_smithy_client.take)(data, {
    Arn: [, import_smithy_client.expectString, `arn`],
    Authorization: [, (_) => de_Authorization(_, context), `authorization`],
    ChannelId: [, import_smithy_client.expectString, `channelId`],
    CmafPackage: [, (_) => de_CmafPackage(_, context), `cmafPackage`],
    CreatedAt: [, import_smithy_client.expectString, `createdAt`],
    DashPackage: [, (_) => de_DashPackage(_, context), `dashPackage`],
    Description: [, import_smithy_client.expectString, `description`],
    HlsPackage: [, (_) => de_HlsPackage(_, context), `hlsPackage`],
    Id: [, import_smithy_client.expectString, `id`],
    ManifestName: [, import_smithy_client.expectString, `manifestName`],
    MssPackage: [, (_) => de_MssPackage(_, context), `mssPackage`],
    Origination: [, import_smithy_client.expectString, `origination`],
    StartoverWindowSeconds: [, import_smithy_client.expectInt32, `startoverWindowSeconds`],
    Tags: [, import_smithy_client._json, `tags`],
    TimeDelaySeconds: [, import_smithy_client.expectInt32, `timeDelaySeconds`],
    Url: [, import_smithy_client.expectString, `url`],
    Whitelist: [, import_smithy_client._json, `whitelist`]
  });
  Object.assign(contents, doc);
  return contents;
}, "de_UpdateOriginEndpointCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
  };
  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
  switch (errorCode) {
    case "ForbiddenException":
    case "com.amazonaws.mediapackage#ForbiddenException":
      throw await de_ForbiddenExceptionRes(parsedOutput, context);
    case "InternalServerErrorException":
    case "com.amazonaws.mediapackage#InternalServerErrorException":
      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
    case "NotFoundException":
    case "com.amazonaws.mediapackage#NotFoundException":
      throw await de_NotFoundExceptionRes(parsedOutput, context);
    case "ServiceUnavailableException":
    case "com.amazonaws.mediapackage#ServiceUnavailableException":
      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
    case "TooManyRequestsException":
    case "com.amazonaws.mediapackage#TooManyRequestsException":
      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
    case "UnprocessableEntityException":
    case "com.amazonaws.mediapack