serverless-spy/node_modules/@aws-sdk/client-eventbridge/dist-cjs/index.js

CDK-based library for writing elegant integration tests on AWS serverless architecture and an additional web console to monitor events in real time.

"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, {
  AccessDeniedException: () => AccessDeniedException,
  ActivateEventSourceCommand: () => ActivateEventSourceCommand,
  ApiDestinationHttpMethod: () => ApiDestinationHttpMethod,
  ApiDestinationState: () => ApiDestinationState,
  AppSyncParametersFilterSensitiveLog: () => AppSyncParametersFilterSensitiveLog,
  ArchiveState: () => ArchiveState,
  AssignPublicIp: () => AssignPublicIp,
  CancelReplayCommand: () => CancelReplayCommand,
  ConcurrentModificationException: () => ConcurrentModificationException,
  ConnectionAuthResponseParametersFilterSensitiveLog: () => ConnectionAuthResponseParametersFilterSensitiveLog,
  ConnectionAuthorizationType: () => ConnectionAuthorizationType,
  ConnectionBodyParameterFilterSensitiveLog: () => ConnectionBodyParameterFilterSensitiveLog,
  ConnectionHeaderParameterFilterSensitiveLog: () => ConnectionHeaderParameterFilterSensitiveLog,
  ConnectionHttpParametersFilterSensitiveLog: () => ConnectionHttpParametersFilterSensitiveLog,
  ConnectionOAuthHttpMethod: () => ConnectionOAuthHttpMethod,
  ConnectionOAuthResponseParametersFilterSensitiveLog: () => ConnectionOAuthResponseParametersFilterSensitiveLog,
  ConnectionQueryStringParameterFilterSensitiveLog: () => ConnectionQueryStringParameterFilterSensitiveLog,
  ConnectionState: () => ConnectionState,
  CreateApiDestinationCommand: () => CreateApiDestinationCommand,
  CreateArchiveCommand: () => CreateArchiveCommand,
  CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog: () => CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog,
  CreateConnectionAuthRequestParametersFilterSensitiveLog: () => CreateConnectionAuthRequestParametersFilterSensitiveLog,
  CreateConnectionBasicAuthRequestParametersFilterSensitiveLog: () => CreateConnectionBasicAuthRequestParametersFilterSensitiveLog,
  CreateConnectionCommand: () => CreateConnectionCommand,
  CreateConnectionOAuthClientRequestParametersFilterSensitiveLog: () => CreateConnectionOAuthClientRequestParametersFilterSensitiveLog,
  CreateConnectionOAuthRequestParametersFilterSensitiveLog: () => CreateConnectionOAuthRequestParametersFilterSensitiveLog,
  CreateConnectionRequestFilterSensitiveLog: () => CreateConnectionRequestFilterSensitiveLog,
  CreateEndpointCommand: () => CreateEndpointCommand,
  CreateEventBusCommand: () => CreateEventBusCommand,
  CreatePartnerEventSourceCommand: () => CreatePartnerEventSourceCommand,
  DeactivateEventSourceCommand: () => DeactivateEventSourceCommand,
  DeauthorizeConnectionCommand: () => DeauthorizeConnectionCommand,
  DeleteApiDestinationCommand: () => DeleteApiDestinationCommand,
  DeleteArchiveCommand: () => DeleteArchiveCommand,
  DeleteConnectionCommand: () => DeleteConnectionCommand,
  DeleteEndpointCommand: () => DeleteEndpointCommand,
  DeleteEventBusCommand: () => DeleteEventBusCommand,
  DeletePartnerEventSourceCommand: () => DeletePartnerEventSourceCommand,
  DeleteRuleCommand: () => DeleteRuleCommand,
  DescribeApiDestinationCommand: () => DescribeApiDestinationCommand,
  DescribeArchiveCommand: () => DescribeArchiveCommand,
  DescribeConnectionCommand: () => DescribeConnectionCommand,
  DescribeConnectionResponseFilterSensitiveLog: () => DescribeConnectionResponseFilterSensitiveLog,
  DescribeEndpointCommand: () => DescribeEndpointCommand,
  DescribeEventBusCommand: () => DescribeEventBusCommand,
  DescribeEventSourceCommand: () => DescribeEventSourceCommand,
  DescribePartnerEventSourceCommand: () => DescribePartnerEventSourceCommand,
  DescribeReplayCommand: () => DescribeReplayCommand,
  DescribeRuleCommand: () => DescribeRuleCommand,
  DisableRuleCommand: () => DisableRuleCommand,
  EnableRuleCommand: () => EnableRuleCommand,
  EndpointState: () => EndpointState,
  EventBridge: () => EventBridge,
  EventBridgeClient: () => EventBridgeClient,
  EventBridgeServiceException: () => EventBridgeServiceException,
  EventSourceState: () => EventSourceState,
  IllegalStatusException: () => IllegalStatusException,
  InternalException: () => InternalException,
  InvalidEventPatternException: () => InvalidEventPatternException,
  InvalidStateException: () => InvalidStateException,
  LaunchType: () => LaunchType,
  LimitExceededException: () => LimitExceededException,
  ListApiDestinationsCommand: () => ListApiDestinationsCommand,
  ListArchivesCommand: () => ListArchivesCommand,
  ListConnectionsCommand: () => ListConnectionsCommand,
  ListEndpointsCommand: () => ListEndpointsCommand,
  ListEventBusesCommand: () => ListEventBusesCommand,
  ListEventSourcesCommand: () => ListEventSourcesCommand,
  ListPartnerEventSourceAccountsCommand: () => ListPartnerEventSourceAccountsCommand,
  ListPartnerEventSourcesCommand: () => ListPartnerEventSourcesCommand,
  ListReplaysCommand: () => ListReplaysCommand,
  ListRuleNamesByTargetCommand: () => ListRuleNamesByTargetCommand,
  ListRulesCommand: () => ListRulesCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ListTargetsByRuleCommand: () => ListTargetsByRuleCommand,
  ListTargetsByRuleResponseFilterSensitiveLog: () => ListTargetsByRuleResponseFilterSensitiveLog,
  ManagedRuleException: () => ManagedRuleException,
  OperationDisabledException: () => OperationDisabledException,
  PlacementConstraintType: () => PlacementConstraintType,
  PlacementStrategyType: () => PlacementStrategyType,
  PolicyLengthExceededException: () => PolicyLengthExceededException,
  PropagateTags: () => PropagateTags,
  PutEventsCommand: () => PutEventsCommand,
  PutPartnerEventsCommand: () => PutPartnerEventsCommand,
  PutPermissionCommand: () => PutPermissionCommand,
  PutRuleCommand: () => PutRuleCommand,
  PutTargetsCommand: () => PutTargetsCommand,
  PutTargetsRequestFilterSensitiveLog: () => PutTargetsRequestFilterSensitiveLog,
  RedshiftDataParametersFilterSensitiveLog: () => RedshiftDataParametersFilterSensitiveLog,
  RemovePermissionCommand: () => RemovePermissionCommand,
  RemoveTargetsCommand: () => RemoveTargetsCommand,
  ReplayState: () => ReplayState,
  ReplicationState: () => ReplicationState,
  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
  ResourceNotFoundException: () => ResourceNotFoundException,
  RuleState: () => RuleState,
  StartReplayCommand: () => StartReplayCommand,
  TagResourceCommand: () => TagResourceCommand,
  TargetFilterSensitiveLog: () => TargetFilterSensitiveLog,
  TestEventPatternCommand: () => TestEventPatternCommand,
  ThrottlingException: () => ThrottlingException,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateApiDestinationCommand: () => UpdateApiDestinationCommand,
  UpdateArchiveCommand: () => UpdateArchiveCommand,
  UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog,
  UpdateConnectionAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionAuthRequestParametersFilterSensitiveLog,
  UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog,
  UpdateConnectionCommand: () => UpdateConnectionCommand,
  UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog: () => UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog,
  UpdateConnectionOAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionOAuthRequestParametersFilterSensitiveLog,
  UpdateConnectionRequestFilterSensitiveLog: () => UpdateConnectionRequestFilterSensitiveLog,
  UpdateEndpointCommand: () => UpdateEndpointCommand,
  UpdateEventBusCommand: () => UpdateEventBusCommand,
  __Client: () => import_smithy_client.Client
});
module.exports = __toCommonJS(src_exports);

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

// src/EventBridgeClient.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/EventBridgeClient.ts
var _EventBridgeClient = class _EventBridgeClient 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.defaultEventBridgeHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials,
          "aws.auth#sigv4a": 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(_EventBridgeClient, "EventBridgeClient");
var EventBridgeClient = _EventBridgeClient;

// src/EventBridge.ts


// src/commands/ActivateEventSourceCommand.ts

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


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



// src/models/EventBridgeServiceException.ts

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

// src/models/models_0.ts

var _AccessDeniedException = class _AccessDeniedException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AccessDeniedException",
      $fault: "client",
      ...opts
    });
    this.name = "AccessDeniedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
  }
};
__name(_AccessDeniedException, "AccessDeniedException");
var AccessDeniedException = _AccessDeniedException;
var _ConcurrentModificationException = class _ConcurrentModificationException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConcurrentModificationException",
      $fault: "client",
      ...opts
    });
    this.name = "ConcurrentModificationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
  }
};
__name(_ConcurrentModificationException, "ConcurrentModificationException");
var ConcurrentModificationException = _ConcurrentModificationException;
var _InternalException = class _InternalException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InternalException",
      $fault: "server",
      ...opts
    });
    this.name = "InternalException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _InternalException.prototype);
  }
};
__name(_InternalException, "InternalException");
var InternalException = _InternalException;
var _InvalidStateException = class _InvalidStateException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidStateException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidStateException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidStateException.prototype);
  }
};
__name(_InvalidStateException, "InvalidStateException");
var InvalidStateException = _InvalidStateException;
var _OperationDisabledException = class _OperationDisabledException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationDisabledException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationDisabledException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationDisabledException.prototype);
  }
};
__name(_OperationDisabledException, "OperationDisabledException");
var OperationDisabledException = _OperationDisabledException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var ApiDestinationState = {
  ACTIVE: "ACTIVE",
  INACTIVE: "INACTIVE"
};
var ApiDestinationHttpMethod = {
  DELETE: "DELETE",
  GET: "GET",
  HEAD: "HEAD",
  OPTIONS: "OPTIONS",
  PATCH: "PATCH",
  POST: "POST",
  PUT: "PUT"
};
var ArchiveState = {
  CREATE_FAILED: "CREATE_FAILED",
  CREATING: "CREATING",
  DISABLED: "DISABLED",
  ENABLED: "ENABLED",
  UPDATE_FAILED: "UPDATE_FAILED",
  UPDATING: "UPDATING"
};
var AssignPublicIp = {
  DISABLED: "DISABLED",
  ENABLED: "ENABLED"
};
var ReplayState = {
  CANCELLED: "CANCELLED",
  CANCELLING: "CANCELLING",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  RUNNING: "RUNNING",
  STARTING: "STARTING"
};
var _IllegalStatusException = class _IllegalStatusException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "IllegalStatusException",
      $fault: "client",
      ...opts
    });
    this.name = "IllegalStatusException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _IllegalStatusException.prototype);
  }
};
__name(_IllegalStatusException, "IllegalStatusException");
var IllegalStatusException = _IllegalStatusException;
var _LimitExceededException = class _LimitExceededException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
  }
};
__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
var _InvalidEventPatternException = class _InvalidEventPatternException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidEventPatternException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidEventPatternException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidEventPatternException.prototype);
  }
};
__name(_InvalidEventPatternException, "InvalidEventPatternException");
var InvalidEventPatternException = _InvalidEventPatternException;
var ConnectionAuthorizationType = {
  API_KEY: "API_KEY",
  BASIC: "BASIC",
  OAUTH_CLIENT_CREDENTIALS: "OAUTH_CLIENT_CREDENTIALS"
};
var ConnectionOAuthHttpMethod = {
  GET: "GET",
  POST: "POST",
  PUT: "PUT"
};
var ConnectionState = {
  ACTIVE: "ACTIVE",
  AUTHORIZED: "AUTHORIZED",
  AUTHORIZING: "AUTHORIZING",
  CREATING: "CREATING",
  DEAUTHORIZED: "DEAUTHORIZED",
  DEAUTHORIZING: "DEAUTHORIZING",
  DELETING: "DELETING",
  FAILED_CONNECTIVITY: "FAILED_CONNECTIVITY",
  UPDATING: "UPDATING"
};
var _ThrottlingException = class _ThrottlingException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ThrottlingException",
      $fault: "client",
      ...opts
    });
    this.name = "ThrottlingException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ThrottlingException.prototype);
  }
};
__name(_ThrottlingException, "ThrottlingException");
var ThrottlingException = _ThrottlingException;
var ReplicationState = {
  DISABLED: "DISABLED",
  ENABLED: "ENABLED"
};
var EndpointState = {
  ACTIVE: "ACTIVE",
  CREATE_FAILED: "CREATE_FAILED",
  CREATING: "CREATING",
  DELETE_FAILED: "DELETE_FAILED",
  DELETING: "DELETING",
  UPDATE_FAILED: "UPDATE_FAILED",
  UPDATING: "UPDATING"
};
var _ManagedRuleException = class _ManagedRuleException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ManagedRuleException",
      $fault: "client",
      ...opts
    });
    this.name = "ManagedRuleException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ManagedRuleException.prototype);
  }
};
__name(_ManagedRuleException, "ManagedRuleException");
var ManagedRuleException = _ManagedRuleException;
var EventSourceState = {
  ACTIVE: "ACTIVE",
  DELETED: "DELETED",
  PENDING: "PENDING"
};
var RuleState = {
  DISABLED: "DISABLED",
  ENABLED: "ENABLED",
  ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS: "ENABLED_WITH_ALL_CLOUDTRAIL_MANAGEMENT_EVENTS"
};
var LaunchType = {
  EC2: "EC2",
  EXTERNAL: "EXTERNAL",
  FARGATE: "FARGATE"
};
var PlacementConstraintType = {
  DISTINCT_INSTANCE: "distinctInstance",
  MEMBER_OF: "memberOf"
};
var PlacementStrategyType = {
  BINPACK: "binpack",
  RANDOM: "random",
  SPREAD: "spread"
};
var PropagateTags = {
  TASK_DEFINITION: "TASK_DEFINITION"
};
var _PolicyLengthExceededException = class _PolicyLengthExceededException extends EventBridgeServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "PolicyLengthExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "PolicyLengthExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _PolicyLengthExceededException.prototype);
  }
};
__name(_PolicyLengthExceededException, "PolicyLengthExceededException");
var PolicyLengthExceededException = _PolicyLengthExceededException;
var AppSyncParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.GraphQLOperation && { GraphQLOperation: import_smithy_client.SENSITIVE_STRING }
}), "AppSyncParametersFilterSensitiveLog");
var CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ApiKeyValue && { ApiKeyValue: import_smithy_client.SENSITIVE_STRING }
}), "CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog");
var CreateConnectionBasicAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
}), "CreateConnectionBasicAuthRequestParametersFilterSensitiveLog");
var ConnectionBodyParameterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
}), "ConnectionBodyParameterFilterSensitiveLog");
var ConnectionHeaderParameterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
}), "ConnectionHeaderParameterFilterSensitiveLog");
var ConnectionQueryStringParameterFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Value && { Value: import_smithy_client.SENSITIVE_STRING }
}), "ConnectionQueryStringParameterFilterSensitiveLog");
var ConnectionHttpParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.HeaderParameters && {
    HeaderParameters: obj.HeaderParameters.map((item) => ConnectionHeaderParameterFilterSensitiveLog(item))
  },
  ...obj.QueryStringParameters && {
    QueryStringParameters: obj.QueryStringParameters.map(
      (item) => ConnectionQueryStringParameterFilterSensitiveLog(item)
    )
  },
  ...obj.BodyParameters && {
    BodyParameters: obj.BodyParameters.map((item) => ConnectionBodyParameterFilterSensitiveLog(item))
  }
}), "ConnectionHttpParametersFilterSensitiveLog");
var CreateConnectionOAuthClientRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ClientSecret && { ClientSecret: import_smithy_client.SENSITIVE_STRING }
}), "CreateConnectionOAuthClientRequestParametersFilterSensitiveLog");
var CreateConnectionOAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ClientParameters && {
    ClientParameters: CreateConnectionOAuthClientRequestParametersFilterSensitiveLog(obj.ClientParameters)
  },
  ...obj.OAuthHttpParameters && {
    OAuthHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.OAuthHttpParameters)
  }
}), "CreateConnectionOAuthRequestParametersFilterSensitiveLog");
var CreateConnectionAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.BasicAuthParameters && {
    BasicAuthParameters: CreateConnectionBasicAuthRequestParametersFilterSensitiveLog(obj.BasicAuthParameters)
  },
  ...obj.OAuthParameters && {
    OAuthParameters: CreateConnectionOAuthRequestParametersFilterSensitiveLog(obj.OAuthParameters)
  },
  ...obj.ApiKeyAuthParameters && {
    ApiKeyAuthParameters: CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog(obj.ApiKeyAuthParameters)
  },
  ...obj.InvocationHttpParameters && {
    InvocationHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.InvocationHttpParameters)
  }
}), "CreateConnectionAuthRequestParametersFilterSensitiveLog");
var CreateConnectionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AuthParameters && {
    AuthParameters: CreateConnectionAuthRequestParametersFilterSensitiveLog(obj.AuthParameters)
  }
}), "CreateConnectionRequestFilterSensitiveLog");
var ConnectionOAuthResponseParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.OAuthHttpParameters && {
    OAuthHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.OAuthHttpParameters)
  }
}), "ConnectionOAuthResponseParametersFilterSensitiveLog");
var ConnectionAuthResponseParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.OAuthParameters && {
    OAuthParameters: ConnectionOAuthResponseParametersFilterSensitiveLog(obj.OAuthParameters)
  },
  ...obj.InvocationHttpParameters && {
    InvocationHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.InvocationHttpParameters)
  }
}), "ConnectionAuthResponseParametersFilterSensitiveLog");
var DescribeConnectionResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AuthParameters && { AuthParameters: ConnectionAuthResponseParametersFilterSensitiveLog(obj.AuthParameters) }
}), "DescribeConnectionResponseFilterSensitiveLog");
var RedshiftDataParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Sql && { Sql: import_smithy_client.SENSITIVE_STRING },
  ...obj.Sqls && { Sqls: import_smithy_client.SENSITIVE_STRING }
}), "RedshiftDataParametersFilterSensitiveLog");
var TargetFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.RedshiftDataParameters && {
    RedshiftDataParameters: RedshiftDataParametersFilterSensitiveLog(obj.RedshiftDataParameters)
  },
  ...obj.AppSyncParameters && { AppSyncParameters: AppSyncParametersFilterSensitiveLog(obj.AppSyncParameters) }
}), "TargetFilterSensitiveLog");
var ListTargetsByRuleResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Targets && { Targets: obj.Targets.map((item) => TargetFilterSensitiveLog(item)) }
}), "ListTargetsByRuleResponseFilterSensitiveLog");
var PutTargetsRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Targets && { Targets: obj.Targets.map((item) => TargetFilterSensitiveLog(item)) }
}), "PutTargetsRequestFilterSensitiveLog");
var UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ApiKeyValue && { ApiKeyValue: import_smithy_client.SENSITIVE_STRING }
}), "UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog");
var UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.Password && { Password: import_smithy_client.SENSITIVE_STRING }
}), "UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog");
var UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ClientSecret && { ClientSecret: import_smithy_client.SENSITIVE_STRING }
}), "UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog");
var UpdateConnectionOAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.ClientParameters && {
    ClientParameters: UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog(obj.ClientParameters)
  },
  ...obj.OAuthHttpParameters && {
    OAuthHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.OAuthHttpParameters)
  }
}), "UpdateConnectionOAuthRequestParametersFilterSensitiveLog");
var UpdateConnectionAuthRequestParametersFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.BasicAuthParameters && {
    BasicAuthParameters: UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog(obj.BasicAuthParameters)
  },
  ...obj.OAuthParameters && {
    OAuthParameters: UpdateConnectionOAuthRequestParametersFilterSensitiveLog(obj.OAuthParameters)
  },
  ...obj.ApiKeyAuthParameters && {
    ApiKeyAuthParameters: UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog(obj.ApiKeyAuthParameters)
  },
  ...obj.InvocationHttpParameters && {
    InvocationHttpParameters: ConnectionHttpParametersFilterSensitiveLog(obj.InvocationHttpParameters)
  }
}), "UpdateConnectionAuthRequestParametersFilterSensitiveLog");
var UpdateConnectionRequestFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.AuthParameters && {
    AuthParameters: UpdateConnectionAuthRequestParametersFilterSensitiveLog(obj.AuthParameters)
  }
}), "UpdateConnectionRequestFilterSensitiveLog");

// src/protocols/Aws_json1_1.ts
var se_ActivateEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ActivateEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ActivateEventSourceCommand");
var se_CancelReplayCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CancelReplay");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CancelReplayCommand");
var se_CreateApiDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateApiDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateApiDestinationCommand");
var se_CreateArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateArchive");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateArchiveCommand");
var se_CreateConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateConnection");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateConnectionCommand");
var se_CreateEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateEndpoint");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateEndpointCommand");
var se_CreateEventBusCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateEventBus");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateEventBusCommand");
var se_CreatePartnerEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreatePartnerEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreatePartnerEventSourceCommand");
var se_DeactivateEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeactivateEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeactivateEventSourceCommand");
var se_DeauthorizeConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeauthorizeConnection");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeauthorizeConnectionCommand");
var se_DeleteApiDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteApiDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteApiDestinationCommand");
var se_DeleteArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteArchive");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteArchiveCommand");
var se_DeleteConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteConnection");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteConnectionCommand");
var se_DeleteEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteEndpoint");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteEndpointCommand");
var se_DeleteEventBusCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteEventBus");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteEventBusCommand");
var se_DeletePartnerEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeletePartnerEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeletePartnerEventSourceCommand");
var se_DeleteRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteRuleCommand");
var se_DescribeApiDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeApiDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeApiDestinationCommand");
var se_DescribeArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeArchive");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeArchiveCommand");
var se_DescribeConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeConnection");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeConnectionCommand");
var se_DescribeEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeEndpoint");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeEndpointCommand");
var se_DescribeEventBusCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeEventBus");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeEventBusCommand");
var se_DescribeEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeEventSourceCommand");
var se_DescribePartnerEventSourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribePartnerEventSource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribePartnerEventSourceCommand");
var se_DescribeReplayCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeReplay");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeReplayCommand");
var se_DescribeRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeRuleCommand");
var se_DisableRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DisableRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DisableRuleCommand");
var se_EnableRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("EnableRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_EnableRuleCommand");
var se_ListApiDestinationsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListApiDestinations");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListApiDestinationsCommand");
var se_ListArchivesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListArchives");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListArchivesCommand");
var se_ListConnectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListConnections");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListConnectionsCommand");
var se_ListEndpointsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListEndpoints");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListEndpointsCommand");
var se_ListEventBusesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListEventBuses");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListEventBusesCommand");
var se_ListEventSourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListEventSources");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListEventSourcesCommand");
var se_ListPartnerEventSourceAccountsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListPartnerEventSourceAccounts");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListPartnerEventSourceAccountsCommand");
var se_ListPartnerEventSourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListPartnerEventSources");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListPartnerEventSourcesCommand");
var se_ListReplaysCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListReplays");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListReplaysCommand");
var se_ListRuleNamesByTargetCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListRuleNamesByTarget");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListRuleNamesByTargetCommand");
var se_ListRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListRules");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListRulesCommand");
var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTagsForResource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTagsForResourceCommand");
var se_ListTargetsByRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTargetsByRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTargetsByRuleCommand");
var se_PutEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutEvents");
  let body;
  body = JSON.stringify(se_PutEventsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutEventsCommand");
var se_PutPartnerEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutPartnerEvents");
  let body;
  body = JSON.stringify(se_PutPartnerEventsRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutPartnerEventsCommand");
var se_PutPermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutPermission");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutPermissionCommand");
var se_PutRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutRule");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutRuleCommand");
var se_PutTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutTargets");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutTargetsCommand");
var se_RemovePermissionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RemovePermission");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RemovePermissionCommand");
var se_RemoveTargetsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("RemoveTargets");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_RemoveTargetsCommand");
var se_StartReplayCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("StartReplay");
  let body;
  body = JSON.stringify(se_StartReplayRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_StartReplayCommand");
var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("TagResource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_TagResourceCommand");
var se_TestEventPatternCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("TestEventPattern");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_TestEventPatternCommand");
var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UntagResource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UntagResourceCommand");
var se_UpdateApiDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UpdateApiDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UpdateApiDestinationCommand");
var se_UpdateArchiveCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UpdateArchive");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UpdateArchiveCommand");
var se_UpdateConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UpdateConnection");
  let body;
  body = JSON.stringify((0, imp