@aws-sdk/client-cloudwatch-events 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,4417 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CloudWatchEventsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./CloudWatchEventsClient"), exports);
-tslib_1.__exportStar(require("./CloudWatchEvents"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var CloudWatchEventsServiceException_1 = require("./models/CloudWatchEventsServiceException");
-Object.defineProperty(exports, "CloudWatchEventsServiceException", { enumerable: true, get: function () { return CloudWatchEventsServiceException_1.CloudWatchEventsServiceException; } });
+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, {
+  ActivateEventSourceCommand: () => ActivateEventSourceCommand,
+  ApiDestinationHttpMethod: () => ApiDestinationHttpMethod,
+  ApiDestinationState: () => ApiDestinationState,
+  ArchiveState: () => ArchiveState,
+  AssignPublicIp: () => AssignPublicIp,
+  CancelReplayCommand: () => CancelReplayCommand,
+  CloudWatchEvents: () => CloudWatchEvents,
+  CloudWatchEventsClient: () => CloudWatchEventsClient,
+  CloudWatchEventsServiceException: () => CloudWatchEventsServiceException,
+  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,
+  CreateEventBusCommand: () => CreateEventBusCommand,
+  CreatePartnerEventSourceCommand: () => CreatePartnerEventSourceCommand,
+  DeactivateEventSourceCommand: () => DeactivateEventSourceCommand,
+  DeauthorizeConnectionCommand: () => DeauthorizeConnectionCommand,
+  DeleteApiDestinationCommand: () => DeleteApiDestinationCommand,
+  DeleteArchiveCommand: () => DeleteArchiveCommand,
+  DeleteConnectionCommand: () => DeleteConnectionCommand,
+  DeleteEventBusCommand: () => DeleteEventBusCommand,
+  DeletePartnerEventSourceCommand: () => DeletePartnerEventSourceCommand,
+  DeleteRuleCommand: () => DeleteRuleCommand,
+  DescribeApiDestinationCommand: () => DescribeApiDestinationCommand,
+  DescribeArchiveCommand: () => DescribeArchiveCommand,
+  DescribeConnectionCommand: () => DescribeConnectionCommand,
+  DescribeConnectionResponseFilterSensitiveLog: () => DescribeConnectionResponseFilterSensitiveLog,
+  DescribeEventBusCommand: () => DescribeEventBusCommand,
+  DescribeEventSourceCommand: () => DescribeEventSourceCommand,
+  DescribePartnerEventSourceCommand: () => DescribePartnerEventSourceCommand,
+  DescribeReplayCommand: () => DescribeReplayCommand,
+  DescribeRuleCommand: () => DescribeRuleCommand,
+  DisableRuleCommand: () => DisableRuleCommand,
+  EnableRuleCommand: () => EnableRuleCommand,
+  EventSourceState: () => EventSourceState,
+  IllegalStatusException: () => IllegalStatusException,
+  InternalException: () => InternalException,
+  InvalidEventPatternException: () => InvalidEventPatternException,
+  InvalidStateException: () => InvalidStateException,
+  LaunchType: () => LaunchType,
+  LimitExceededException: () => LimitExceededException,
+  ListApiDestinationsCommand: () => ListApiDestinationsCommand,
+  ListArchivesCommand: () => ListArchivesCommand,
+  ListConnectionsCommand: () => ListConnectionsCommand,
+  ListEventBusesCommand: () => ListEventBusesCommand,
+  ListEventSourcesCommand: () => ListEventSourcesCommand,
+  ListPartnerEventSourceAccountsCommand: () => ListPartnerEventSourceAccountsCommand,
+  ListPartnerEventSourcesCommand: () => ListPartnerEventSourcesCommand,
+  ListReplaysCommand: () => ListReplaysCommand,
+  ListRuleNamesByTargetCommand: () => ListRuleNamesByTargetCommand,
+  ListRulesCommand: () => ListRulesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTargetsByRuleCommand: () => ListTargetsByRuleCommand,
+  ManagedRuleException: () => ManagedRuleException,
+  OperationDisabledException: () => OperationDisabledException,
+  PlacementConstraintType: () => PlacementConstraintType,
+  PlacementStrategyType: () => PlacementStrategyType,
+  PolicyLengthExceededException: () => PolicyLengthExceededException,
+  PropagateTags: () => PropagateTags,
+  PutEventsCommand: () => PutEventsCommand,
+  PutPartnerEventsCommand: () => PutPartnerEventsCommand,
+  PutPermissionCommand: () => PutPermissionCommand,
+  PutRuleCommand: () => PutRuleCommand,
+  PutTargetsCommand: () => PutTargetsCommand,
+  RemovePermissionCommand: () => RemovePermissionCommand,
+  RemoveTargetsCommand: () => RemoveTargetsCommand,
+  ReplayState: () => ReplayState,
+  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  RuleState: () => RuleState,
+  StartReplayCommand: () => StartReplayCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TestEventPatternCommand: () => TestEventPatternCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateApiDestinationCommand: () => UpdateApiDestinationCommand,
+  UpdateArchiveCommand: () => UpdateArchiveCommand,
+  UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionCommand: () => UpdateConnectionCommand,
+  UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog: () => UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog,
+  UpdateConnectionOAuthRequestParametersFilterSensitiveLog: () => UpdateConnectionOAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionRequestFilterSensitiveLog: () => UpdateConnectionRequestFilterSensitiveLog,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/CloudWatchEventsClient.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_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+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");
+
+
+// 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/CloudWatchEventsClient.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");
+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))
+  };
+  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)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/CloudWatchEventsClient.ts
+var _CloudWatchEventsClient = class _CloudWatchEventsClient 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_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_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_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_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(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(_CloudWatchEventsClient, "CloudWatchEventsClient");
+var CloudWatchEventsClient = _CloudWatchEventsClient;
+
+// src/CloudWatchEvents.ts
+
+
+// src/commands/ActivateEventSourceCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/CloudWatchEventsServiceException.ts
+
+var _CloudWatchEventsServiceException = class _CloudWatchEventsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _CloudWatchEventsServiceException.prototype);
+  }
+};
+__name(_CloudWatchEventsServiceException, "CloudWatchEventsServiceException");
+var CloudWatchEventsServiceException = _CloudWatchEventsServiceException;
+
+// src/models/models_0.ts
+
+var _ConcurrentModificationException = class _ConcurrentModificationException extends CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 CloudWatchEventsServiceException {
+  /**
+   * @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 = {
+  AUTHORIZED: "AUTHORIZED",
+  AUTHORIZING: "AUTHORIZING",
+  CREATING: "CREATING",
+  DEAUTHORIZED: "DEAUTHORIZED",
+  DEAUTHORIZING: "DEAUTHORIZING",
+  DELETING: "DELETING",
+  UPDATING: "UPDATING"
+};
+var _ManagedRuleException = class _ManagedRuleException extends CloudWatchEventsServiceException {
+  /**
+   * @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"
+};
+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 CloudWatchEventsServiceException {
+  /**
+   * @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 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 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_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_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_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_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 de_ActivateEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ActivateEventSourceCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_ActivateEventSourceCommand");
+var de_ActivateEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.cloudwatchevents#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ActivateEventSourceCommandError");
+var de_CancelReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CancelReplayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CancelReplayCommand");
+var de_CancelReplayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "IllegalStatusException":
+    case "com.amazonaws.cloudwatchevents#IllegalStatusException":
+      throw await de_IllegalStatusExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CancelReplayCommandError");
+var de_CreateApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateApiDestinationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateApiDestinationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateApiDestinationCommand");
+var de_CreateApiDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateApiDestinationCommandError");
+var de_CreateArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateArchiveCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateArchiveResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateArchiveCommand");
+var de_CreateArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidEventPatternException":
+    case "com.amazonaws.cloudwatchevents#InvalidEventPatternException":
+      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateArchiveCommandError");
+var de_CreateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateConnectionCommand");
+var de_CreateConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateConnectionCommandError");
+var de_CreateEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateEventBusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateEventBusCommand");
+var de_CreateEventBusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.cloudwatchevents#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateEventBusCommandError");
+var de_CreatePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePartnerEventSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreatePartnerEventSourceCommand");
+var de_CreatePartnerEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePartnerEventSourceCommandError");
+var de_DeactivateEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeactivateEventSourceCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeactivateEventSourceCommand");
+var de_DeactivateEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidStateException":
+    case "com.amazonaws.cloudwatchevents#InvalidStateException":
+      throw await de_InvalidStateExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeactivateEventSourceCommandError");
+var de_DeauthorizeConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeauthorizeConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeauthorizeConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeauthorizeConnectionCommand");
+var de_DeauthorizeConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeauthorizeConnectionCommandError");
+var de_DeleteApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteApiDestinationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteApiDestinationCommand");
+var de_DeleteApiDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteApiDestinationCommandError");
+var de_DeleteArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteArchiveCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteArchiveCommand");
+var de_DeleteArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteArchiveCommandError");
+var de_DeleteConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteConnectionCommand");
+var de_DeleteConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteConnectionCommandError");
+var de_DeleteEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteEventBusCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteEventBusCommand");
+var de_DeleteEventBusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteEventBusCommandError");
+var de_DeletePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeletePartnerEventSourceCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeletePartnerEventSourceCommand");
+var de_DeletePartnerEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeletePartnerEventSourceCommandError");
+var de_DeleteRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRuleCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DeleteRuleCommand");
+var de_DeleteRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRuleCommandError");
+var de_DescribeApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeApiDestinationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeApiDestinationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeApiDestinationCommand");
+var de_DescribeApiDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeApiDestinationCommandError");
+var de_DescribeArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeArchiveCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeArchiveResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeArchiveCommand");
+var de_DescribeArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeArchiveCommandError");
+var de_DescribeConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeConnectionCommand");
+var de_DescribeConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeConnectionCommandError");
+var de_DescribeEventBusCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventBusCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventBusCommand");
+var de_DescribeEventBusCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventBusCommandError");
+var de_DescribeEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventSourceResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventSourceCommand");
+var de_DescribeEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventSourceCommandError");
+var de_DescribePartnerEventSourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribePartnerEventSourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribePartnerEventSourceCommand");
+var de_DescribePartnerEventSourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribePartnerEventSourceCommandError");
+var de_DescribeReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeReplayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeReplayResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeReplayCommand");
+var de_DescribeReplayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeReplayCommandError");
+var de_DescribeRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRuleCommand");
+var de_DescribeRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRuleCommandError");
+var de_DisableRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisableRuleCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DisableRuleCommand");
+var de_DisableRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisableRuleCommandError");
+var de_EnableRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EnableRuleCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_EnableRuleCommand");
+var de_EnableRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EnableRuleCommandError");
+var de_ListApiDestinationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListApiDestinationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListApiDestinationsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListApiDestinationsCommand");
+var de_ListApiDestinationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListApiDestinationsCommandError");
+var de_ListArchivesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListArchivesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListArchivesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListArchivesCommand");
+var de_ListArchivesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListArchivesCommandError");
+var de_ListConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListConnectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListConnectionsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListConnectionsCommand");
+var de_ListConnectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListConnectionsCommandError");
+var de_ListEventBusesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListEventBusesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListEventBusesCommand");
+var de_ListEventBusesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListEventBusesCommandError");
+var de_ListEventSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListEventSourcesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListEventSourcesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListEventSourcesCommand");
+var de_ListEventSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListEventSourcesCommandError");
+var de_ListPartnerEventSourceAccountsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListPartnerEventSourceAccountsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListPartnerEventSourceAccountsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPartnerEventSourceAccountsCommand");
+var de_ListPartnerEventSourceAccountsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPartnerEventSourceAccountsCommandError");
+var de_ListPartnerEventSourcesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListPartnerEventSourcesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListPartnerEventSourcesCommand");
+var de_ListPartnerEventSourcesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListPartnerEventSourcesCommandError");
+var de_ListReplaysCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListReplaysCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListReplaysResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListReplaysCommand");
+var de_ListReplaysCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReplaysCommandError");
+var de_ListRuleNamesByTargetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListRuleNamesByTargetCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListRuleNamesByTargetCommand");
+var de_ListRuleNamesByTargetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRuleNamesByTargetCommandError");
+var de_ListRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListRulesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListRulesCommand");
+var de_ListRulesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRulesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTargetsByRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTargetsByRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTargetsByRuleCommand");
+var de_ListTargetsByRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTargetsByRuleCommandError");
+var de_PutEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutEventsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutEventsCommand");
+var de_PutEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutEventsCommandError");
+var de_PutPartnerEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutPartnerEventsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutPartnerEventsCommand");
+var de_PutPartnerEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutPartnerEventsCommandError");
+var de_PutPermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutPermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_PutPermissionCommand");
+var de_PutPermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "PolicyLengthExceededException":
+    case "com.amazonaws.cloudwatchevents#PolicyLengthExceededException":
+      throw await de_PolicyLengthExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutPermissionCommandError");
+var de_PutRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutRuleCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutRuleCommand");
+var de_PutRuleCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidEventPatternException":
+    case "com.amazonaws.cloudwatchevents#InvalidEventPatternException":
+      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutRuleCommandError");
+var de_PutTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutTargetsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_PutTargetsCommand");
+var de_PutTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutTargetsCommandError");
+var de_RemovePermissionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemovePermissionCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_RemovePermissionCommand");
+var de_RemovePermissionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "OperationDisabledException":
+    case "com.amazonaws.cloudwatchevents#OperationDisabledException":
+      throw await de_OperationDisabledExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemovePermissionCommandError");
+var de_RemoveTargetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemoveTargetsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RemoveTargetsCommand");
+var de_RemoveTargetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RemoveTargetsCommandError");
+var de_StartReplayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartReplayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartReplayResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartReplayCommand");
+var de_StartReplayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidEventPatternException":
+    case "com.amazonaws.cloudwatchevents#InvalidEventPatternException":
+      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceAlreadyExistsException":
+    case "com.amazonaws.cloudwatchevents#ResourceAlreadyExistsException":
+      throw await de_ResourceAlreadyExistsExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartReplayCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_TestEventPatternCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TestEventPatternCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TestEventPatternCommand");
+var de_TestEventPatternCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidEventPatternException":
+    case "com.amazonaws.cloudwatchevents#InvalidEventPatternException":
+      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TestEventPatternCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "ManagedRuleException":
+    case "com.amazonaws.cloudwatchevents#ManagedRuleException":
+      throw await de_ManagedRuleExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateApiDestinationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateApiDestinationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateApiDestinationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateApiDestinationCommand");
+var de_UpdateApiDestinationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateApiDestinationCommandError");
+var de_UpdateArchiveCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateArchiveCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateArchiveResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateArchiveCommand");
+var de_UpdateArchiveCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "InvalidEventPatternException":
+    case "com.amazonaws.cloudwatchevents#InvalidEventPatternException":
+      throw await de_InvalidEventPatternExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateArchiveCommandError");
+var de_UpdateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateConnectionResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateConnectionCommand");
+var de_UpdateConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.cloudwatchevents#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    case "InternalException":
+    case "com.amazonaws.cloudwatchevents#InternalException":
+      throw await de_InternalExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.cloudwatchevents#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.cloudwatchevents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateConnectionCommandError");
+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 se_PutEventsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    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: (_) => Math.round(_.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: (_) => Math.round(_.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: (_) => Math.round(_.getTime() / 1e3),
+    EventSourceArn: [],
+    EventStartTime: (_) => Math.round(_.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,
+    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_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_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_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 collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(CloudWatchEventsServiceException);
+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");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "CreateConnectionCommand").f(CreateConnectionRequestFilterSensitiveLog, void 0).ser(se_CreateConnectionCommand).de(de_CreateConnectionCommand).build() {
+};
+__name(_CreateConnectionCommand, "CreateConnectionCommand");
+var CreateConnectionCommand = _CreateConnectionCommand;
+
+// 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "DeleteConnectionCommand").f(void 0, void 0).ser(se_DeleteConnectionCommand).de(de_DeleteConnectionCommand).build() {
+};
+__name(_DeleteConnectionCommand, "DeleteConnectionCommand");
+var DeleteConnectionCommand = _DeleteConnectionCommand;
+
+// 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "DescribeConnectionCommand").f(void 0, DescribeConnectionResponseFilterSensitiveLog).ser(se_DescribeConnectionCommand).de(de_DescribeConnectionCommand).build() {
+};
+__name(_DescribeConnectionCommand, "DescribeConnectionCommand");
+var DescribeConnectionCommand = _DescribeConnectionCommand;
+
+// 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "ListConnectionsCommand").f(void 0, void 0).ser(se_ListConnectionsCommand).de(de_ListConnectionsCommand).build() {
+};
+__name(_ListConnectionsCommand, "ListConnectionsCommand");
+var ListConnectionsCommand = _ListConnectionsCommand;
+
+// 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "ListTargetsByRuleCommand").f(void 0, void 0).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
+}).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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "PutTargetsCommand").f(void 0, 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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "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("CloudWatchEventsClient", "UpdateConnectionCommand").f(UpdateConnectionRequestFilterSensitiveLog, void 0).ser(se_UpdateConnectionCommand).de(de_UpdateConnectionCommand).build() {
+};
+__name(_UpdateConnectionCommand, "UpdateConnectionCommand");
+var UpdateConnectionCommand = _UpdateConnectionCommand;
+
+// src/CloudWatchEvents.ts
+var commands = {
+  ActivateEventSourceCommand,
+  CancelReplayCommand,
+  CreateApiDestinationCommand,
+  CreateArchiveCommand,
+  CreateConnectionCommand,
+  CreateEventBusCommand,
+  CreatePartnerEventSourceCommand,
+  DeactivateEventSourceCommand,
+  DeauthorizeConnectionCommand,
+  DeleteApiDestinationCommand,
+  DeleteArchiveCommand,
+  DeleteConnectionCommand,
+  DeleteEventBusCommand,
+  DeletePartnerEventSourceCommand,
+  DeleteRuleCommand,
+  DescribeApiDestinationCommand,
+  DescribeArchiveCommand,
+  DescribeConnectionCommand,
+  DescribeEventBusCommand,
+  DescribeEventSourceCommand,
+  DescribePartnerEventSourceCommand,
+  DescribeReplayCommand,
+  DescribeRuleCommand,
+  DisableRuleCommand,
+  EnableRuleCommand,
+  ListApiDestinationsCommand,
+  ListArchivesCommand,
+  ListConnectionsCommand,
+  ListEventBusesCommand,
+  ListEventSourcesCommand,
+  ListPartnerEventSourceAccountsCommand,
+  ListPartnerEventSourcesCommand,
+  ListReplaysCommand,
+  ListRuleNamesByTargetCommand,
+  ListRulesCommand,
+  ListTagsForResourceCommand,
+  ListTargetsByRuleCommand,
+  PutEventsCommand,
+  PutPartnerEventsCommand,
+  PutPermissionCommand,
+  PutRuleCommand,
+  PutTargetsCommand,
+  RemovePermissionCommand,
+  RemoveTargetsCommand,
+  StartReplayCommand,
+  TagResourceCommand,
+  TestEventPatternCommand,
+  UntagResourceCommand,
+  UpdateApiDestinationCommand,
+  UpdateArchiveCommand,
+  UpdateConnectionCommand
+};
+var _CloudWatchEvents = class _CloudWatchEvents extends CloudWatchEventsClient {
+};
+__name(_CloudWatchEvents, "CloudWatchEvents");
+var CloudWatchEvents = _CloudWatchEvents;
+(0, import_smithy_client.createAggregatedClient)(commands, CloudWatchEvents);
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivateEventSourceCommand,
+  ApiDestinationHttpMethod,
+  ApiDestinationState,
+  ArchiveState,
+  AssignPublicIp,
+  CancelReplayCommand,
+  CloudWatchEvents,
+  CloudWatchEventsClient,
+  CloudWatchEventsServiceException,
+  ConcurrentModificationException,
+  ConnectionAuthResponseParametersFilterSensitiveLog,
+  ConnectionAuthorizationType,
+  ConnectionBodyParameterFilterSensitiveLog,
+  ConnectionHeaderParameterFilterSensitiveLog,
+  ConnectionHttpParametersFilterSensitiveLog,
+  ConnectionOAuthHttpMethod,
+  ConnectionOAuthResponseParametersFilterSensitiveLog,
+  ConnectionQueryStringParameterFilterSensitiveLog,
+  ConnectionState,
+  CreateApiDestinationCommand,
+  CreateArchiveCommand,
+  CreateConnectionApiKeyAuthRequestParametersFilterSensitiveLog,
+  CreateConnectionAuthRequestParametersFilterSensitiveLog,
+  CreateConnectionBasicAuthRequestParametersFilterSensitiveLog,
+  CreateConnectionCommand,
+  CreateConnectionOAuthClientRequestParametersFilterSensitiveLog,
+  CreateConnectionOAuthRequestParametersFilterSensitiveLog,
+  CreateConnectionRequestFilterSensitiveLog,
+  CreateEventBusCommand,
+  CreatePartnerEventSourceCommand,
+  DeactivateEventSourceCommand,
+  DeauthorizeConnectionCommand,
+  DeleteApiDestinationCommand,
+  DeleteArchiveCommand,
+  DeleteConnectionCommand,
+  DeleteEventBusCommand,
+  DeletePartnerEventSourceCommand,
+  DeleteRuleCommand,
+  DescribeApiDestinationCommand,
+  DescribeArchiveCommand,
+  DescribeConnectionCommand,
+  DescribeConnectionResponseFilterSensitiveLog,
+  DescribeEventBusCommand,
+  DescribeEventSourceCommand,
+  DescribePartnerEventSourceCommand,
+  DescribeReplayCommand,
+  DescribeRuleCommand,
+  DisableRuleCommand,
+  EnableRuleCommand,
+  EventSourceState,
+  IllegalStatusException,
+  InternalException,
+  InvalidEventPatternException,
+  InvalidStateException,
+  LaunchType,
+  LimitExceededException,
+  ListApiDestinationsCommand,
+  ListArchivesCommand,
+  ListConnectionsCommand,
+  ListEventBusesCommand,
+  ListEventSourcesCommand,
+  ListPartnerEventSourceAccountsCommand,
+  ListPartnerEventSourcesCommand,
+  ListReplaysCommand,
+  ListRuleNamesByTargetCommand,
+  ListRulesCommand,
+  ListTagsForResourceCommand,
+  ListTargetsByRuleCommand,
+  ManagedRuleException,
+  OperationDisabledException,
+  PlacementConstraintType,
+  PlacementStrategyType,
+  PolicyLengthExceededException,
+  PropagateTags,
+  PutEventsCommand,
+  PutPartnerEventsCommand,
+  PutPermissionCommand,
+  PutRuleCommand,
+  PutTargetsCommand,
+  RemovePermissionCommand,
+  RemoveTargetsCommand,
+  ReplayState,
+  ResourceAlreadyExistsException,
+  ResourceNotFoundException,
+  RuleState,
+  StartReplayCommand,
+  TagResourceCommand,
+  TestEventPatternCommand,
+  UntagResourceCommand,
+  UpdateApiDestinationCommand,
+  UpdateArchiveCommand,
+  UpdateConnectionApiKeyAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionBasicAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionCommand,
+  UpdateConnectionOAuthClientRequestParametersFilterSensitiveLog,
+  UpdateConnectionOAuthRequestParametersFilterSensitiveLog,
+  UpdateConnectionRequestFilterSensitiveLog,
+  __Client
+});