cdk-amazon-chime-resources/node_modules/@aws-sdk/client-chime-sdk-media-pipelines/dist-cjs/index.js


"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 src_exports = {};
__export(src_exports, {
  ActiveSpeakerPosition: () => ActiveSpeakerPosition,
  ArtifactsConcatenationState: () => ArtifactsConcatenationState,
  ArtifactsState: () => ArtifactsState,
  AudioArtifactsConcatenationState: () => AudioArtifactsConcatenationState,
  AudioChannelsOption: () => AudioChannelsOption,
  AudioMuxType: () => AudioMuxType,
  BadRequestException: () => BadRequestException,
  BorderColor: () => BorderColor,
  CallAnalyticsLanguageCode: () => CallAnalyticsLanguageCode,
  CanvasOrientation: () => CanvasOrientation,
  ChimeSDKMediaPipelines: () => ChimeSDKMediaPipelines,
  ChimeSDKMediaPipelinesClient: () => ChimeSDKMediaPipelinesClient,
  ChimeSDKMediaPipelinesServiceException: () => ChimeSDKMediaPipelinesServiceException,
  ChimeSdkMeetingConfigurationFilterSensitiveLog: () => ChimeSdkMeetingConfigurationFilterSensitiveLog,
  ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog: () => ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog,
  ConcatenationSinkFilterSensitiveLog: () => ConcatenationSinkFilterSensitiveLog,
  ConcatenationSinkType: () => ConcatenationSinkType,
  ConcatenationSourceFilterSensitiveLog: () => ConcatenationSourceFilterSensitiveLog,
  ConcatenationSourceType: () => ConcatenationSourceType,
  ConflictException: () => ConflictException,
  ContentMuxType: () => ContentMuxType,
  ContentRedactionOutput: () => ContentRedactionOutput,
  ContentShareLayoutOption: () => ContentShareLayoutOption,
  ContentType: () => ContentType,
  CreateMediaCapturePipelineCommand: () => CreateMediaCapturePipelineCommand,
  CreateMediaCapturePipelineRequestFilterSensitiveLog: () => CreateMediaCapturePipelineRequestFilterSensitiveLog,
  CreateMediaCapturePipelineResponseFilterSensitiveLog: () => CreateMediaCapturePipelineResponseFilterSensitiveLog,
  CreateMediaConcatenationPipelineCommand: () => CreateMediaConcatenationPipelineCommand,
  CreateMediaConcatenationPipelineRequestFilterSensitiveLog: () => CreateMediaConcatenationPipelineRequestFilterSensitiveLog,
  CreateMediaConcatenationPipelineResponseFilterSensitiveLog: () => CreateMediaConcatenationPipelineResponseFilterSensitiveLog,
  CreateMediaInsightsPipelineCommand: () => CreateMediaInsightsPipelineCommand,
  CreateMediaInsightsPipelineConfigurationCommand: () => CreateMediaInsightsPipelineConfigurationCommand,
  CreateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog: () => CreateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog,
  CreateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog: () => CreateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog,
  CreateMediaInsightsPipelineRequestFilterSensitiveLog: () => CreateMediaInsightsPipelineRequestFilterSensitiveLog,
  CreateMediaInsightsPipelineResponseFilterSensitiveLog: () => CreateMediaInsightsPipelineResponseFilterSensitiveLog,
  CreateMediaLiveConnectorPipelineCommand: () => CreateMediaLiveConnectorPipelineCommand,
  CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog: () => CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog,
  CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog: () => CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog,
  CreateMediaPipelineKinesisVideoStreamPoolCommand: () => CreateMediaPipelineKinesisVideoStreamPoolCommand,
  CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog: () => CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog,
  CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog: () => CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
  CreateMediaStreamPipelineCommand: () => CreateMediaStreamPipelineCommand,
  CreateMediaStreamPipelineRequestFilterSensitiveLog: () => CreateMediaStreamPipelineRequestFilterSensitiveLog,
  CreateMediaStreamPipelineResponseFilterSensitiveLog: () => CreateMediaStreamPipelineResponseFilterSensitiveLog,
  DeleteMediaCapturePipelineCommand: () => DeleteMediaCapturePipelineCommand,
  DeleteMediaInsightsPipelineConfigurationCommand: () => DeleteMediaInsightsPipelineConfigurationCommand,
  DeleteMediaPipelineCommand: () => DeleteMediaPipelineCommand,
  DeleteMediaPipelineKinesisVideoStreamPoolCommand: () => DeleteMediaPipelineKinesisVideoStreamPoolCommand,
  ErrorCode: () => ErrorCode,
  ForbiddenException: () => ForbiddenException,
  FragmentSelectorType: () => FragmentSelectorType,
  GetMediaCapturePipelineCommand: () => GetMediaCapturePipelineCommand,
  GetMediaCapturePipelineResponseFilterSensitiveLog: () => GetMediaCapturePipelineResponseFilterSensitiveLog,
  GetMediaInsightsPipelineConfigurationCommand: () => GetMediaInsightsPipelineConfigurationCommand,
  GetMediaInsightsPipelineConfigurationResponseFilterSensitiveLog: () => GetMediaInsightsPipelineConfigurationResponseFilterSensitiveLog,
  GetMediaPipelineCommand: () => GetMediaPipelineCommand,
  GetMediaPipelineKinesisVideoStreamPoolCommand: () => GetMediaPipelineKinesisVideoStreamPoolCommand,
  GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog: () => GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
  GetMediaPipelineResponseFilterSensitiveLog: () => GetMediaPipelineResponseFilterSensitiveLog,
  GetSpeakerSearchTaskCommand: () => GetSpeakerSearchTaskCommand,
  GetVoiceToneAnalysisTaskCommand: () => GetVoiceToneAnalysisTaskCommand,
  HighlightColor: () => HighlightColor,
  HorizontalTilePosition: () => HorizontalTilePosition,
  KinesisDataStreamSinkConfigurationFilterSensitiveLog: () => KinesisDataStreamSinkConfigurationFilterSensitiveLog,
  KinesisVideoStreamPoolConfigurationFilterSensitiveLog: () => KinesisVideoStreamPoolConfigurationFilterSensitiveLog,
  KinesisVideoStreamPoolStatus: () => KinesisVideoStreamPoolStatus,
  KinesisVideoStreamPoolSummaryFilterSensitiveLog: () => KinesisVideoStreamPoolSummaryFilterSensitiveLog,
  LambdaFunctionSinkConfigurationFilterSensitiveLog: () => LambdaFunctionSinkConfigurationFilterSensitiveLog,
  LayoutOption: () => LayoutOption,
  ListMediaCapturePipelinesCommand: () => ListMediaCapturePipelinesCommand,
  ListMediaInsightsPipelineConfigurationsCommand: () => ListMediaInsightsPipelineConfigurationsCommand,
  ListMediaInsightsPipelineConfigurationsResponseFilterSensitiveLog: () => ListMediaInsightsPipelineConfigurationsResponseFilterSensitiveLog,
  ListMediaPipelineKinesisVideoStreamPoolsCommand: () => ListMediaPipelineKinesisVideoStreamPoolsCommand,
  ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog: () => ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog,
  ListMediaPipelinesCommand: () => ListMediaPipelinesCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  LiveConnectorMuxType: () => LiveConnectorMuxType,
  LiveConnectorRTMPConfigurationFilterSensitiveLog: () => LiveConnectorRTMPConfigurationFilterSensitiveLog,
  LiveConnectorSinkConfigurationFilterSensitiveLog: () => LiveConnectorSinkConfigurationFilterSensitiveLog,
  LiveConnectorSinkType: () => LiveConnectorSinkType,
  LiveConnectorSourceConfigurationFilterSensitiveLog: () => LiveConnectorSourceConfigurationFilterSensitiveLog,
  LiveConnectorSourceType: () => LiveConnectorSourceType,
  MediaCapturePipelineFilterSensitiveLog: () => MediaCapturePipelineFilterSensitiveLog,
  MediaCapturePipelineSourceConfigurationFilterSensitiveLog: () => MediaCapturePipelineSourceConfigurationFilterSensitiveLog,
  MediaConcatenationPipelineFilterSensitiveLog: () => MediaConcatenationPipelineFilterSensitiveLog,
  MediaEncoding: () => MediaEncoding,
  MediaInsightsPipelineConfigurationElementFilterSensitiveLog: () => MediaInsightsPipelineConfigurationElementFilterSensitiveLog,
  MediaInsightsPipelineConfigurationElementType: () => MediaInsightsPipelineConfigurationElementType,
  MediaInsightsPipelineConfigurationFilterSensitiveLog: () => MediaInsightsPipelineConfigurationFilterSensitiveLog,
  MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog: () => MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog,
  MediaInsightsPipelineFilterSensitiveLog: () => MediaInsightsPipelineFilterSensitiveLog,
  MediaLiveConnectorPipelineFilterSensitiveLog: () => MediaLiveConnectorPipelineFilterSensitiveLog,
  MediaPipelineElementStatus: () => MediaPipelineElementStatus,
  MediaPipelineFilterSensitiveLog: () => MediaPipelineFilterSensitiveLog,
  MediaPipelineSinkType: () => MediaPipelineSinkType,
  MediaPipelineSourceType: () => MediaPipelineSourceType,
  MediaPipelineStatus: () => MediaPipelineStatus,
  MediaPipelineStatusUpdate: () => MediaPipelineStatusUpdate,
  MediaPipelineTaskStatus: () => MediaPipelineTaskStatus,
  MediaStreamPipelineFilterSensitiveLog: () => MediaStreamPipelineFilterSensitiveLog,
  MediaStreamPipelineSinkType: () => MediaStreamPipelineSinkType,
  MediaStreamSinkFilterSensitiveLog: () => MediaStreamSinkFilterSensitiveLog,
  MediaStreamSourceFilterSensitiveLog: () => MediaStreamSourceFilterSensitiveLog,
  MediaStreamType: () => MediaStreamType,
  NotFoundException: () => NotFoundException,
  PartialResultsStability: () => PartialResultsStability,
  ParticipantRole: () => ParticipantRole,
  PresenterPosition: () => PresenterPosition,
  RealTimeAlertRuleType: () => RealTimeAlertRuleType,
  RecordingFileFormat: () => RecordingFileFormat,
  ResolutionOption: () => ResolutionOption,
  ResourceLimitExceededException: () => ResourceLimitExceededException,
  S3BucketSinkConfigurationFilterSensitiveLog: () => S3BucketSinkConfigurationFilterSensitiveLog,
  S3RecordingSinkConfigurationFilterSensitiveLog: () => S3RecordingSinkConfigurationFilterSensitiveLog,
  S3RecordingSinkRuntimeConfigurationFilterSensitiveLog: () => S3RecordingSinkRuntimeConfigurationFilterSensitiveLog,
  SelectedVideoStreamsFilterSensitiveLog: () => SelectedVideoStreamsFilterSensitiveLog,
  SentimentType: () => SentimentType,
  ServiceFailureException: () => ServiceFailureException,
  ServiceUnavailableException: () => ServiceUnavailableException,
  SnsTopicSinkConfigurationFilterSensitiveLog: () => SnsTopicSinkConfigurationFilterSensitiveLog,
  SourceConfigurationFilterSensitiveLog: () => SourceConfigurationFilterSensitiveLog,
  SqsQueueSinkConfigurationFilterSensitiveLog: () => SqsQueueSinkConfigurationFilterSensitiveLog,
  StartSpeakerSearchTaskCommand: () => StartSpeakerSearchTaskCommand,
  StartSpeakerSearchTaskRequestFilterSensitiveLog: () => StartSpeakerSearchTaskRequestFilterSensitiveLog,
  StartVoiceToneAnalysisTaskCommand: () => StartVoiceToneAnalysisTaskCommand,
  StartVoiceToneAnalysisTaskRequestFilterSensitiveLog: () => StartVoiceToneAnalysisTaskRequestFilterSensitiveLog,
  StopSpeakerSearchTaskCommand: () => StopSpeakerSearchTaskCommand,
  StopVoiceToneAnalysisTaskCommand: () => StopVoiceToneAnalysisTaskCommand,
  TagResourceCommand: () => TagResourceCommand,
  ThrottledClientException: () => ThrottledClientException,
  TileOrder: () => TileOrder,
  UnauthorizedClientException: () => UnauthorizedClientException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateMediaInsightsPipelineConfigurationCommand: () => UpdateMediaInsightsPipelineConfigurationCommand,
  UpdateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog: () => UpdateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog,
  UpdateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog: () => UpdateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog,
  UpdateMediaInsightsPipelineStatusCommand: () => UpdateMediaInsightsPipelineStatusCommand,
  UpdateMediaPipelineKinesisVideoStreamPoolCommand: () => UpdateMediaPipelineKinesisVideoStreamPoolCommand,
  UpdateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog: () => UpdateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog,
  VerticalTilePosition: () => VerticalTilePosition,
  VideoMuxType: () => VideoMuxType,
  VocabularyFilterMethod: () => VocabularyFilterMethod,
  VoiceAnalyticsConfigurationStatus: () => VoiceAnalyticsConfigurationStatus,
  VoiceAnalyticsLanguageCode: () => VoiceAnalyticsLanguageCode,
  __Client: () => import_smithy_client.Client,
  paginateListMediaCapturePipelines: () => paginateListMediaCapturePipelines,
  paginateListMediaInsightsPipelineConfigurations: () => paginateListMediaInsightsPipelineConfigurations,
  paginateListMediaPipelineKinesisVideoStreamPools: () => paginateListMediaPipelineKinesisVideoStreamPools,
  paginateListMediaPipelines: () => paginateListMediaPipelines
});
module.exports = __toCommonJS(src_exports);

// src/ChimeSDKMediaPipelinesClient.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 {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "chime"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/ChimeSDKMediaPipelinesClient.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 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)),
    ...asPartial(getHttpAuthExtensionConfiguration(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),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/ChimeSDKMediaPipelinesClient.ts
var _ChimeSDKMediaPipelinesClient = class _ChimeSDKMediaPipelinesClient 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_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 == null ? void 0 : configuration.extensions) || []);
    super(_config_8);
    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.defaultChimeSDKMediaPipelinesHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        })
      })
    );
    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();
  }
};
__name(_ChimeSDKMediaPipelinesClient, "ChimeSDKMediaPipelinesClient");
var ChimeSDKMediaPipelinesClient = _ChimeSDKMediaPipelinesClient;

// src/ChimeSDKMediaPipelines.ts


// src/commands/CreateMediaCapturePipelineCommand.ts

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


// src/models/models_0.ts


// src/models/ChimeSDKMediaPipelinesServiceException.ts

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

// src/models/models_0.ts
var ActiveSpeakerPosition = {
  BottomLeft: "BottomLeft",
  BottomRight: "BottomRight",
  TopLeft: "TopLeft",
  TopRight: "TopRight"
};
var ContentType = {
  PII: "PII"
};
var CallAnalyticsLanguageCode = {
  DE_DE: "de-DE",
  EN_AU: "en-AU",
  EN_GB: "en-GB",
  EN_US: "en-US",
  ES_US: "es-US",
  FR_CA: "fr-CA",
  FR_FR: "fr-FR",
  IT_IT: "it-IT",
  PT_BR: "pt-BR"
};
var PartialResultsStability = {
  HIGH: "high",
  LOW: "low",
  MEDIUM: "medium"
};
var ContentRedactionOutput = {
  REDACTED: "redacted",
  REDACTED_AND_UNREDACTED: "redacted_and_unredacted"
};
var VocabularyFilterMethod = {
  MASK: "mask",
  REMOVE: "remove",
  TAG: "tag"
};
var AudioArtifactsConcatenationState = {
  Enabled: "Enabled"
};
var ArtifactsConcatenationState = {
  Disabled: "Disabled",
  Enabled: "Enabled"
};
var AudioMuxType = {
  AudioOnly: "AudioOnly",
  AudioWithActiveSpeakerVideo: "AudioWithActiveSpeakerVideo",
  AudioWithCompositedVideo: "AudioWithCompositedVideo"
};
var CanvasOrientation = {
  Landscape: "Landscape",
  Portrait: "Portrait"
};
var ContentShareLayoutOption = {
  ActiveSpeakerOnly: "ActiveSpeakerOnly",
  Horizontal: "Horizontal",
  PresenterOnly: "PresenterOnly",
  Vertical: "Vertical"
};
var TileOrder = {
  JoinSequence: "JoinSequence",
  SpeakerSequence: "SpeakerSequence"
};
var HorizontalTilePosition = {
  Bottom: "Bottom",
  Top: "Top"
};
var PresenterPosition = {
  BottomLeft: "BottomLeft",
  BottomRight: "BottomRight",
  TopLeft: "TopLeft",
  TopRight: "TopRight"
};
var VerticalTilePosition = {
  Left: "Left",
  Right: "Right"
};
var BorderColor = {
  Black: "Black",
  Blue: "Blue",
  Green: "Green",
  Red: "Red",
  White: "White",
  Yellow: "Yellow"
};
var HighlightColor = {
  Black: "Black",
  Blue: "Blue",
  Green: "Green",
  Red: "Red",
  White: "White",
  Yellow: "Yellow"
};
var LayoutOption = {
  GridView: "GridView"
};
var ResolutionOption = {
  FHD: "FHD",
  HD: "HD"
};
var ContentMuxType = {
  ContentOnly: "ContentOnly"
};
var ArtifactsState = {
  Disabled: "Disabled",
  Enabled: "Enabled"
};
var VideoMuxType = {
  VideoOnly: "VideoOnly"
};
var AudioChannelsOption = {
  Mono: "Mono",
  Stereo: "Stereo"
};
var ErrorCode = {
  BadRequest: "BadRequest",
  Forbidden: "Forbidden",
  NotFound: "NotFound",
  ResourceLimitExceeded: "ResourceLimitExceeded",
  ServiceFailure: "ServiceFailure",
  ServiceUnavailable: "ServiceUnavailable",
  Throttling: "Throttling"
};
var _BadRequestException = class _BadRequestException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "BadRequestException",
      $fault: "client",
      ...opts
    });
    this.name = "BadRequestException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _BadRequestException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_BadRequestException, "BadRequestException");
var BadRequestException = _BadRequestException;
var ParticipantRole = {
  AGENT: "AGENT",
  CUSTOMER: "CUSTOMER"
};
var MediaPipelineSinkType = {
  S3Bucket: "S3Bucket"
};
var MediaPipelineSourceType = {
  ChimeSdkMeeting: "ChimeSdkMeeting"
};
var MediaPipelineStatus = {
  Failed: "Failed",
  InProgress: "InProgress",
  Initializing: "Initializing",
  NotStarted: "NotStarted",
  Paused: "Paused",
  Stopped: "Stopped",
  Stopping: "Stopping"
};
var _ForbiddenException = class _ForbiddenException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ForbiddenException",
      $fault: "client",
      ...opts
    });
    this.name = "ForbiddenException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ForbiddenException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ForbiddenException, "ForbiddenException");
var ForbiddenException = _ForbiddenException;
var _ResourceLimitExceededException = class _ResourceLimitExceededException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceLimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceLimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceLimitExceededException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ResourceLimitExceededException, "ResourceLimitExceededException");
var ResourceLimitExceededException = _ResourceLimitExceededException;
var _ServiceFailureException = class _ServiceFailureException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceFailureException",
      $fault: "server",
      ...opts
    });
    this.name = "ServiceFailureException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _ServiceFailureException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ServiceFailureException, "ServiceFailureException");
var ServiceFailureException = _ServiceFailureException;
var _ServiceUnavailableException = class _ServiceUnavailableException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceUnavailableException",
      $fault: "server",
      ...opts
    });
    this.name = "ServiceUnavailableException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ServiceUnavailableException, "ServiceUnavailableException");
var ServiceUnavailableException = _ServiceUnavailableException;
var _ThrottledClientException = class _ThrottledClientException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ThrottledClientException",
      $fault: "client",
      ...opts
    });
    this.name = "ThrottledClientException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ThrottledClientException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ThrottledClientException, "ThrottledClientException");
var ThrottledClientException = _ThrottledClientException;
var _UnauthorizedClientException = class _UnauthorizedClientException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnauthorizedClientException",
      $fault: "client",
      ...opts
    });
    this.name = "UnauthorizedClientException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnauthorizedClientException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_UnauthorizedClientException, "UnauthorizedClientException");
var UnauthorizedClientException = _UnauthorizedClientException;
var ConcatenationSinkType = {
  S3Bucket: "S3Bucket"
};
var ConcatenationSourceType = {
  MediaCapturePipeline: "MediaCapturePipeline"
};
var FragmentSelectorType = {
  ProducerTimestamp: "ProducerTimestamp",
  ServerTimestamp: "ServerTimestamp"
};
var MediaEncoding = {
  PCM: "pcm"
};
var RecordingFileFormat = {
  Opus: "Opus",
  Wav: "Wav"
};
var MediaPipelineElementStatus = {
  Failed: "Failed",
  InProgress: "InProgress",
  Initializing: "Initializing",
  NotStarted: "NotStarted",
  NotSupported: "NotSupported",
  Paused: "Paused",
  Stopped: "Stopped",
  Stopping: "Stopping"
};
var MediaInsightsPipelineConfigurationElementType = {
  AMAZON_TRANSCRIBE_CALL_ANALYTICS_PROCESSOR: "AmazonTranscribeCallAnalyticsProcessor",
  AMAZON_TRANSCRIBE_PROCESSOR: "AmazonTranscribeProcessor",
  KINESIS_DATA_STREAM_SINK: "KinesisDataStreamSink",
  LAMBDA_FUNCTION_SINK: "LambdaFunctionSink",
  S3_RECORDING_SINK: "S3RecordingSink",
  SNS_TOPIC_SINK: "SnsTopicSink",
  SQS_QUEUE_SINK: "SqsQueueSink",
  VOICE_ANALYTICS_PROCESSOR: "VoiceAnalyticsProcessor",
  VOICE_ENHANCEMENT_SINK: "VoiceEnhancementSink"
};
var _NotFoundException = class _NotFoundException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "NotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "NotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _NotFoundException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_NotFoundException, "NotFoundException");
var NotFoundException = _NotFoundException;
var VoiceAnalyticsConfigurationStatus = {
  DISABLED: "Disabled",
  ENABLED: "Enabled"
};
var SentimentType = {
  NEGATIVE: "NEGATIVE"
};
var RealTimeAlertRuleType = {
  IssueDetection: "IssueDetection",
  KeywordMatch: "KeywordMatch",
  Sentiment: "Sentiment"
};
var LiveConnectorSinkType = {
  RTMP: "RTMP"
};
var LiveConnectorMuxType = {
  AudioWithActiveSpeakerVideo: "AudioWithActiveSpeakerVideo",
  AudioWithCompositedVideo: "AudioWithCompositedVideo"
};
var LiveConnectorSourceType = {
  ChimeSdkMeeting: "ChimeSdkMeeting"
};
var _ConflictException = class _ConflictException extends ChimeSDKMediaPipelinesServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "ConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConflictException.prototype);
    this.Code = opts.Code;
    this.Message = opts.Message;
    this.RequestId = opts.RequestId;
  }
};
__name(_ConflictException, "ConflictException");
var ConflictException = _ConflictException;
var KinesisVideoStreamPoolStatus = {
  ACTIVE: "ACTIVE",
  CREATING: "CREATING",
  DELETING: "DELETING",
  FAILED: "FAILED",
  UPDATING: "UPDATING"
};
var MediaStreamType = {
  IndividualAudio: "IndividualAudio",
  MixedAudio: "MixedAudio"
};
var MediaStreamPipelineSinkType = {
  KinesisVideoStreamPool: "KinesisVideoStreamPool"
};
var MediaPipelineTaskStatus = {
  Failed: "Failed",
  InProgress: "InProgress",
  Initializing: "Initializing",
  NotStarted: "NotStarted",
  Stopped: "Stopped",
  Stopping: "Stopping"
};
var VoiceAnalyticsLanguageCode = {
  EN_US: "en-US"
};
var MediaPipelineStatusUpdate = {
  Pause: "Pause",
  Resume: "Resume"
};
var SelectedVideoStreamsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ExternalUserIds && { ExternalUserIds: import_smithy_client.SENSITIVE_STRING }
}), "SelectedVideoStreamsFilterSensitiveLog");
var SourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SelectedVideoStreams && {
    SelectedVideoStreams: SelectedVideoStreamsFilterSensitiveLog(obj.SelectedVideoStreams)
  }
}), "SourceConfigurationFilterSensitiveLog");
var ChimeSdkMeetingConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SourceConfiguration && {
    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration)
  }
}), "ChimeSdkMeetingConfigurationFilterSensitiveLog");
var CreateMediaCapturePipelineRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SourceArn && { SourceArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.SinkArn && { SinkArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.ChimeSdkMeetingConfiguration && {
    ChimeSdkMeetingConfiguration: ChimeSdkMeetingConfigurationFilterSensitiveLog(obj.ChimeSdkMeetingConfiguration)
  }
}), "CreateMediaCapturePipelineRequestFilterSensitiveLog");
var MediaCapturePipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SourceArn && { SourceArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.SinkArn && { SinkArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.ChimeSdkMeetingConfiguration && {
    ChimeSdkMeetingConfiguration: ChimeSdkMeetingConfigurationFilterSensitiveLog(obj.ChimeSdkMeetingConfiguration)
  }
}), "MediaCapturePipelineFilterSensitiveLog");
var CreateMediaCapturePipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaCapturePipeline && {
    MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline)
  }
}), "CreateMediaCapturePipelineResponseFilterSensitiveLog");
var S3BucketSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING }
}), "S3BucketSinkConfigurationFilterSensitiveLog");
var ConcatenationSinkFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.S3BucketSinkConfiguration && {
    S3BucketSinkConfiguration: S3BucketSinkConfigurationFilterSensitiveLog(obj.S3BucketSinkConfiguration)
  }
}), "ConcatenationSinkFilterSensitiveLog");
var MediaCapturePipelineSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaPipelineArn && { MediaPipelineArn: import_smithy_client.SENSITIVE_STRING }
}), "MediaCapturePipelineSourceConfigurationFilterSensitiveLog");
var ConcatenationSourceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaCapturePipelineSourceConfiguration && {
    MediaCapturePipelineSourceConfiguration: MediaCapturePipelineSourceConfigurationFilterSensitiveLog(
      obj.MediaCapturePipelineSourceConfiguration
    )
  }
}), "ConcatenationSourceFilterSensitiveLog");
var CreateMediaConcatenationPipelineRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => ConcatenationSourceFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => ConcatenationSinkFilterSensitiveLog(item)) },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaConcatenationPipelineRequestFilterSensitiveLog");
var MediaConcatenationPipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => ConcatenationSourceFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => ConcatenationSinkFilterSensitiveLog(item)) }
}), "MediaConcatenationPipelineFilterSensitiveLog");
var CreateMediaConcatenationPipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaConcatenationPipeline && {
    MediaConcatenationPipeline: MediaConcatenationPipelineFilterSensitiveLog(obj.MediaConcatenationPipeline)
  }
}), "CreateMediaConcatenationPipelineResponseFilterSensitiveLog");
var S3RecordingSinkRuntimeConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING }
}), "S3RecordingSinkRuntimeConfigurationFilterSensitiveLog");
var CreateMediaInsightsPipelineRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfigurationArn && { MediaInsightsPipelineConfigurationArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.MediaInsightsRuntimeMetadata && { MediaInsightsRuntimeMetadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.S3RecordingSinkRuntimeConfiguration && {
    S3RecordingSinkRuntimeConfiguration: S3RecordingSinkRuntimeConfigurationFilterSensitiveLog(
      obj.S3RecordingSinkRuntimeConfiguration
    )
  },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaInsightsPipelineRequestFilterSensitiveLog");
var MediaInsightsPipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaPipelineArn && { MediaPipelineArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.MediaInsightsPipelineConfigurationArn && { MediaInsightsPipelineConfigurationArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.MediaInsightsRuntimeMetadata && { MediaInsightsRuntimeMetadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.S3RecordingSinkRuntimeConfiguration && {
    S3RecordingSinkRuntimeConfiguration: S3RecordingSinkRuntimeConfigurationFilterSensitiveLog(
      obj.S3RecordingSinkRuntimeConfiguration
    )
  }
}), "MediaInsightsPipelineFilterSensitiveLog");
var CreateMediaInsightsPipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipeline && {
    MediaInsightsPipeline: MediaInsightsPipelineFilterSensitiveLog(obj.MediaInsightsPipeline)
  }
}), "CreateMediaInsightsPipelineResponseFilterSensitiveLog");
var KinesisDataStreamSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InsightsTarget && { InsightsTarget: import_smithy_client.SENSITIVE_STRING }
}), "KinesisDataStreamSinkConfigurationFilterSensitiveLog");
var LambdaFunctionSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InsightsTarget && { InsightsTarget: import_smithy_client.SENSITIVE_STRING }
}), "LambdaFunctionSinkConfigurationFilterSensitiveLog");
var S3RecordingSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Destination && { Destination: import_smithy_client.SENSITIVE_STRING }
}), "S3RecordingSinkConfigurationFilterSensitiveLog");
var SnsTopicSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InsightsTarget && { InsightsTarget: import_smithy_client.SENSITIVE_STRING }
}), "SnsTopicSinkConfigurationFilterSensitiveLog");
var SqsQueueSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InsightsTarget && { InsightsTarget: import_smithy_client.SENSITIVE_STRING }
}), "SqsQueueSinkConfigurationFilterSensitiveLog");
var MediaInsightsPipelineConfigurationElementFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KinesisDataStreamSinkConfiguration && {
    KinesisDataStreamSinkConfiguration: KinesisDataStreamSinkConfigurationFilterSensitiveLog(
      obj.KinesisDataStreamSinkConfiguration
    )
  },
  ...obj.S3RecordingSinkConfiguration && {
    S3RecordingSinkConfiguration: S3RecordingSinkConfigurationFilterSensitiveLog(obj.S3RecordingSinkConfiguration)
  },
  ...obj.LambdaFunctionSinkConfiguration && {
    LambdaFunctionSinkConfiguration: LambdaFunctionSinkConfigurationFilterSensitiveLog(
      obj.LambdaFunctionSinkConfiguration
    )
  },
  ...obj.SqsQueueSinkConfiguration && {
    SqsQueueSinkConfiguration: SqsQueueSinkConfigurationFilterSensitiveLog(obj.SqsQueueSinkConfiguration)
  },
  ...obj.SnsTopicSinkConfiguration && {
    SnsTopicSinkConfiguration: SnsTopicSinkConfigurationFilterSensitiveLog(obj.SnsTopicSinkConfiguration)
  }
}), "MediaInsightsPipelineConfigurationElementFilterSensitiveLog");
var CreateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ResourceAccessRoleArn && { ResourceAccessRoleArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.Elements && {
    Elements: obj.Elements.map((item) => MediaInsightsPipelineConfigurationElementFilterSensitiveLog(item))
  },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaInsightsPipelineConfigurationRequestFilterSensitiveLog");
var MediaInsightsPipelineConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfigurationArn && { MediaInsightsPipelineConfigurationArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.ResourceAccessRoleArn && { ResourceAccessRoleArn: import_smithy_client.SENSITIVE_STRING },
  ...obj.Elements && {
    Elements: obj.Elements.map((item) => MediaInsightsPipelineConfigurationElementFilterSensitiveLog(item))
  }
}), "MediaInsightsPipelineConfigurationFilterSensitiveLog");
var CreateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfiguration && {
    MediaInsightsPipelineConfiguration: MediaInsightsPipelineConfigurationFilterSensitiveLog(
      obj.MediaInsightsPipelineConfiguration
    )
  }
}), "CreateMediaInsightsPipelineConfigurationResponseFilterSensitiveLog");
var LiveConnectorRTMPConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Url && { Url: import_smithy_client.SENSITIVE_STRING }
}), "LiveConnectorRTMPConfigurationFilterSensitiveLog");
var LiveConnectorSinkConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.RTMPConfiguration && {
    RTMPConfiguration: LiveConnectorRTMPConfigurationFilterSensitiveLog(obj.RTMPConfiguration)
  }
}), "LiveConnectorSinkConfigurationFilterSensitiveLog");
var ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Arn && { Arn: import_smithy_client.SENSITIVE_STRING },
  ...obj.SourceConfiguration && {
    SourceConfiguration: SourceConfigurationFilterSensitiveLog(obj.SourceConfiguration)
  }
}), "ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog");
var LiveConnectorSourceConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChimeSdkMeetingLiveConnectorConfiguration && {
    ChimeSdkMeetingLiveConnectorConfiguration: ChimeSdkMeetingLiveConnectorConfigurationFilterSensitiveLog(
      obj.ChimeSdkMeetingLiveConnectorConfiguration
    )
  }
}), "LiveConnectorSourceConfigurationFilterSensitiveLog");
var CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => LiveConnectorSourceConfigurationFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => LiveConnectorSinkConfigurationFilterSensitiveLog(item)) },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaLiveConnectorPipelineRequestFilterSensitiveLog");
var MediaLiveConnectorPipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => LiveConnectorSourceConfigurationFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => LiveConnectorSinkConfigurationFilterSensitiveLog(item)) }
}), "MediaLiveConnectorPipelineFilterSensitiveLog");
var CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaLiveConnectorPipeline && {
    MediaLiveConnectorPipeline: MediaLiveConnectorPipelineFilterSensitiveLog(obj.MediaLiveConnectorPipeline)
  }
}), "CreateMediaLiveConnectorPipelineResponseFilterSensitiveLog");
var CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaPipelineKinesisVideoStreamPoolRequestFilterSensitiveLog");
var KinesisVideoStreamPoolConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PoolArn && { PoolArn: import_smithy_client.SENSITIVE_STRING }
}), "KinesisVideoStreamPoolConfigurationFilterSensitiveLog");
var CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KinesisVideoStreamPoolConfiguration && {
    KinesisVideoStreamPoolConfiguration: KinesisVideoStreamPoolConfigurationFilterSensitiveLog(
      obj.KinesisVideoStreamPoolConfiguration
    )
  }
}), "CreateMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog");
var MediaStreamSinkFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SinkArn && { SinkArn: import_smithy_client.SENSITIVE_STRING }
}), "MediaStreamSinkFilterSensitiveLog");
var MediaStreamSourceFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.SourceArn && { SourceArn: import_smithy_client.SENSITIVE_STRING }
}), "MediaStreamSourceFilterSensitiveLog");
var CreateMediaStreamPipelineRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => MediaStreamSourceFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => MediaStreamSinkFilterSensitiveLog(item)) },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateMediaStreamPipelineRequestFilterSensitiveLog");
var MediaStreamPipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sources && { Sources: obj.Sources.map((item) => MediaStreamSourceFilterSensitiveLog(item)) },
  ...obj.Sinks && { Sinks: obj.Sinks.map((item) => MediaStreamSinkFilterSensitiveLog(item)) }
}), "MediaStreamPipelineFilterSensitiveLog");
var CreateMediaStreamPipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaStreamPipeline && {
    MediaStreamPipeline: MediaStreamPipelineFilterSensitiveLog(obj.MediaStreamPipeline)
  }
}), "CreateMediaStreamPipelineResponseFilterSensitiveLog");
var GetMediaCapturePipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaCapturePipeline && {
    MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline)
  }
}), "GetMediaCapturePipelineResponseFilterSensitiveLog");
var GetMediaInsightsPipelineConfigurationResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfiguration && {
    MediaInsightsPipelineConfiguration: MediaInsightsPipelineConfigurationFilterSensitiveLog(
      obj.MediaInsightsPipelineConfiguration
    )
  }
}), "GetMediaInsightsPipelineConfigurationResponseFilterSensitiveLog");
var MediaPipelineFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaCapturePipeline && {
    MediaCapturePipeline: MediaCapturePipelineFilterSensitiveLog(obj.MediaCapturePipeline)
  },
  ...obj.MediaLiveConnectorPipeline && {
    MediaLiveConnectorPipeline: MediaLiveConnectorPipelineFilterSensitiveLog(obj.MediaLiveConnectorPipeline)
  },
  ...obj.MediaConcatenationPipeline && {
    MediaConcatenationPipeline: MediaConcatenationPipelineFilterSensitiveLog(obj.MediaConcatenationPipeline)
  },
  ...obj.MediaInsightsPipeline && {
    MediaInsightsPipeline: MediaInsightsPipelineFilterSensitiveLog(obj.MediaInsightsPipeline)
  },
  ...obj.MediaStreamPipeline && {
    MediaStreamPipeline: MediaStreamPipelineFilterSensitiveLog(obj.MediaStreamPipeline)
  }
}), "MediaPipelineFilterSensitiveLog");
var GetMediaPipelineResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaPipeline && { MediaPipeline: MediaPipelineFilterSensitiveLog(obj.MediaPipeline) }
}), "GetMediaPipelineResponseFilterSensitiveLog");
var GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KinesisVideoStreamPoolConfiguration && {
    KinesisVideoStreamPoolConfiguration: KinesisVideoStreamPoolConfigurationFilterSensitiveLog(
      obj.KinesisVideoStreamPoolConfiguration
    )
  }
}), "GetMediaPipelineKinesisVideoStreamPoolResponseFilterSensitiveLog");
var MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfigurationArn && { MediaInsightsPipelineConfigurationArn: import_smithy_client.SENSITIVE_STRING }
}), "MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog");
var ListMediaInsightsPipelineConfigurationsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.MediaInsightsPipelineConfigurations && {
    MediaInsightsPipelineConfigurations: obj.MediaInsightsPipelineConfigurations.map(
      (item) => MediaInsightsPipelineConfigurationSummaryFilterSensitiveLog(item)
    )
  }
}), "ListMediaInsightsPipelineConfigurationsResponseFilterSensitiveLog");
var KinesisVideoStreamPoolSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PoolArn && { PoolArn: import_smithy_client.SENSITIVE_STRING }
}), "KinesisVideoStreamPoolSummaryFilterSensitiveLog");
var ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.KinesisVideoStreamPools && {
    KinesisVideoStreamPools: obj.KinesisVideoStreamPools.map(
      (item) => KinesisVideoStreamPoolSummaryFilterSensitiveLog(item)
    )
  }
}), "ListMediaPipelineKinesisVideoStreamPoolsResponseFilterSensitiveLog");
var StartSpeakerSearchTaskRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.VoiceProfileDomainArn && { VoiceProfileDomainArn: import_smithy_client.SENSITIVE_STRING },
  ...o