cdk-amazon-chime-resources/node_modules/@aws-sdk/client-chime-sdk-messaging/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, {
  AllowNotifications: () => AllowNotifications,
  AssociateChannelFlowCommand: () => AssociateChannelFlowCommand,
  BadRequestException: () => BadRequestException,
  BatchChannelMembershipsFilterSensitiveLog: () => BatchChannelMembershipsFilterSensitiveLog,
  BatchCreateChannelMembershipCommand: () => BatchCreateChannelMembershipCommand,
  BatchCreateChannelMembershipResponseFilterSensitiveLog: () => BatchCreateChannelMembershipResponseFilterSensitiveLog,
  ChannelAssociatedWithFlowSummaryFilterSensitiveLog: () => ChannelAssociatedWithFlowSummaryFilterSensitiveLog,
  ChannelBanFilterSensitiveLog: () => ChannelBanFilterSensitiveLog,
  ChannelBanSummaryFilterSensitiveLog: () => ChannelBanSummaryFilterSensitiveLog,
  ChannelFilterSensitiveLog: () => ChannelFilterSensitiveLog,
  ChannelFlowCallbackCommand: () => ChannelFlowCallbackCommand,
  ChannelFlowCallbackRequestFilterSensitiveLog: () => ChannelFlowCallbackRequestFilterSensitiveLog,
  ChannelFlowFilterSensitiveLog: () => ChannelFlowFilterSensitiveLog,
  ChannelFlowSummaryFilterSensitiveLog: () => ChannelFlowSummaryFilterSensitiveLog,
  ChannelMembershipFilterSensitiveLog: () => ChannelMembershipFilterSensitiveLog,
  ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog: () => ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog,
  ChannelMembershipPreferencesFilterSensitiveLog: () => ChannelMembershipPreferencesFilterSensitiveLog,
  ChannelMembershipSummaryFilterSensitiveLog: () => ChannelMembershipSummaryFilterSensitiveLog,
  ChannelMembershipType: () => ChannelMembershipType,
  ChannelMessageCallbackFilterSensitiveLog: () => ChannelMessageCallbackFilterSensitiveLog,
  ChannelMessageFilterSensitiveLog: () => ChannelMessageFilterSensitiveLog,
  ChannelMessagePersistenceType: () => ChannelMessagePersistenceType,
  ChannelMessageStatus: () => ChannelMessageStatus,
  ChannelMessageSummaryFilterSensitiveLog: () => ChannelMessageSummaryFilterSensitiveLog,
  ChannelMessageType: () => ChannelMessageType,
  ChannelMode: () => ChannelMode,
  ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog: () => ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog,
  ChannelModeratorFilterSensitiveLog: () => ChannelModeratorFilterSensitiveLog,
  ChannelModeratorSummaryFilterSensitiveLog: () => ChannelModeratorSummaryFilterSensitiveLog,
  ChannelPrivacy: () => ChannelPrivacy,
  ChannelSummaryFilterSensitiveLog: () => ChannelSummaryFilterSensitiveLog,
  ChimeSDKMessaging: () => ChimeSDKMessaging,
  ChimeSDKMessagingClient: () => ChimeSDKMessagingClient,
  ChimeSDKMessagingServiceException: () => ChimeSDKMessagingServiceException,
  ConflictException: () => ConflictException,
  CreateChannelBanCommand: () => CreateChannelBanCommand,
  CreateChannelBanResponseFilterSensitiveLog: () => CreateChannelBanResponseFilterSensitiveLog,
  CreateChannelCommand: () => CreateChannelCommand,
  CreateChannelFlowCommand: () => CreateChannelFlowCommand,
  CreateChannelFlowRequestFilterSensitiveLog: () => CreateChannelFlowRequestFilterSensitiveLog,
  CreateChannelMembershipCommand: () => CreateChannelMembershipCommand,
  CreateChannelMembershipResponseFilterSensitiveLog: () => CreateChannelMembershipResponseFilterSensitiveLog,
  CreateChannelModeratorCommand: () => CreateChannelModeratorCommand,
  CreateChannelModeratorResponseFilterSensitiveLog: () => CreateChannelModeratorResponseFilterSensitiveLog,
  CreateChannelRequestFilterSensitiveLog: () => CreateChannelRequestFilterSensitiveLog,
  DeleteChannelBanCommand: () => DeleteChannelBanCommand,
  DeleteChannelCommand: () => DeleteChannelCommand,
  DeleteChannelFlowCommand: () => DeleteChannelFlowCommand,
  DeleteChannelMembershipCommand: () => DeleteChannelMembershipCommand,
  DeleteChannelMessageCommand: () => DeleteChannelMessageCommand,
  DeleteChannelModeratorCommand: () => DeleteChannelModeratorCommand,
  DeleteMessagingStreamingConfigurationsCommand: () => DeleteMessagingStreamingConfigurationsCommand,
  DescribeChannelBanCommand: () => DescribeChannelBanCommand,
  DescribeChannelBanResponseFilterSensitiveLog: () => DescribeChannelBanResponseFilterSensitiveLog,
  DescribeChannelCommand: () => DescribeChannelCommand,
  DescribeChannelFlowCommand: () => DescribeChannelFlowCommand,
  DescribeChannelFlowResponseFilterSensitiveLog: () => DescribeChannelFlowResponseFilterSensitiveLog,
  DescribeChannelMembershipCommand: () => DescribeChannelMembershipCommand,
  DescribeChannelMembershipForAppInstanceUserCommand: () => DescribeChannelMembershipForAppInstanceUserCommand,
  DescribeChannelMembershipForAppInstanceUserResponseFilterSensitiveLog: () => DescribeChannelMembershipForAppInstanceUserResponseFilterSensitiveLog,
  DescribeChannelMembershipResponseFilterSensitiveLog: () => DescribeChannelMembershipResponseFilterSensitiveLog,
  DescribeChannelModeratedByAppInstanceUserCommand: () => DescribeChannelModeratedByAppInstanceUserCommand,
  DescribeChannelModeratedByAppInstanceUserResponseFilterSensitiveLog: () => DescribeChannelModeratedByAppInstanceUserResponseFilterSensitiveLog,
  DescribeChannelModeratorCommand: () => DescribeChannelModeratorCommand,
  DescribeChannelModeratorResponseFilterSensitiveLog: () => DescribeChannelModeratorResponseFilterSensitiveLog,
  DescribeChannelResponseFilterSensitiveLog: () => DescribeChannelResponseFilterSensitiveLog,
  DisassociateChannelFlowCommand: () => DisassociateChannelFlowCommand,
  ErrorCode: () => ErrorCode,
  ExpirationCriterion: () => ExpirationCriterion,
  FallbackAction: () => FallbackAction,
  ForbiddenException: () => ForbiddenException,
  GetChannelMembershipPreferencesCommand: () => GetChannelMembershipPreferencesCommand,
  GetChannelMembershipPreferencesResponseFilterSensitiveLog: () => GetChannelMembershipPreferencesResponseFilterSensitiveLog,
  GetChannelMessageCommand: () => GetChannelMessageCommand,
  GetChannelMessageResponseFilterSensitiveLog: () => GetChannelMessageResponseFilterSensitiveLog,
  GetChannelMessageStatusCommand: () => GetChannelMessageStatusCommand,
  GetMessagingSessionEndpointCommand: () => GetMessagingSessionEndpointCommand,
  GetMessagingStreamingConfigurationsCommand: () => GetMessagingStreamingConfigurationsCommand,
  IdentityFilterSensitiveLog: () => IdentityFilterSensitiveLog,
  InvocationType: () => InvocationType,
  ListChannelBansCommand: () => ListChannelBansCommand,
  ListChannelBansRequestFilterSensitiveLog: () => ListChannelBansRequestFilterSensitiveLog,
  ListChannelBansResponseFilterSensitiveLog: () => ListChannelBansResponseFilterSensitiveLog,
  ListChannelFlowsCommand: () => ListChannelFlowsCommand,
  ListChannelFlowsRequestFilterSensitiveLog: () => ListChannelFlowsRequestFilterSensitiveLog,
  ListChannelFlowsResponseFilterSensitiveLog: () => ListChannelFlowsResponseFilterSensitiveLog,
  ListChannelMembershipsCommand: () => ListChannelMembershipsCommand,
  ListChannelMembershipsForAppInstanceUserCommand: () => ListChannelMembershipsForAppInstanceUserCommand,
  ListChannelMembershipsForAppInstanceUserRequestFilterSensitiveLog: () => ListChannelMembershipsForAppInstanceUserRequestFilterSensitiveLog,
  ListChannelMembershipsForAppInstanceUserResponseFilterSensitiveLog: () => ListChannelMembershipsForAppInstanceUserResponseFilterSensitiveLog,
  ListChannelMembershipsRequestFilterSensitiveLog: () => ListChannelMembershipsRequestFilterSensitiveLog,
  ListChannelMembershipsResponseFilterSensitiveLog: () => ListChannelMembershipsResponseFilterSensitiveLog,
  ListChannelMessagesCommand: () => ListChannelMessagesCommand,
  ListChannelMessagesRequestFilterSensitiveLog: () => ListChannelMessagesRequestFilterSensitiveLog,
  ListChannelMessagesResponseFilterSensitiveLog: () => ListChannelMessagesResponseFilterSensitiveLog,
  ListChannelModeratorsCommand: () => ListChannelModeratorsCommand,
  ListChannelModeratorsRequestFilterSensitiveLog: () => ListChannelModeratorsRequestFilterSensitiveLog,
  ListChannelModeratorsResponseFilterSensitiveLog: () => ListChannelModeratorsResponseFilterSensitiveLog,
  ListChannelsAssociatedWithChannelFlowCommand: () => ListChannelsAssociatedWithChannelFlowCommand,
  ListChannelsAssociatedWithChannelFlowRequestFilterSensitiveLog: () => ListChannelsAssociatedWithChannelFlowRequestFilterSensitiveLog,
  ListChannelsAssociatedWithChannelFlowResponseFilterSensitiveLog: () => ListChannelsAssociatedWithChannelFlowResponseFilterSensitiveLog,
  ListChannelsCommand: () => ListChannelsCommand,
  ListChannelsModeratedByAppInstanceUserCommand: () => ListChannelsModeratedByAppInstanceUserCommand,
  ListChannelsModeratedByAppInstanceUserRequestFilterSensitiveLog: () => ListChannelsModeratedByAppInstanceUserRequestFilterSensitiveLog,
  ListChannelsModeratedByAppInstanceUserResponseFilterSensitiveLog: () => ListChannelsModeratedByAppInstanceUserResponseFilterSensitiveLog,
  ListChannelsRequestFilterSensitiveLog: () => ListChannelsRequestFilterSensitiveLog,
  ListChannelsResponseFilterSensitiveLog: () => ListChannelsResponseFilterSensitiveLog,
  ListSubChannelsCommand: () => ListSubChannelsCommand,
  ListSubChannelsRequestFilterSensitiveLog: () => ListSubChannelsRequestFilterSensitiveLog,
  ListSubChannelsResponseFilterSensitiveLog: () => ListSubChannelsResponseFilterSensitiveLog,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ListTagsForResourceResponseFilterSensitiveLog: () => ListTagsForResourceResponseFilterSensitiveLog,
  MessageAttributeValueFilterSensitiveLog: () => MessageAttributeValueFilterSensitiveLog,
  MessagingDataType: () => MessagingDataType,
  NotFoundException: () => NotFoundException,
  ProcessorFilterSensitiveLog: () => ProcessorFilterSensitiveLog,
  PushNotificationConfigurationFilterSensitiveLog: () => PushNotificationConfigurationFilterSensitiveLog,
  PushNotificationPreferencesFilterSensitiveLog: () => PushNotificationPreferencesFilterSensitiveLog,
  PushNotificationType: () => PushNotificationType,
  PutChannelExpirationSettingsCommand: () => PutChannelExpirationSettingsCommand,
  PutChannelMembershipPreferencesCommand: () => PutChannelMembershipPreferencesCommand,
  PutChannelMembershipPreferencesRequestFilterSensitiveLog: () => PutChannelMembershipPreferencesRequestFilterSensitiveLog,
  PutChannelMembershipPreferencesResponseFilterSensitiveLog: () => PutChannelMembershipPreferencesResponseFilterSensitiveLog,
  PutMessagingStreamingConfigurationsCommand: () => PutMessagingStreamingConfigurationsCommand,
  RedactChannelMessageCommand: () => RedactChannelMessageCommand,
  ResourceLimitExceededException: () => ResourceLimitExceededException,
  SearchChannelsCommand: () => SearchChannelsCommand,
  SearchChannelsRequestFilterSensitiveLog: () => SearchChannelsRequestFilterSensitiveLog,
  SearchChannelsResponseFilterSensitiveLog: () => SearchChannelsResponseFilterSensitiveLog,
  SearchFieldKey: () => SearchFieldKey,
  SearchFieldOperator: () => SearchFieldOperator,
  SendChannelMessageCommand: () => SendChannelMessageCommand,
  SendChannelMessageRequestFilterSensitiveLog: () => SendChannelMessageRequestFilterSensitiveLog,
  ServiceFailureException: () => ServiceFailureException,
  ServiceUnavailableException: () => ServiceUnavailableException,
  SortOrder: () => SortOrder,
  TagFilterSensitiveLog: () => TagFilterSensitiveLog,
  TagResourceCommand: () => TagResourceCommand,
  TagResourceRequestFilterSensitiveLog: () => TagResourceRequestFilterSensitiveLog,
  ThrottledClientException: () => ThrottledClientException,
  UnauthorizedClientException: () => UnauthorizedClientException,
  UntagResourceCommand: () => UntagResourceCommand,
  UntagResourceRequestFilterSensitiveLog: () => UntagResourceRequestFilterSensitiveLog,
  UpdateChannelCommand: () => UpdateChannelCommand,
  UpdateChannelFlowCommand: () => UpdateChannelFlowCommand,
  UpdateChannelFlowRequestFilterSensitiveLog: () => UpdateChannelFlowRequestFilterSensitiveLog,
  UpdateChannelMessageCommand: () => UpdateChannelMessageCommand,
  UpdateChannelMessageRequestFilterSensitiveLog: () => UpdateChannelMessageRequestFilterSensitiveLog,
  UpdateChannelReadMarkerCommand: () => UpdateChannelReadMarkerCommand,
  UpdateChannelRequestFilterSensitiveLog: () => UpdateChannelRequestFilterSensitiveLog,
  __Client: () => import_smithy_client.Client,
  paginateListChannelBans: () => paginateListChannelBans,
  paginateListChannelFlows: () => paginateListChannelFlows,
  paginateListChannelMemberships: () => paginateListChannelMemberships,
  paginateListChannelMembershipsForAppInstanceUser: () => paginateListChannelMembershipsForAppInstanceUser,
  paginateListChannelMessages: () => paginateListChannelMessages,
  paginateListChannelModerators: () => paginateListChannelModerators,
  paginateListChannels: () => paginateListChannels,
  paginateListChannelsAssociatedWithChannelFlow: () => paginateListChannelsAssociatedWithChannelFlow,
  paginateListChannelsModeratedByAppInstanceUser: () => paginateListChannelsModeratedByAppInstanceUser,
  paginateListSubChannels: () => paginateListSubChannels,
  paginateSearchChannels: () => paginateSearchChannels
});
module.exports = __toCommonJS(src_exports);

// src/ChimeSDKMessagingClient.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/ChimeSDKMessagingClient.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/ChimeSDKMessagingClient.ts
var _ChimeSDKMessagingClient = class _ChimeSDKMessagingClient 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.defaultChimeSDKMessagingHttpAuthSchemeParametersProvider,
        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(_ChimeSDKMessagingClient, "ChimeSDKMessagingClient");
var ChimeSDKMessagingClient = _ChimeSDKMessagingClient;

// src/ChimeSDKMessaging.ts


// src/commands/AssociateChannelFlowCommand.ts

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


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


var import_uuid = require("uuid");

// src/models/ChimeSDKMessagingServiceException.ts

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

// src/models/models_0.ts

var AllowNotifications = {
  ALL: "ALL",
  FILTERED: "FILTERED",
  NONE: "NONE"
};
var ChannelMembershipType = {
  DEFAULT: "DEFAULT",
  HIDDEN: "HIDDEN"
};
var ErrorCode = {
  AccessDenied: "AccessDenied",
  BadRequest: "BadRequest",
  Conflict: "Conflict",
  Forbidden: "Forbidden",
  NotFound: "NotFound",
  PhoneNumberAssociationsExist: "PhoneNumberAssociationsExist",
  PreconditionFailed: "PreconditionFailed",
  ResourceLimitExceeded: "ResourceLimitExceeded",
  ServiceFailure: "ServiceFailure",
  ServiceUnavailable: "ServiceUnavailable",
  Throttled: "Throttled",
  Throttling: "Throttling",
  Unauthorized: "Unauthorized",
  Unprocessable: "Unprocessable",
  VoiceConnectorGroupAssociationsExist: "VoiceConnectorGroupAssociationsExist"
};
var _BadRequestException = class _BadRequestException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_BadRequestException, "BadRequestException");
var BadRequestException = _BadRequestException;
var _ConflictException = class _ConflictException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ConflictException, "ConflictException");
var ConflictException = _ConflictException;
var _ForbiddenException = class _ForbiddenException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ForbiddenException, "ForbiddenException");
var ForbiddenException = _ForbiddenException;
var _NotFoundException = class _NotFoundException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_NotFoundException, "NotFoundException");
var NotFoundException = _NotFoundException;
var _ServiceFailureException = class _ServiceFailureException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ServiceFailureException, "ServiceFailureException");
var ServiceFailureException = _ServiceFailureException;
var _ServiceUnavailableException = class _ServiceUnavailableException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ServiceUnavailableException, "ServiceUnavailableException");
var ServiceUnavailableException = _ServiceUnavailableException;
var _ThrottledClientException = class _ThrottledClientException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ThrottledClientException, "ThrottledClientException");
var ThrottledClientException = _ThrottledClientException;
var _UnauthorizedClientException = class _UnauthorizedClientException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_UnauthorizedClientException, "UnauthorizedClientException");
var UnauthorizedClientException = _UnauthorizedClientException;
var _ResourceLimitExceededException = class _ResourceLimitExceededException extends ChimeSDKMessagingServiceException {
  /**
   * @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;
  }
};
__name(_ResourceLimitExceededException, "ResourceLimitExceededException");
var ResourceLimitExceededException = _ResourceLimitExceededException;
var ExpirationCriterion = {
  CREATED_TIMESTAMP: "CREATED_TIMESTAMP",
  LAST_MESSAGE_TIMESTAMP: "LAST_MESSAGE_TIMESTAMP"
};
var ChannelMode = {
  RESTRICTED: "RESTRICTED",
  UNRESTRICTED: "UNRESTRICTED"
};
var ChannelPrivacy = {
  PRIVATE: "PRIVATE",
  PUBLIC: "PUBLIC"
};
var InvocationType = {
  ASYNC: "ASYNC"
};
var FallbackAction = {
  ABORT: "ABORT",
  CONTINUE: "CONTINUE"
};
var PushNotificationType = {
  DEFAULT: "DEFAULT",
  VOIP: "VOIP"
};
var ChannelMessagePersistenceType = {
  NON_PERSISTENT: "NON_PERSISTENT",
  PERSISTENT: "PERSISTENT"
};
var ChannelMessageStatus = {
  DENIED: "DENIED",
  FAILED: "FAILED",
  PENDING: "PENDING",
  SENT: "SENT"
};
var ChannelMessageType = {
  CONTROL: "CONTROL",
  STANDARD: "STANDARD"
};
var MessagingDataType = {
  Channel: "Channel",
  ChannelMessage: "ChannelMessage"
};
var SortOrder = {
  ASCENDING: "ASCENDING",
  DESCENDING: "DESCENDING"
};
var SearchFieldKey = {
  MEMBERS: "MEMBERS"
};
var SearchFieldOperator = {
  EQUALS: "EQUALS",
  INCLUDES: "INCLUDES"
};
var IdentityFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
}), "IdentityFilterSensitiveLog");
var BatchChannelMembershipsFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InvitedBy && { InvitedBy: IdentityFilterSensitiveLog(obj.InvitedBy) },
  ...obj.Members && { Members: obj.Members.map((item) => IdentityFilterSensitiveLog(item)) }
}), "BatchChannelMembershipsFilterSensitiveLog");
var BatchCreateChannelMembershipResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.BatchChannelMemberships && {
    BatchChannelMemberships: BatchChannelMembershipsFilterSensitiveLog(obj.BatchChannelMemberships)
  }
}), "BatchCreateChannelMembershipResponseFilterSensitiveLog");
var ChannelFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.CreatedBy && { CreatedBy: IdentityFilterSensitiveLog(obj.CreatedBy) }
}), "ChannelFilterSensitiveLog");
var ChannelAssociatedWithFlowSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING }
}), "ChannelAssociatedWithFlowSummaryFilterSensitiveLog");
var ChannelBanFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) },
  ...obj.CreatedBy && { CreatedBy: IdentityFilterSensitiveLog(obj.CreatedBy) }
}), "ChannelBanFilterSensitiveLog");
var ChannelBanSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) }
}), "ChannelBanSummaryFilterSensitiveLog");
var ProcessorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
}), "ProcessorFilterSensitiveLog");
var ChannelFlowFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Processors && { Processors: obj.Processors.map((item) => ProcessorFilterSensitiveLog(item)) },
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
}), "ChannelFlowFilterSensitiveLog");
var MessageAttributeValueFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.StringValues && { StringValues: import_smithy_client.SENSITIVE_STRING }
}), "MessageAttributeValueFilterSensitiveLog");
var PushNotificationConfigurationFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Title && { Title: import_smithy_client.SENSITIVE_STRING },
  ...obj.Body && { Body: import_smithy_client.SENSITIVE_STRING }
}), "PushNotificationConfigurationFilterSensitiveLog");
var ChannelMessageCallbackFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.PushNotification && {
    PushNotification: PushNotificationConfigurationFilterSensitiveLog(obj.PushNotification)
  },
  ...obj.MessageAttributes && {
    MessageAttributes: Object.entries(obj.MessageAttributes).reduce(
      (acc, [key, value]) => (acc[key] = MessageAttributeValueFilterSensitiveLog(value), acc),
      {}
    )
  },
  ...obj.ContentType && { ContentType: import_smithy_client.SENSITIVE_STRING }
}), "ChannelMessageCallbackFilterSensitiveLog");
var ChannelFlowCallbackRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMessage && { ChannelMessage: ChannelMessageCallbackFilterSensitiveLog(obj.ChannelMessage) }
}), "ChannelFlowCallbackRequestFilterSensitiveLog");
var ChannelFlowSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Processors && { Processors: obj.Processors.map((item) => ProcessorFilterSensitiveLog(item)) }
}), "ChannelFlowSummaryFilterSensitiveLog");
var ChannelMembershipFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.InvitedBy && { InvitedBy: IdentityFilterSensitiveLog(obj.InvitedBy) },
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) }
}), "ChannelMembershipFilterSensitiveLog");
var ChannelSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING }
}), "ChannelSummaryFilterSensitiveLog");
var ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelSummary && { ChannelSummary: ChannelSummaryFilterSensitiveLog(obj.ChannelSummary) }
}), "ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog");
var PushNotificationPreferencesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.FilterRule && { FilterRule: import_smithy_client.SENSITIVE_STRING }
}), "PushNotificationPreferencesFilterSensitiveLog");
var ChannelMembershipPreferencesFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.PushNotifications && {
    PushNotifications: PushNotificationPreferencesFilterSensitiveLog(obj.PushNotifications)
  }
}), "ChannelMembershipPreferencesFilterSensitiveLog");
var ChannelMembershipSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) }
}), "ChannelMembershipSummaryFilterSensitiveLog");
var ChannelMessageFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.Sender && { Sender: IdentityFilterSensitiveLog(obj.Sender) },
  ...obj.MessageAttributes && {
    MessageAttributes: Object.entries(obj.MessageAttributes).reduce(
      (acc, [key, value]) => (acc[key] = MessageAttributeValueFilterSensitiveLog(value), acc),
      {}
    )
  },
  ...obj.ContentType && { ContentType: import_smithy_client.SENSITIVE_STRING }
}), "ChannelMessageFilterSensitiveLog");
var ChannelMessageSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.Sender && { Sender: IdentityFilterSensitiveLog(obj.Sender) },
  ...obj.MessageAttributes && {
    MessageAttributes: Object.entries(obj.MessageAttributes).reduce(
      (acc, [key, value]) => (acc[key] = MessageAttributeValueFilterSensitiveLog(value), acc),
      {}
    )
  },
  ...obj.ContentType && { ContentType: import_smithy_client.SENSITIVE_STRING }
}), "ChannelMessageSummaryFilterSensitiveLog");
var ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelSummary && { ChannelSummary: ChannelSummaryFilterSensitiveLog(obj.ChannelSummary) }
}), "ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog");
var ChannelModeratorFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Moderator && { Moderator: IdentityFilterSensitiveLog(obj.Moderator) },
  ...obj.CreatedBy && { CreatedBy: IdentityFilterSensitiveLog(obj.CreatedBy) }
}), "ChannelModeratorFilterSensitiveLog");
var ChannelModeratorSummaryFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Moderator && { Moderator: IdentityFilterSensitiveLog(obj.Moderator) }
}), "ChannelModeratorSummaryFilterSensitiveLog");
var TagFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Key && { Key: import_smithy_client.SENSITIVE_STRING },
  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
}), "TagFilterSensitiveLog");
var CreateChannelRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) },
  ...obj.ChannelId && { ChannelId: import_smithy_client.SENSITIVE_STRING }
}), "CreateChannelRequestFilterSensitiveLog");
var CreateChannelBanResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) }
}), "CreateChannelBanResponseFilterSensitiveLog");
var CreateChannelFlowRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Processors && { Processors: obj.Processors.map((item) => ProcessorFilterSensitiveLog(item)) },
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING }
}), "CreateChannelFlowRequestFilterSensitiveLog");
var CreateChannelMembershipResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) }
}), "CreateChannelMembershipResponseFilterSensitiveLog");
var CreateChannelModeratorResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelModerator && { ChannelModerator: IdentityFilterSensitiveLog(obj.ChannelModerator) }
}), "CreateChannelModeratorResponseFilterSensitiveLog");
var DescribeChannelResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channel && { Channel: ChannelFilterSensitiveLog(obj.Channel) }
}), "DescribeChannelResponseFilterSensitiveLog");
var DescribeChannelBanResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelBan && { ChannelBan: ChannelBanFilterSensitiveLog(obj.ChannelBan) }
}), "DescribeChannelBanResponseFilterSensitiveLog");
var DescribeChannelFlowResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelFlow && { ChannelFlow: ChannelFlowFilterSensitiveLog(obj.ChannelFlow) }
}), "DescribeChannelFlowResponseFilterSensitiveLog");
var DescribeChannelMembershipResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMembership && { ChannelMembership: ChannelMembershipFilterSensitiveLog(obj.ChannelMembership) }
}), "DescribeChannelMembershipResponseFilterSensitiveLog");
var DescribeChannelMembershipForAppInstanceUserResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMembership && {
    ChannelMembership: ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog(obj.ChannelMembership)
  }
}), "DescribeChannelMembershipForAppInstanceUserResponseFilterSensitiveLog");
var DescribeChannelModeratedByAppInstanceUserResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channel && { Channel: ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog(obj.Channel) }
}), "DescribeChannelModeratedByAppInstanceUserResponseFilterSensitiveLog");
var DescribeChannelModeratorResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelModerator && { ChannelModerator: ChannelModeratorFilterSensitiveLog(obj.ChannelModerator) }
}), "DescribeChannelModeratorResponseFilterSensitiveLog");
var GetChannelMembershipPreferencesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) },
  ...obj.Preferences && { Preferences: ChannelMembershipPreferencesFilterSensitiveLog(obj.Preferences) }
}), "GetChannelMembershipPreferencesResponseFilterSensitiveLog");
var GetChannelMessageResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMessage && { ChannelMessage: ChannelMessageFilterSensitiveLog(obj.ChannelMessage) }
}), "GetChannelMessageResponseFilterSensitiveLog");
var ListChannelBansRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelBansRequestFilterSensitiveLog");
var ListChannelBansResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.ChannelBans && { ChannelBans: obj.ChannelBans.map((item) => ChannelBanSummaryFilterSensitiveLog(item)) }
}), "ListChannelBansResponseFilterSensitiveLog");
var ListChannelFlowsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelFlowsRequestFilterSensitiveLog");
var ListChannelFlowsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelFlows && { ChannelFlows: obj.ChannelFlows.map((item) => ChannelFlowSummaryFilterSensitiveLog(item)) },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelFlowsResponseFilterSensitiveLog");
var ListChannelMembershipsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelMembershipsRequestFilterSensitiveLog");
var ListChannelMembershipsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMemberships && {
    ChannelMemberships: obj.ChannelMemberships.map((item) => ChannelMembershipSummaryFilterSensitiveLog(item))
  },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelMembershipsResponseFilterSensitiveLog");
var ListChannelMembershipsForAppInstanceUserRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelMembershipsForAppInstanceUserRequestFilterSensitiveLog");
var ListChannelMembershipsForAppInstanceUserResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ChannelMemberships && {
    ChannelMemberships: obj.ChannelMemberships.map(
      (item) => ChannelMembershipForAppInstanceUserSummaryFilterSensitiveLog(item)
    )
  },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelMembershipsForAppInstanceUserResponseFilterSensitiveLog");
var ListChannelMessagesRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelMessagesRequestFilterSensitiveLog");
var ListChannelMessagesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.ChannelMessages && {
    ChannelMessages: obj.ChannelMessages.map((item) => ChannelMessageSummaryFilterSensitiveLog(item))
  }
}), "ListChannelMessagesResponseFilterSensitiveLog");
var ListChannelModeratorsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelModeratorsRequestFilterSensitiveLog");
var ListChannelModeratorsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.ChannelModerators && {
    ChannelModerators: obj.ChannelModerators.map((item) => ChannelModeratorSummaryFilterSensitiveLog(item))
  }
}), "ListChannelModeratorsResponseFilterSensitiveLog");
var ListChannelsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsRequestFilterSensitiveLog");
var ListChannelsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channels && { Channels: obj.Channels.map((item) => ChannelSummaryFilterSensitiveLog(item)) },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsResponseFilterSensitiveLog");
var ListChannelsAssociatedWithChannelFlowRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsAssociatedWithChannelFlowRequestFilterSensitiveLog");
var ListChannelsAssociatedWithChannelFlowResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channels && {
    Channels: obj.Channels.map((item) => ChannelAssociatedWithFlowSummaryFilterSensitiveLog(item))
  },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsAssociatedWithChannelFlowResponseFilterSensitiveLog");
var ListChannelsModeratedByAppInstanceUserRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsModeratedByAppInstanceUserRequestFilterSensitiveLog");
var ListChannelsModeratedByAppInstanceUserResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channels && {
    Channels: obj.Channels.map((item) => ChannelModeratedByAppInstanceUserSummaryFilterSensitiveLog(item))
  },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListChannelsModeratedByAppInstanceUserResponseFilterSensitiveLog");
var ListSubChannelsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListSubChannelsRequestFilterSensitiveLog");
var ListSubChannelsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "ListSubChannelsResponseFilterSensitiveLog");
var ListTagsForResourceResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }
}), "ListTagsForResourceResponseFilterSensitiveLog");
var PutChannelMembershipPreferencesRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Preferences && { Preferences: ChannelMembershipPreferencesFilterSensitiveLog(obj.Preferences) }
}), "PutChannelMembershipPreferencesRequestFilterSensitiveLog");
var PutChannelMembershipPreferencesResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Member && { Member: IdentityFilterSensitiveLog(obj.Member) },
  ...obj.Preferences && { Preferences: ChannelMembershipPreferencesFilterSensitiveLog(obj.Preferences) }
}), "PutChannelMembershipPreferencesResponseFilterSensitiveLog");
var SearchChannelsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "SearchChannelsRequestFilterSensitiveLog");
var SearchChannelsResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Channels && { Channels: obj.Channels.map((item) => ChannelSummaryFilterSensitiveLog(item)) },
  ...obj.NextToken && { NextToken: import_smithy_client.SENSITIVE_STRING }
}), "SearchChannelsResponseFilterSensitiveLog");
var SendChannelMessageRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.ClientRequestToken && { ClientRequestToken: import_smithy_client.SENSITIVE_STRING },
  ...obj.PushNotification && {
    PushNotification: PushNotificationConfigurationFilterSensitiveLog(obj.PushNotification)
  },
  ...obj.MessageAttributes && {
    MessageAttributes: Object.entries(obj.MessageAttributes).reduce(
      (acc, [key, value]) => (acc[key] = MessageAttributeValueFilterSensitiveLog(value), acc),
      {}
    )
  },
  ...obj.ContentType && { ContentType: import_smithy_client.SENSITIVE_STRING }
}), "SendChannelMessageRequestFilterSensitiveLog");
var TagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Tags && { Tags: obj.Tags.map((item) => TagFilterSensitiveLog(item)) }
}), "TagResourceRequestFilterSensitiveLog");
var UntagResourceRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.TagKeys && { TagKeys: import_smithy_client.SENSITIVE_STRING }
}), "UntagResourceRequestFilterSensitiveLog");
var UpdateChannelRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING }
}), "UpdateChannelRequestFilterSensitiveLog");
var UpdateChannelFlowRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Processors && { Processors: obj.Processors.map((item) => ProcessorFilterSensitiveLog(item)) },
  ...obj.Name && { Name: import_smithy_client.SENSITIVE_STRING }
}), "UpdateChannelFlowRequestFilterSensitiveLog");
var UpdateChannelMessageRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Content && { Content: import_smithy_client.SENSITIVE_STRING },
  ...obj.Metadata && { Metadata: import_smithy_client.SENSITIVE_STRING },
  ...obj.ContentType && { Con