"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, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UpdateConnectionCommand");
var se_UpdateEndpointCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UpdateEndpoint");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UpdateEndpointCommand");
var se_UpdateEventBusCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("UpdateEventBus");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UpdateEventBusCommand");
var de_ActivateEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_ActivateEventSourceCommand");
var de_CancelReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CancelReplayCommand");
var de_CreateApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_CreateApiDestinationResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateApiDestinationCommand");
var de_CreateArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_CreateArchiveResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateArchiveCommand");
var de_CreateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_CreateConnectionResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateConnectionCommand");
var de_CreateEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateEndpointCommand");
var de_CreateEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreateEventBusCommand");
var de_CreatePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_CreatePartnerEventSourceCommand");
var de_DeactivateEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeactivateEventSourceCommand");
var de_DeauthorizeConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DeauthorizeConnectionResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeauthorizeConnectionCommand");
var de_DeleteApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteApiDestinationCommand");
var de_DeleteArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteArchiveCommand");
var de_DeleteConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DeleteConnectionResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteConnectionCommand");
var de_DeleteEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteEndpointCommand");
var de_DeleteEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteEventBusCommand");
var de_DeletePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeletePartnerEventSourceCommand");
var de_DeleteRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteRuleCommand");
var de_DescribeApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeApiDestinationResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeApiDestinationCommand");
var de_DescribeArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeArchiveResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeArchiveCommand");
var de_DescribeConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeConnectionResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeConnectionCommand");
var de_DescribeEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeEndpointResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeEndpointCommand");
var de_DescribeEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeEventBusResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeEventBusCommand");
var de_DescribeEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeEventSourceResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeEventSourceCommand");
var de_DescribePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribePartnerEventSourceCommand");
var de_DescribeReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_DescribeReplayResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeReplayCommand");
var de_DescribeRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeRuleCommand");
var de_DisableRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DisableRuleCommand");
var de_EnableRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_EnableRuleCommand");
var de_ListApiDestinationsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListApiDestinationsResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListApiDestinationsCommand");
var de_ListArchivesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListArchivesResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListArchivesCommand");
var de_ListConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListConnectionsResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListConnectionsCommand");
var de_ListEndpointsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListEndpointsResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListEndpointsCommand");
var de_ListEventBusesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListEventBusesResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListEventBusesCommand");
var de_ListEventSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListEventSourcesResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListEventSourcesCommand");
var de_ListPartnerEventSourceAccountsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListPartnerEventSourceAccountsResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListPartnerEventSourceAccountsCommand");
var de_ListPartnerEventSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListPartnerEventSourcesCommand");
var de_ListReplaysCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_ListReplaysResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListReplaysCommand");
var de_ListRuleNamesByTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListRuleNamesByTargetCommand");
var de_ListRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListRulesCommand");
var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListTagsForResourceCommand");
var de_ListTargetsByRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListTargetsByRuleCommand");
var de_PutEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutEventsCommand");
var de_PutPartnerEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutPartnerEventsCommand");
var de_PutPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PutPermissionCommand");
var de_PutRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutRuleCommand");
var de_PutTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutTargetsCommand");
var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_RemovePermissionCommand");
var de_RemoveTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_RemoveTargetsCommand");
var de_StartReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_StartReplayResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_StartReplayCommand");
var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_TagResourceCommand");
var de_TestEventPatternCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_TestEventPatternCommand");
var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UntagResourceCommand");
var de_UpdateApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_UpdateApiDestinationResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UpdateApiDestinationCommand");
var de_UpdateArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_UpdateArchiveResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UpdateArchiveCommand");
var de_UpdateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = de_UpdateConnectionResponse(data, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UpdateConnectionCommand");
var de_UpdateEndpointCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UpdateEndpointCommand");
var de_UpdateEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await (0, import_core2.parseJsonBody)(output.body, context);
  let contents = {};
  contents = (0, import_smithy_client._json)(data);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UpdateEventBusCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
  };
  const errorCode = (0, import_core2.loadRestJsonErrorCode)(output, parsedOutput.body);
  switch (errorCode) {
    case "ConcurrentModificationException":
    case "com.amazonaws.eventbridge#ConcurrentModificationException":
      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
    case "InternalException":
    case "com.amazonaws.eventbridge#InternalException":
      throw await de_InternalExceptionRes(parsedOutput, context);
    case "InvalidStateException":
    case "com.amazonaws.eventbridge#InvalidStateException":
      throw await de_InvalidStateExceptionRes(parsedOutput, context);
    case "OperationDisabledException":
    case "com.amazonaws.eventbridge#OperationDisabledException":
      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
    case "ResourceNotFoundException":
    case "com.amazonaws.eventbridge#ResourceNotFoundException":
      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
    case "IllegalStatusException":
    case "com.amazonaws.eventbridge#IllegalStatusException":
      throw await de_IllegalStatusExceptionRes(parsedOutput, context);
    case "LimitExceededException":
    case "com.amazonaws.eventbridge#LimitExceededException":
      throw await de_LimitExceededExceptionRes(parsedOutput, context);
    case "ResourceAlreadyExistsException":
    case "com.amazonaws.eventbridge#ResourceAlreadyExistsException":
      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
    case "InvalidEventPatternException":
    case "com.amazonaws.eventbridge#InvalidEventPatternException":
      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
    case "AccessDeniedException":
    case "com.amazonaws.eventbridge#AccessDeniedException":
      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
    case "ThrottlingException":
    case "com.amazonaws.eventbridge#ThrottlingException":
      throw await de_ThrottlingExceptionRes(parsedOutput, context);
    case "ManagedRuleException":
    case "com.amazonaws.eventbridge#ManagedRuleException":
      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
    case "PolicyLengthExceededException":
    case "com.amazonaws.eventbridge#PolicyLengthExceededException":
      throw await de_PolicyLengthExceededExceptionRes(parsedOutput, context);
    default:
      const parsedBody = parsedOutput.body;
      return throwDefaultError({
        output,
        parsedBody,
        errorCode
      });
  }
}, "de_CommandError");
var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new AccessDeniedException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_AccessDeniedExceptionRes");
var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ConcurrentModificationException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ConcurrentModificationExceptionRes");
var de_IllegalStatusExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new IllegalStatusException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_IllegalStatusExceptionRes");
var de_InternalExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InternalException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InternalExceptionRes");
var de_InvalidEventPatternExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidEventPatternException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidEventPatternExceptionRes");
var de_InvalidStateExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new InvalidStateException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidStateExceptionRes");
var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new LimitExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_LimitExceededExceptionRes");
var de_ManagedRuleExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ManagedRuleException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ManagedRuleExceptionRes");
var de_OperationDisabledExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new OperationDisabledException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_OperationDisabledExceptionRes");
var de_PolicyLengthExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new PolicyLengthExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_PolicyLengthExceededExceptionRes");
var de_ResourceAlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ResourceAlreadyExistsException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ResourceAlreadyExistsExceptionRes");
var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ResourceNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ResourceNotFoundExceptionRes");
var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = (0, import_smithy_client._json)(body);
  const exception = new ThrottlingException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ThrottlingExceptionRes");
var se_PutEventsRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    EndpointId: [],
    Entries: (_) => se_PutEventsRequestEntryList(_, context)
  });
}, "se_PutEventsRequest");
var se_PutEventsRequestEntry = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Detail: [],
    DetailType: [],
    EventBusName: [],
    Resources: import_smithy_client._json,
    Source: [],
    Time: (_) => _.getTime() / 1e3,
    TraceHeader: []
  });
}, "se_PutEventsRequestEntry");
var se_PutEventsRequestEntryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return se_PutEventsRequestEntry(entry, context);
  });
}, "se_PutEventsRequestEntryList");
var se_PutPartnerEventsRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Entries: (_) => se_PutPartnerEventsRequestEntryList(_, context)
  });
}, "se_PutPartnerEventsRequest");
var se_PutPartnerEventsRequestEntry = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Detail: [],
    DetailType: [],
    Resources: import_smithy_client._json,
    Source: [],
    Time: (_) => _.getTime() / 1e3
  });
}, "se_PutPartnerEventsRequestEntry");
var se_PutPartnerEventsRequestEntryList = /* @__PURE__ */ __name((input, context) => {
  return input.filter((e) => e != null).map((entry) => {
    return se_PutPartnerEventsRequestEntry(entry, context);
  });
}, "se_PutPartnerEventsRequestEntryList");
var se_StartReplayRequest = /* @__PURE__ */ __name((input, context) => {
  return (0, import_smithy_client.take)(input, {
    Description: [],
    Destination: import_smithy_client._json,
    EventEndTime: (_) => _.getTime() / 1e3,
    EventSourceArn: [],
    EventStartTime: (_) => _.getTime() / 1e3,
    ReplayName: []
  });
}, "se_StartReplayRequest");
var de_ApiDestination = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ApiDestinationArn: import_smithy_client.expectString,
    ApiDestinationState: import_smithy_client.expectString,
    ConnectionArn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    HttpMethod: import_smithy_client.expectString,
    InvocationEndpoint: import_smithy_client.expectString,
    InvocationRateLimitPerSecond: import_smithy_client.expectInt32,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString
  });
}, "de_ApiDestination");
var de_ApiDestinationResponseList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_ApiDestination(entry, context);
  });
  return retVal;
}, "de_ApiDestinationResponseList");
var de_Archive = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ArchiveName: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    EventCount: import_smithy_client.expectLong,
    EventSourceArn: import_smithy_client.expectString,
    RetentionDays: import_smithy_client.expectInt32,
    SizeBytes: import_smithy_client.expectLong,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_Archive");
var de_ArchiveResponseList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_Archive(entry, context);
  });
  return retVal;
}, "de_ArchiveResponseList");
var de_Connection = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    AuthorizationType: import_smithy_client.expectString,
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastAuthorizedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_Connection");
var de_ConnectionResponseList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_Connection(entry, context);
  });
  return retVal;
}, "de_ConnectionResponseList");
var de_CreateApiDestinationResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ApiDestinationArn: import_smithy_client.expectString,
    ApiDestinationState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_CreateApiDestinationResponse");
var de_CreateArchiveResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ArchiveArn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_CreateArchiveResponse");
var de_CreateConnectionResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_CreateConnectionResponse");
var de_DeauthorizeConnectionResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastAuthorizedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_DeauthorizeConnectionResponse");
var de_DeleteConnectionResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastAuthorizedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_DeleteConnectionResponse");
var de_DescribeApiDestinationResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ApiDestinationArn: import_smithy_client.expectString,
    ApiDestinationState: import_smithy_client.expectString,
    ConnectionArn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    HttpMethod: import_smithy_client.expectString,
    InvocationEndpoint: import_smithy_client.expectString,
    InvocationRateLimitPerSecond: import_smithy_client.expectInt32,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString
  });
}, "de_DescribeApiDestinationResponse");
var de_DescribeArchiveResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ArchiveArn: import_smithy_client.expectString,
    ArchiveName: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    EventCount: import_smithy_client.expectLong,
    EventPattern: import_smithy_client.expectString,
    EventSourceArn: import_smithy_client.expectString,
    RetentionDays: import_smithy_client.expectInt32,
    SizeBytes: import_smithy_client.expectLong,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_DescribeArchiveResponse");
var de_DescribeConnectionResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    AuthParameters: import_smithy_client._json,
    AuthorizationType: import_smithy_client.expectString,
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    InvocationConnectivityParameters: import_smithy_client._json,
    LastAuthorizedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    SecretArn: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_DescribeConnectionResponse");
var de_DescribeEndpointResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    EndpointId: import_smithy_client.expectString,
    EndpointUrl: import_smithy_client.expectString,
    EventBuses: import_smithy_client._json,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    ReplicationConfig: import_smithy_client._json,
    RoleArn: import_smithy_client.expectString,
    RoutingConfig: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_DescribeEndpointResponse");
var de_DescribeEventBusResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    DeadLetterConfig: import_smithy_client._json,
    Description: import_smithy_client.expectString,
    KmsKeyIdentifier: import_smithy_client.expectString,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    Policy: import_smithy_client.expectString
  });
}, "de_DescribeEventBusResponse");
var de_DescribeEventSourceResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreatedBy: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ExpirationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    State: import_smithy_client.expectString
  });
}, "de_DescribeEventSourceResponse");
var de_DescribeReplayResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Description: import_smithy_client.expectString,
    Destination: import_smithy_client._json,
    EventEndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    EventLastReplayedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    EventSourceArn: import_smithy_client.expectString,
    EventStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ReplayArn: import_smithy_client.expectString,
    ReplayEndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ReplayName: import_smithy_client.expectString,
    ReplayStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_DescribeReplayResponse");
var de_Endpoint = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    EndpointId: import_smithy_client.expectString,
    EndpointUrl: import_smithy_client.expectString,
    EventBuses: import_smithy_client._json,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    ReplicationConfig: import_smithy_client._json,
    RoleArn: import_smithy_client.expectString,
    RoutingConfig: import_smithy_client._json,
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_Endpoint");
var de_EndpointList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_Endpoint(entry, context);
  });
  return retVal;
}, "de_EndpointList");
var de_EventBus = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Description: import_smithy_client.expectString,
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    Policy: import_smithy_client.expectString
  });
}, "de_EventBus");
var de_EventBusList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_EventBus(entry, context);
  });
  return retVal;
}, "de_EventBusList");
var de_EventSource = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Arn: import_smithy_client.expectString,
    CreatedBy: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ExpirationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    Name: import_smithy_client.expectString,
    State: import_smithy_client.expectString
  });
}, "de_EventSource");
var de_EventSourceList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_EventSource(entry, context);
  });
  return retVal;
}, "de_EventSourceList");
var de_ListApiDestinationsResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ApiDestinations: (_) => de_ApiDestinationResponseList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListApiDestinationsResponse");
var de_ListArchivesResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Archives: (_) => de_ArchiveResponseList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListArchivesResponse");
var de_ListConnectionsResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Connections: (_) => de_ConnectionResponseList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListConnectionsResponse");
var de_ListEndpointsResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Endpoints: (_) => de_EndpointList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListEndpointsResponse");
var de_ListEventBusesResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    EventBuses: (_) => de_EventBusList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListEventBusesResponse");
var de_ListEventSourcesResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    EventSources: (_) => de_EventSourceList(_, context),
    NextToken: import_smithy_client.expectString
  });
}, "de_ListEventSourcesResponse");
var de_ListPartnerEventSourceAccountsResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    NextToken: import_smithy_client.expectString,
    PartnerEventSourceAccounts: (_) => de_PartnerEventSourceAccountList(_, context)
  });
}, "de_ListPartnerEventSourceAccountsResponse");
var de_ListReplaysResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    NextToken: import_smithy_client.expectString,
    Replays: (_) => de_ReplayList(_, context)
  });
}, "de_ListReplaysResponse");
var de_PartnerEventSourceAccount = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    Account: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ExpirationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString
  });
}, "de_PartnerEventSourceAccount");
var de_PartnerEventSourceAccountList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_PartnerEventSourceAccount(entry, context);
  });
  return retVal;
}, "de_PartnerEventSourceAccountList");
var de_Replay = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    EventEndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    EventLastReplayedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    EventSourceArn: import_smithy_client.expectString,
    EventStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ReplayEndTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    ReplayName: import_smithy_client.expectString,
    ReplayStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_Replay");
var de_ReplayList = /* @__PURE__ */ __name((output, context) => {
  const retVal = (output || []).filter((e) => e != null).map((entry) => {
    return de_Replay(entry, context);
  });
  return retVal;
}, "de_ReplayList");
var de_StartReplayResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ReplayArn: import_smithy_client.expectString,
    ReplayStartTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_StartReplayResponse");
var de_UpdateApiDestinationResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ApiDestinationArn: import_smithy_client.expectString,
    ApiDestinationState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_UpdateApiDestinationResponse");
var de_UpdateArchiveResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ArchiveArn: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    State: import_smithy_client.expectString,
    StateReason: import_smithy_client.expectString
  });
}, "de_UpdateArchiveResponse");
var de_UpdateConnectionResponse = /* @__PURE__ */ __name((output, context) => {
  return (0, import_smithy_client.take)(output, {
    ConnectionArn: import_smithy_client.expectString,
    ConnectionState: import_smithy_client.expectString,
    CreationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastAuthorizedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
  });
}, "de_UpdateConnectionResponse");
var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
  httpStatusCode: output.statusCode,
  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
  extendedRequestId: output.headers["x-amz-id-2"],
  cfId: output.headers["x-amz-cf-id"]
}), "deserializeMetadata");
var throwDefaultError = (0, import_smithy_client.withBaseException)(EventBridgeServiceException);
var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
  const contents = {
    protocol,
    hostname,
    port,
    method: "POST",
    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
    headers
  };
  if (resolvedHostname !== void 0) {
    contents.hostname = resolvedHostname;
  }
  if (body !== void 0) {
    contents.body = body;
  }
  return new import_protocol_http.HttpRequest(contents);
}, "buildHttpRpcRequest");
function sharedHeaders(operation) {
  return {
    "content-type": "application/x-amz-json-1.1",
    "x-amz-target": `AWSEvents.${operation}`
  };
}
__name(sharedHeaders, "sharedHeaders");

// src/commands/ActivateEventSourceCommand.ts
var _ActivateEventSourceCommand = class _ActivateEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ActivateEventSource", {}).n("EventBridgeClient", "ActivateEventSourceCommand").f(void 0, void 0).ser(se_ActivateEventSourceCommand).de(de_ActivateEventSourceCommand).build() {
};
__name(_ActivateEventSourceCommand, "ActivateEventSourceCommand");
var ActivateEventSourceCommand = _ActivateEventSourceCommand;

// src/commands/CancelReplayCommand.ts



var _CancelReplayCommand = class _CancelReplayCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CancelReplay", {}).n("EventBridgeClient", "CancelReplayCommand").f(void 0, void 0).ser(se_CancelReplayCommand).de(de_CancelReplayCommand).build() {
};
__name(_CancelReplayCommand, "CancelReplayCommand");
var CancelReplayCommand = _CancelReplayCommand;

// src/commands/CreateApiDestinationCommand.ts



var _CreateApiDestinationCommand = class _CreateApiDestinationCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreateApiDestination", {}).n("EventBridgeClient", "CreateApiDestinationCommand").f(void 0, void 0).ser(se_CreateApiDestinationCommand).de(de_CreateApiDestinationCommand).build() {
};
__name(_CreateApiDestinationCommand, "CreateApiDestinationCommand");
var CreateApiDestinationCommand = _CreateApiDestinationCommand;

// src/commands/CreateArchiveCommand.ts



var _CreateArchiveCommand = class _CreateArchiveCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreateArchive", {}).n("EventBridgeClient", "CreateArchiveCommand").f(void 0, void 0).ser(se_CreateArchiveCommand).de(de_CreateArchiveCommand).build() {
};
__name(_CreateArchiveCommand, "CreateArchiveCommand");
var CreateArchiveCommand = _CreateArchiveCommand;

// src/commands/CreateConnectionCommand.ts



var _CreateConnectionCommand = class _CreateConnectionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreateConnection", {}).n("EventBridgeClient", "CreateConnectionCommand").f(CreateConnectionRequestFilterSensitiveLog, void 0).ser(se_CreateConnectionCommand).de(de_CreateConnectionCommand).build() {
};
__name(_CreateConnectionCommand, "CreateConnectionCommand");
var CreateConnectionCommand = _CreateConnectionCommand;

// src/commands/CreateEndpointCommand.ts



var _CreateEndpointCommand = class _CreateEndpointCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreateEndpoint", {}).n("EventBridgeClient", "CreateEndpointCommand").f(void 0, void 0).ser(se_CreateEndpointCommand).de(de_CreateEndpointCommand).build() {
};
__name(_CreateEndpointCommand, "CreateEndpointCommand");
var CreateEndpointCommand = _CreateEndpointCommand;

// src/commands/CreateEventBusCommand.ts



var _CreateEventBusCommand = class _CreateEventBusCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreateEventBus", {}).n("EventBridgeClient", "CreateEventBusCommand").f(void 0, void 0).ser(se_CreateEventBusCommand).de(de_CreateEventBusCommand).build() {
};
__name(_CreateEventBusCommand, "CreateEventBusCommand");
var CreateEventBusCommand = _CreateEventBusCommand;

// src/commands/CreatePartnerEventSourceCommand.ts



var _CreatePartnerEventSourceCommand = class _CreatePartnerEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "CreatePartnerEventSource", {}).n("EventBridgeClient", "CreatePartnerEventSourceCommand").f(void 0, void 0).ser(se_CreatePartnerEventSourceCommand).de(de_CreatePartnerEventSourceCommand).build() {
};
__name(_CreatePartnerEventSourceCommand, "CreatePartnerEventSourceCommand");
var CreatePartnerEventSourceCommand = _CreatePartnerEventSourceCommand;

// src/commands/DeactivateEventSourceCommand.ts



var _DeactivateEventSourceCommand = class _DeactivateEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeactivateEventSource", {}).n("EventBridgeClient", "DeactivateEventSourceCommand").f(void 0, void 0).ser(se_DeactivateEventSourceCommand).de(de_DeactivateEventSourceCommand).build() {
};
__name(_DeactivateEventSourceCommand, "DeactivateEventSourceCommand");
var DeactivateEventSourceCommand = _DeactivateEventSourceCommand;

// src/commands/DeauthorizeConnectionCommand.ts



var _DeauthorizeConnectionCommand = class _DeauthorizeConnectionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeauthorizeConnection", {}).n("EventBridgeClient", "DeauthorizeConnectionCommand").f(void 0, void 0).ser(se_DeauthorizeConnectionCommand).de(de_DeauthorizeConnectionCommand).build() {
};
__name(_DeauthorizeConnectionCommand, "DeauthorizeConnectionCommand");
var DeauthorizeConnectionCommand = _DeauthorizeConnectionCommand;

// src/commands/DeleteApiDestinationCommand.ts



var _DeleteApiDestinationCommand = class _DeleteApiDestinationCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteApiDestination", {}).n("EventBridgeClient", "DeleteApiDestinationCommand").f(void 0, void 0).ser(se_DeleteApiDestinationCommand).de(de_DeleteApiDestinationCommand).build() {
};
__name(_DeleteApiDestinationCommand, "DeleteApiDestinationCommand");
var DeleteApiDestinationCommand = _DeleteApiDestinationCommand;

// src/commands/DeleteArchiveCommand.ts



var _DeleteArchiveCommand = class _DeleteArchiveCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteArchive", {}).n("EventBridgeClient", "DeleteArchiveCommand").f(void 0, void 0).ser(se_DeleteArchiveCommand).de(de_DeleteArchiveCommand).build() {
};
__name(_DeleteArchiveCommand, "DeleteArchiveCommand");
var DeleteArchiveCommand = _DeleteArchiveCommand;

// src/commands/DeleteConnectionCommand.ts



var _DeleteConnectionCommand = class _DeleteConnectionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteConnection", {}).n("EventBridgeClient", "DeleteConnectionCommand").f(void 0, void 0).ser(se_DeleteConnectionCommand).de(de_DeleteConnectionCommand).build() {
};
__name(_DeleteConnectionCommand, "DeleteConnectionCommand");
var DeleteConnectionCommand = _DeleteConnectionCommand;

// src/commands/DeleteEndpointCommand.ts



var _DeleteEndpointCommand = class _DeleteEndpointCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteEndpoint", {}).n("EventBridgeClient", "DeleteEndpointCommand").f(void 0, void 0).ser(se_DeleteEndpointCommand).de(de_DeleteEndpointCommand).build() {
};
__name(_DeleteEndpointCommand, "DeleteEndpointCommand");
var DeleteEndpointCommand = _DeleteEndpointCommand;

// src/commands/DeleteEventBusCommand.ts



var _DeleteEventBusCommand = class _DeleteEventBusCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteEventBus", {}).n("EventBridgeClient", "DeleteEventBusCommand").f(void 0, void 0).ser(se_DeleteEventBusCommand).de(de_DeleteEventBusCommand).build() {
};
__name(_DeleteEventBusCommand, "DeleteEventBusCommand");
var DeleteEventBusCommand = _DeleteEventBusCommand;

// src/commands/DeletePartnerEventSourceCommand.ts



var _DeletePartnerEventSourceCommand = class _DeletePartnerEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeletePartnerEventSource", {}).n("EventBridgeClient", "DeletePartnerEventSourceCommand").f(void 0, void 0).ser(se_DeletePartnerEventSourceCommand).de(de_DeletePartnerEventSourceCommand).build() {
};
__name(_DeletePartnerEventSourceCommand, "DeletePartnerEventSourceCommand");
var DeletePartnerEventSourceCommand = _DeletePartnerEventSourceCommand;

// src/commands/DeleteRuleCommand.ts



var _DeleteRuleCommand = class _DeleteRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DeleteRule", {}).n("EventBridgeClient", "DeleteRuleCommand").f(void 0, void 0).ser(se_DeleteRuleCommand).de(de_DeleteRuleCommand).build() {
};
__name(_DeleteRuleCommand, "DeleteRuleCommand");
var DeleteRuleCommand = _DeleteRuleCommand;

// src/commands/DescribeApiDestinationCommand.ts



var _DescribeApiDestinationCommand = class _DescribeApiDestinationCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeApiDestination", {}).n("EventBridgeClient", "DescribeApiDestinationCommand").f(void 0, void 0).ser(se_DescribeApiDestinationCommand).de(de_DescribeApiDestinationCommand).build() {
};
__name(_DescribeApiDestinationCommand, "DescribeApiDestinationCommand");
var DescribeApiDestinationCommand = _DescribeApiDestinationCommand;

// src/commands/DescribeArchiveCommand.ts



var _DescribeArchiveCommand = class _DescribeArchiveCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeArchive", {}).n("EventBridgeClient", "DescribeArchiveCommand").f(void 0, void 0).ser(se_DescribeArchiveCommand).de(de_DescribeArchiveCommand).build() {
};
__name(_DescribeArchiveCommand, "DescribeArchiveCommand");
var DescribeArchiveCommand = _DescribeArchiveCommand;

// src/commands/DescribeConnectionCommand.ts



var _DescribeConnectionCommand = class _DescribeConnectionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeConnection", {}).n("EventBridgeClient", "DescribeConnectionCommand").f(void 0, DescribeConnectionResponseFilterSensitiveLog).ser(se_DescribeConnectionCommand).de(de_DescribeConnectionCommand).build() {
};
__name(_DescribeConnectionCommand, "DescribeConnectionCommand");
var DescribeConnectionCommand = _DescribeConnectionCommand;

// src/commands/DescribeEndpointCommand.ts



var _DescribeEndpointCommand = class _DescribeEndpointCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeEndpoint", {}).n("EventBridgeClient", "DescribeEndpointCommand").f(void 0, void 0).ser(se_DescribeEndpointCommand).de(de_DescribeEndpointCommand).build() {
};
__name(_DescribeEndpointCommand, "DescribeEndpointCommand");
var DescribeEndpointCommand = _DescribeEndpointCommand;

// src/commands/DescribeEventBusCommand.ts



var _DescribeEventBusCommand = class _DescribeEventBusCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeEventBus", {}).n("EventBridgeClient", "DescribeEventBusCommand").f(void 0, void 0).ser(se_DescribeEventBusCommand).de(de_DescribeEventBusCommand).build() {
};
__name(_DescribeEventBusCommand, "DescribeEventBusCommand");
var DescribeEventBusCommand = _DescribeEventBusCommand;

// src/commands/DescribeEventSourceCommand.ts



var _DescribeEventSourceCommand = class _DescribeEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeEventSource", {}).n("EventBridgeClient", "DescribeEventSourceCommand").f(void 0, void 0).ser(se_DescribeEventSourceCommand).de(de_DescribeEventSourceCommand).build() {
};
__name(_DescribeEventSourceCommand, "DescribeEventSourceCommand");
var DescribeEventSourceCommand = _DescribeEventSourceCommand;

// src/commands/DescribePartnerEventSourceCommand.ts



var _DescribePartnerEventSourceCommand = class _DescribePartnerEventSourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribePartnerEventSource", {}).n("EventBridgeClient", "DescribePartnerEventSourceCommand").f(void 0, void 0).ser(se_DescribePartnerEventSourceCommand).de(de_DescribePartnerEventSourceCommand).build() {
};
__name(_DescribePartnerEventSourceCommand, "DescribePartnerEventSourceCommand");
var DescribePartnerEventSourceCommand = _DescribePartnerEventSourceCommand;

// src/commands/DescribeReplayCommand.ts



var _DescribeReplayCommand = class _DescribeReplayCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeReplay", {}).n("EventBridgeClient", "DescribeReplayCommand").f(void 0, void 0).ser(se_DescribeReplayCommand).de(de_DescribeReplayCommand).build() {
};
__name(_DescribeReplayCommand, "DescribeReplayCommand");
var DescribeReplayCommand = _DescribeReplayCommand;

// src/commands/DescribeRuleCommand.ts



var _DescribeRuleCommand = class _DescribeRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DescribeRule", {}).n("EventBridgeClient", "DescribeRuleCommand").f(void 0, void 0).ser(se_DescribeRuleCommand).de(de_DescribeRuleCommand).build() {
};
__name(_DescribeRuleCommand, "DescribeRuleCommand");
var DescribeRuleCommand = _DescribeRuleCommand;

// src/commands/DisableRuleCommand.ts



var _DisableRuleCommand = class _DisableRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "DisableRule", {}).n("EventBridgeClient", "DisableRuleCommand").f(void 0, void 0).ser(se_DisableRuleCommand).de(de_DisableRuleCommand).build() {
};
__name(_DisableRuleCommand, "DisableRuleCommand");
var DisableRuleCommand = _DisableRuleCommand;

// src/commands/EnableRuleCommand.ts



var _EnableRuleCommand = class _EnableRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "EnableRule", {}).n("EventBridgeClient", "EnableRuleCommand").f(void 0, void 0).ser(se_EnableRuleCommand).de(de_EnableRuleCommand).build() {
};
__name(_EnableRuleCommand, "EnableRuleCommand");
var EnableRuleCommand = _EnableRuleCommand;

// src/commands/ListApiDestinationsCommand.ts



var _ListApiDestinationsCommand = class _ListApiDestinationsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListApiDestinations", {}).n("EventBridgeClient", "ListApiDestinationsCommand").f(void 0, void 0).ser(se_ListApiDestinationsCommand).de(de_ListApiDestinationsCommand).build() {
};
__name(_ListApiDestinationsCommand, "ListApiDestinationsCommand");
var ListApiDestinationsCommand = _ListApiDestinationsCommand;

// src/commands/ListArchivesCommand.ts



var _ListArchivesCommand = class _ListArchivesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListArchives", {}).n("EventBridgeClient", "ListArchivesCommand").f(void 0, void 0).ser(se_ListArchivesCommand).de(de_ListArchivesCommand).build() {
};
__name(_ListArchivesCommand, "ListArchivesCommand");
var ListArchivesCommand = _ListArchivesCommand;

// src/commands/ListConnectionsCommand.ts



var _ListConnectionsCommand = class _ListConnectionsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListConnections", {}).n("EventBridgeClient", "ListConnectionsCommand").f(void 0, void 0).ser(se_ListConnectionsCommand).de(de_ListConnectionsCommand).build() {
};
__name(_ListConnectionsCommand, "ListConnectionsCommand");
var ListConnectionsCommand = _ListConnectionsCommand;

// src/commands/ListEndpointsCommand.ts



var _ListEndpointsCommand = class _ListEndpointsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListEndpoints", {}).n("EventBridgeClient", "ListEndpointsCommand").f(void 0, void 0).ser(se_ListEndpointsCommand).de(de_ListEndpointsCommand).build() {
};
__name(_ListEndpointsCommand, "ListEndpointsCommand");
var ListEndpointsCommand = _ListEndpointsCommand;

// src/commands/ListEventBusesCommand.ts



var _ListEventBusesCommand = class _ListEventBusesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListEventBuses", {}).n("EventBridgeClient", "ListEventBusesCommand").f(void 0, void 0).ser(se_ListEventBusesCommand).de(de_ListEventBusesCommand).build() {
};
__name(_ListEventBusesCommand, "ListEventBusesCommand");
var ListEventBusesCommand = _ListEventBusesCommand;

// src/commands/ListEventSourcesCommand.ts



var _ListEventSourcesCommand = class _ListEventSourcesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListEventSources", {}).n("EventBridgeClient", "ListEventSourcesCommand").f(void 0, void 0).ser(se_ListEventSourcesCommand).de(de_ListEventSourcesCommand).build() {
};
__name(_ListEventSourcesCommand, "ListEventSourcesCommand");
var ListEventSourcesCommand = _ListEventSourcesCommand;

// src/commands/ListPartnerEventSourceAccountsCommand.ts



var _ListPartnerEventSourceAccountsCommand = class _ListPartnerEventSourceAccountsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListPartnerEventSourceAccounts", {}).n("EventBridgeClient", "ListPartnerEventSourceAccountsCommand").f(void 0, void 0).ser(se_ListPartnerEventSourceAccountsCommand).de(de_ListPartnerEventSourceAccountsCommand).build() {
};
__name(_ListPartnerEventSourceAccountsCommand, "ListPartnerEventSourceAccountsCommand");
var ListPartnerEventSourceAccountsCommand = _ListPartnerEventSourceAccountsCommand;

// src/commands/ListPartnerEventSourcesCommand.ts



var _ListPartnerEventSourcesCommand = class _ListPartnerEventSourcesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListPartnerEventSources", {}).n("EventBridgeClient", "ListPartnerEventSourcesCommand").f(void 0, void 0).ser(se_ListPartnerEventSourcesCommand).de(de_ListPartnerEventSourcesCommand).build() {
};
__name(_ListPartnerEventSourcesCommand, "ListPartnerEventSourcesCommand");
var ListPartnerEventSourcesCommand = _ListPartnerEventSourcesCommand;

// src/commands/ListReplaysCommand.ts



var _ListReplaysCommand = class _ListReplaysCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListReplays", {}).n("EventBridgeClient", "ListReplaysCommand").f(void 0, void 0).ser(se_ListReplaysCommand).de(de_ListReplaysCommand).build() {
};
__name(_ListReplaysCommand, "ListReplaysCommand");
var ListReplaysCommand = _ListReplaysCommand;

// src/commands/ListRuleNamesByTargetCommand.ts



var _ListRuleNamesByTargetCommand = class _ListRuleNamesByTargetCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListRuleNamesByTarget", {}).n("EventBridgeClient", "ListRuleNamesByTargetCommand").f(void 0, void 0).ser(se_ListRuleNamesByTargetCommand).de(de_ListRuleNamesByTargetCommand).build() {
};
__name(_ListRuleNamesByTargetCommand, "ListRuleNamesByTargetCommand");
var ListRuleNamesByTargetCommand = _ListRuleNamesByTargetCommand;

// src/commands/ListRulesCommand.ts



var _ListRulesCommand = class _ListRulesCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListRules", {}).n("EventBridgeClient", "ListRulesCommand").f(void 0, void 0).ser(se_ListRulesCommand).de(de_ListRulesCommand).build() {
};
__name(_ListRulesCommand, "ListRulesCommand");
var ListRulesCommand = _ListRulesCommand;

// src/commands/ListTagsForResourceCommand.ts



var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListTagsForResource", {}).n("EventBridgeClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
};
__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
var ListTagsForResourceCommand = _ListTagsForResourceCommand;

// src/commands/ListTargetsByRuleCommand.ts



var _ListTargetsByRuleCommand = class _ListTargetsByRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "ListTargetsByRule", {}).n("EventBridgeClient", "ListTargetsByRuleCommand").f(void 0, ListTargetsByRuleResponseFilterSensitiveLog).ser(se_ListTargetsByRuleCommand).de(de_ListTargetsByRuleCommand).build() {
};
__name(_ListTargetsByRuleCommand, "ListTargetsByRuleCommand");
var ListTargetsByRuleCommand = _ListTargetsByRuleCommand;

// src/commands/PutEventsCommand.ts



var _PutEventsCommand = class _PutEventsCommand extends import_smithy_client.Command.classBuilder().ep({
  ...commonParams,
  EndpointId: { type: "contextParams", name: "EndpointId" }
}).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "PutEvents", {}).n("EventBridgeClient", "PutEventsCommand").f(void 0, void 0).ser(se_PutEventsCommand).de(de_PutEventsCommand).build() {
};
__name(_PutEventsCommand, "PutEventsCommand");
var PutEventsCommand = _PutEventsCommand;

// src/commands/PutPartnerEventsCommand.ts



var _PutPartnerEventsCommand = class _PutPartnerEventsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "PutPartnerEvents", {}).n("EventBridgeClient", "PutPartnerEventsCommand").f(void 0, void 0).ser(se_PutPartnerEventsCommand).de(de_PutPartnerEventsCommand).build() {
};
__name(_PutPartnerEventsCommand, "PutPartnerEventsCommand");
var PutPartnerEventsCommand = _PutPartnerEventsCommand;

// src/commands/PutPermissionCommand.ts



var _PutPermissionCommand = class _PutPermissionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "PutPermission", {}).n("EventBridgeClient", "PutPermissionCommand").f(void 0, void 0).ser(se_PutPermissionCommand).de(de_PutPermissionCommand).build() {
};
__name(_PutPermissionCommand, "PutPermissionCommand");
var PutPermissionCommand = _PutPermissionCommand;

// src/commands/PutRuleCommand.ts



var _PutRuleCommand = class _PutRuleCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "PutRule", {}).n("EventBridgeClient", "PutRuleCommand").f(void 0, void 0).ser(se_PutRuleCommand).de(de_PutRuleCommand).build() {
};
__name(_PutRuleCommand, "PutRuleCommand");
var PutRuleCommand = _PutRuleCommand;

// src/commands/PutTargetsCommand.ts



var _PutTargetsCommand = class _PutTargetsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "PutTargets", {}).n("EventBridgeClient", "PutTargetsCommand").f(PutTargetsRequestFilterSensitiveLog, void 0).ser(se_PutTargetsCommand).de(de_PutTargetsCommand).build() {
};
__name(_PutTargetsCommand, "PutTargetsCommand");
var PutTargetsCommand = _PutTargetsCommand;

// src/commands/RemovePermissionCommand.ts



var _RemovePermissionCommand = class _RemovePermissionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "RemovePermission", {}).n("EventBridgeClient", "RemovePermissionCommand").f(void 0, void 0).ser(se_RemovePermissionCommand).de(de_RemovePermissionCommand).build() {
};
__name(_RemovePermissionCommand, "RemovePermissionCommand");
var RemovePermissionCommand = _RemovePermissionCommand;

// src/commands/RemoveTargetsCommand.ts



var _RemoveTargetsCommand = class _RemoveTargetsCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "RemoveTargets", {}).n("EventBridgeClient", "RemoveTargetsCommand").f(void 0, void 0).ser(se_RemoveTargetsCommand).de(de_RemoveTargetsCommand).build() {
};
__name(_RemoveTargetsCommand, "RemoveTargetsCommand");
var RemoveTargetsCommand = _RemoveTargetsCommand;

// src/commands/StartReplayCommand.ts



var _StartReplayCommand = class _StartReplayCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "StartReplay", {}).n("EventBridgeClient", "StartReplayCommand").f(void 0, void 0).ser(se_StartReplayCommand).de(de_StartReplayCommand).build() {
};
__name(_StartReplayCommand, "StartReplayCommand");
var StartReplayCommand = _StartReplayCommand;

// src/commands/TagResourceCommand.ts



var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "TagResource", {}).n("EventBridgeClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
};
__name(_TagResourceCommand, "TagResourceCommand");
var TagResourceCommand = _TagResourceCommand;

// src/commands/TestEventPatternCommand.ts



var _TestEventPatternCommand = class _TestEventPatternCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "TestEventPattern", {}).n("EventBridgeClient", "TestEventPatternCommand").f(void 0, void 0).ser(se_TestEventPatternCommand).de(de_TestEventPatternCommand).build() {
};
__name(_TestEventPatternCommand, "TestEventPatternCommand");
var TestEventPatternCommand = _TestEventPatternCommand;

// src/commands/UntagResourceCommand.ts



var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UntagResource", {}).n("EventBridgeClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
};
__name(_UntagResourceCommand, "UntagResourceCommand");
var UntagResourceCommand = _UntagResourceCommand;

// src/commands/UpdateApiDestinationCommand.ts



var _UpdateApiDestinationCommand = class _UpdateApiDestinationCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UpdateApiDestination", {}).n("EventBridgeClient", "UpdateApiDestinationCommand").f(void 0, void 0).ser(se_UpdateApiDestinationCommand).de(de_UpdateApiDestinationCommand).build() {
};
__name(_UpdateApiDestinationCommand, "UpdateApiDestinationCommand");
var UpdateApiDestinationCommand = _UpdateApiDestinationCommand;

// src/commands/UpdateArchiveCommand.ts



var _UpdateArchiveCommand = class _UpdateArchiveCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UpdateArchive", {}).n("EventBridgeClient", "UpdateArchiveCommand").f(void 0, void 0).ser(se_UpdateArchiveCommand).de(de_UpdateArchiveCommand).build() {
};
__name(_UpdateArchiveCommand, "UpdateArchiveCommand");
var UpdateArchiveCommand = _UpdateArchiveCommand;

// src/commands/UpdateConnectionCommand.ts



var _UpdateConnectionCommand = class _UpdateConnectionCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UpdateConnection", {}).n("EventBridgeClient", "UpdateConnectionCommand").f(UpdateConnectionRequestFilterSensitiveLog, void 0).ser(se_UpdateConnectionCommand).de(de_UpdateConnectionCommand).build() {
};
__name(_UpdateConnectionCommand, "UpdateConnectionCommand");
var UpdateConnectionCommand = _UpdateConnectionCommand;

// src/commands/UpdateEndpointCommand.ts



var _UpdateEndpointCommand = class _UpdateEndpointCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UpdateEndpoint", {}).n("EventBridgeClient", "UpdateEndpointCommand").f(void 0, void 0).ser(se_UpdateEndpointCommand).de(de_UpdateEndpointCommand).build() {
};
__name(_UpdateEndpointCommand, "UpdateEndpointCommand");
var UpdateEndpointCommand = _UpdateEndpointCommand;

// src/commands/UpdateEventBusCommand.ts



var _UpdateEventBusCommand = class _UpdateEventBusCommand extends import_smithy_client.Command.classBuilder().ep(commonParams).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("AWSEvents", "UpdateEventBus", {}).n("EventBridgeClient", "UpdateEventBusCommand").f(void 0, void 0).ser(se_UpdateEventBusCommand).de(de_UpdateEventBusCommand).build() {
};
__name(_UpdateEventBusCommand, "UpdateEventBusCommand");
var UpdateEventBusCommand = _UpdateEventBusCommand;

// src/EventBridge.ts
var commands = {
  ActivateEventSourceCommand,
  CancelReplayCommand,
  CreateApiDestinationCommand,
  CreateArchiveCommand,
  CreateConnectionCommand,
  CreateEndpointCommand,
  CreateEventBusCommand,
  CreatePartnerEventSourceCommand,
  DeactivateEventSourceCommand,
  DeauthorizeConnectionCommand,
  DeleteApiDestinationCommand,
  DeleteArchiveCommand,
  DeleteConnectionCommand,
  DeleteEndpointCommand,
  DeleteEventBusCommand,
  DeletePartnerEventSourceCommand,
  DeleteRuleCommand,
  DescribeApiDestinationCommand,
  DescribeArchiveCommand,
  DescribeConnectionCommand,
  DescribeEndpointCommand,
  DescribeEventBusCommand,
  DescribeEventSourceCommand,
  DescribePartnerEventSourceCommand,
  DescribeReplayCommand,
  DescribeRuleCommand,
  DisableRuleCommand,
  EnableRuleCommand,
  ListApiDestinationsCommand,
  ListArchivesCommand,
  ListConnectionsCommand,
  ListEndpointsCommand,
  ListEventBusesCommand,
  ListEventSourcesCommand,
  ListPartnerEventSourceAccountsCommand,
  ListPartnerEventSourcesCommand,
  ListReplaysCommand,
  ListRuleNamesByTargetCommand,
  ListRulesCommand,
  ListTagsForResourceCommand,
  ListTargetsByRuleCommand,
  PutEventsCommand,
  PutPartnerEventsCommand,
  PutPermissionCommand,
  PutRuleCommand,
  PutTargetsCommand,
  RemovePermissionCommand,
  RemoveTargetsCommand,
  StartReplayCommand,
  TagResourceCommand,
  TestEventPatternCommand,
  UntagResourceCommand,
  UpdateApiDestinationCommand,
  UpdateArchiveCommand,
  UpdateConnectionCommand,
  UpdateEndpointCommand,
  UpdateEventBusCommand
};
var _EventBridge = class _EventBridge extends EventBridgeClient {
};
__name(_EventBridge, "EventBridge");
var EventBridge = _EventBridge;
(0, import_smithy_client.createAggregatedClient)(commands, EventBridge);
// Annotate the CommonJS export names for ESM import in node:

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