@aws-sdk/client-eventbridge 3.1068.0 → 3.1069.0

package/dist-cjs/index.js

@@ -1,18 +1,21 @@
-'use strict';
-
-var client$1 = require('@aws-sdk/core/client');
-var core = require('@smithy/core');
-var client = require('@smithy/core/client');
-var config = require('@smithy/core/config');
-var endpoints = require('@smithy/core/endpoints');
-var protocols = require('@smithy/core/protocols');
-var retry = require('@smithy/core/retry');
-var schema = require('@smithy/core/schema');
-var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var runtimeConfig = require('./runtimeConfig');
-var schemas_0 = require('./schemas/schemas_0');
-var errors = require('./models/errors');
-var EventBridgeServiceException = require('./models/EventBridgeServiceException');
+var __exportStar = (m, e) => { Object.assign(e, m); };
+const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require("@smithy/core");
+const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createAggregatedClient } = require("@smithy/core/client");
+exports.$Command = Command;
+exports.__Client = Client;
+const { resolveRegionConfig } = require("@smithy/core/config");
+const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { resolveHttpAuthSchemeConfig, defaultEventBridgeHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
+const { getRuntimeConfig } = require("./runtimeConfig");
+const { ActivateEventSource$, CancelReplay$, CreateApiDestination$, CreateArchive$, CreateConnection$, CreateEndpoint$, CreateEventBus$, CreatePartnerEventSource$, DeactivateEventSource$, DeauthorizeConnection$, DeleteApiDestination$, DeleteArchive$, DeleteConnection$, DeleteEndpoint$, DeleteEventBus$, DeletePartnerEventSource$, DeleteRule$, DescribeApiDestination$, DescribeArchive$, DescribeConnection$, DescribeEndpoint$, DescribeEventBus$, DescribeEventSource$, DescribePartnerEventSource$, DescribeReplay$, DescribeRule$, DisableRule$, EnableRule$, ListApiDestinations$, ListArchives$, ListConnections$, ListEndpoints$, ListEventBuses$, ListEventSources$, ListPartnerEventSourceAccounts$, ListPartnerEventSources$, ListReplays$, ListRuleNamesByTarget$, ListRules$, ListTagsForResource$, ListTargetsByRule$, PutEvents$, PutPartnerEvents$, PutPermission$, PutRule$, PutTargets$, RemovePermission$, RemoveTargets$, StartReplay$, TagResource$, TestEventPattern$, UntagResource$, UpdateApiDestination$, UpdateArchive$, UpdateConnection$, UpdateEndpoint$, UpdateEventBus$ } = require("./schemas/schemas_0");
+__exportStar(require("./schemas/schemas_0"), exports);
+__exportStar(require("./models/errors"), exports);
+const { EventBridgeServiceException } = require("./models/EventBridgeServiceException");
+exports.EventBridgeServiceException = EventBridgeServiceException;
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -68,731 +71,731 @@ const resolveHttpAuthRuntimeConfig = (config) => {
 };
 
 const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
-    const extensionConfiguration = Object.assign(client$1.getAwsRegionExtensionConfiguration(runtimeConfig), client.getDefaultExtensionConfiguration(runtimeConfig), protocols.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
     extensions.forEach((extension) => extension.configure(extensionConfiguration));
-    return Object.assign(runtimeConfig, client$1.resolveAwsRegionExtensionConfiguration(extensionConfiguration), client.resolveDefaultRuntimeConfig(extensionConfiguration), protocols.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+    return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
 };
 
-class EventBridgeClient extends client.Client {
+class EventBridgeClient extends Client {
     config;
     constructor(...[configuration]) {
-        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        const _config_0 = getRuntimeConfig(configuration || {});
         super(_config_0);
         this.initConfig = _config_0;
         const _config_1 = resolveClientEndpointParameters(_config_0);
-        const _config_2 = client$1.resolveUserAgentConfig(_config_1);
-        const _config_3 = retry.resolveRetryConfig(_config_2);
-        const _config_4 = config.resolveRegionConfig(_config_3);
-        const _config_5 = client$1.resolveHostHeaderConfig(_config_4);
-        const _config_6 = endpoints.resolveEndpointConfig(_config_5);
-        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveRegionConfig(_config_3);
+        const _config_5 = resolveHostHeaderConfig(_config_4);
+        const _config_6 = resolveEndpointConfig(_config_5);
+        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
-        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
-        this.middlewareStack.use(client$1.getUserAgentPlugin(this.config));
-        this.middlewareStack.use(retry.getRetryPlugin(this.config));
-        this.middlewareStack.use(protocols.getContentLengthPlugin(this.config));
-        this.middlewareStack.use(client$1.getHostHeaderPlugin(this.config));
-        this.middlewareStack.use(client$1.getLoggerPlugin(this.config));
-        this.middlewareStack.use(client$1.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
-            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultEventBridgeHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        this.middlewareStack.use(getUserAgentPlugin(this.config));
+        this.middlewareStack.use(getRetryPlugin(this.config));
+        this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultEventBridgeHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
                 "aws.auth#sigv4a": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
     }
 }
 
-class ActivateEventSourceCommand extends client.Command
+class ActivateEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ActivateEventSource", {})
     .n("EventBridgeClient", "ActivateEventSourceCommand")
-    .sc(schemas_0.ActivateEventSource$)
+    .sc(ActivateEventSource$)
     .build() {
 }
 
-class CancelReplayCommand extends client.Command
+class CancelReplayCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CancelReplay", {})
     .n("EventBridgeClient", "CancelReplayCommand")
-    .sc(schemas_0.CancelReplay$)
+    .sc(CancelReplay$)
     .build() {
 }
 
-class CreateApiDestinationCommand extends client.Command
+class CreateApiDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreateApiDestination", {})
     .n("EventBridgeClient", "CreateApiDestinationCommand")
-    .sc(schemas_0.CreateApiDestination$)
+    .sc(CreateApiDestination$)
     .build() {
 }
 
-class CreateArchiveCommand extends client.Command
+class CreateArchiveCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreateArchive", {})
     .n("EventBridgeClient", "CreateArchiveCommand")
-    .sc(schemas_0.CreateArchive$)
+    .sc(CreateArchive$)
     .build() {
 }
 
-class CreateConnectionCommand extends client.Command
+class CreateConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreateConnection", {})
     .n("EventBridgeClient", "CreateConnectionCommand")
-    .sc(schemas_0.CreateConnection$)
+    .sc(CreateConnection$)
     .build() {
 }
 
-class CreateEndpointCommand extends client.Command
+class CreateEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreateEndpoint", {})
     .n("EventBridgeClient", "CreateEndpointCommand")
-    .sc(schemas_0.CreateEndpoint$)
+    .sc(CreateEndpoint$)
     .build() {
 }
 
-class CreateEventBusCommand extends client.Command
+class CreateEventBusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreateEventBus", {})
     .n("EventBridgeClient", "CreateEventBusCommand")
-    .sc(schemas_0.CreateEventBus$)
+    .sc(CreateEventBus$)
     .build() {
 }
 
-class CreatePartnerEventSourceCommand extends client.Command
+class CreatePartnerEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "CreatePartnerEventSource", {})
     .n("EventBridgeClient", "CreatePartnerEventSourceCommand")
-    .sc(schemas_0.CreatePartnerEventSource$)
+    .sc(CreatePartnerEventSource$)
     .build() {
 }
 
-class DeactivateEventSourceCommand extends client.Command
+class DeactivateEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeactivateEventSource", {})
     .n("EventBridgeClient", "DeactivateEventSourceCommand")
-    .sc(schemas_0.DeactivateEventSource$)
+    .sc(DeactivateEventSource$)
     .build() {
 }
 
-class DeauthorizeConnectionCommand extends client.Command
+class DeauthorizeConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeauthorizeConnection", {})
     .n("EventBridgeClient", "DeauthorizeConnectionCommand")
-    .sc(schemas_0.DeauthorizeConnection$)
+    .sc(DeauthorizeConnection$)
     .build() {
 }
 
-class DeleteApiDestinationCommand extends client.Command
+class DeleteApiDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteApiDestination", {})
     .n("EventBridgeClient", "DeleteApiDestinationCommand")
-    .sc(schemas_0.DeleteApiDestination$)
+    .sc(DeleteApiDestination$)
     .build() {
 }
 
-class DeleteArchiveCommand extends client.Command
+class DeleteArchiveCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteArchive", {})
     .n("EventBridgeClient", "DeleteArchiveCommand")
-    .sc(schemas_0.DeleteArchive$)
+    .sc(DeleteArchive$)
     .build() {
 }
 
-class DeleteConnectionCommand extends client.Command
+class DeleteConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteConnection", {})
     .n("EventBridgeClient", "DeleteConnectionCommand")
-    .sc(schemas_0.DeleteConnection$)
+    .sc(DeleteConnection$)
     .build() {
 }
 
-class DeleteEndpointCommand extends client.Command
+class DeleteEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteEndpoint", {})
     .n("EventBridgeClient", "DeleteEndpointCommand")
-    .sc(schemas_0.DeleteEndpoint$)
+    .sc(DeleteEndpoint$)
     .build() {
 }
 
-class DeleteEventBusCommand extends client.Command
+class DeleteEventBusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteEventBus", {})
     .n("EventBridgeClient", "DeleteEventBusCommand")
-    .sc(schemas_0.DeleteEventBus$)
+    .sc(DeleteEventBus$)
     .build() {
 }
 
-class DeletePartnerEventSourceCommand extends client.Command
+class DeletePartnerEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeletePartnerEventSource", {})
     .n("EventBridgeClient", "DeletePartnerEventSourceCommand")
-    .sc(schemas_0.DeletePartnerEventSource$)
+    .sc(DeletePartnerEventSource$)
     .build() {
 }
 
-class DeleteRuleCommand extends client.Command
+class DeleteRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DeleteRule", {})
     .n("EventBridgeClient", "DeleteRuleCommand")
-    .sc(schemas_0.DeleteRule$)
+    .sc(DeleteRule$)
     .build() {
 }
 
-class DescribeApiDestinationCommand extends client.Command
+class DescribeApiDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeApiDestination", {})
     .n("EventBridgeClient", "DescribeApiDestinationCommand")
-    .sc(schemas_0.DescribeApiDestination$)
+    .sc(DescribeApiDestination$)
     .build() {
 }
 
-class DescribeArchiveCommand extends client.Command
+class DescribeArchiveCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeArchive", {})
     .n("EventBridgeClient", "DescribeArchiveCommand")
-    .sc(schemas_0.DescribeArchive$)
+    .sc(DescribeArchive$)
     .build() {
 }
 
-class DescribeConnectionCommand extends client.Command
+class DescribeConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeConnection", {})
     .n("EventBridgeClient", "DescribeConnectionCommand")
-    .sc(schemas_0.DescribeConnection$)
+    .sc(DescribeConnection$)
     .build() {
 }
 
-class DescribeEndpointCommand extends client.Command
+class DescribeEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeEndpoint", {})
     .n("EventBridgeClient", "DescribeEndpointCommand")
-    .sc(schemas_0.DescribeEndpoint$)
+    .sc(DescribeEndpoint$)
     .build() {
 }
 
-class DescribeEventBusCommand extends client.Command
+class DescribeEventBusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeEventBus", {})
     .n("EventBridgeClient", "DescribeEventBusCommand")
-    .sc(schemas_0.DescribeEventBus$)
+    .sc(DescribeEventBus$)
     .build() {
 }
 
-class DescribeEventSourceCommand extends client.Command
+class DescribeEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeEventSource", {})
     .n("EventBridgeClient", "DescribeEventSourceCommand")
-    .sc(schemas_0.DescribeEventSource$)
+    .sc(DescribeEventSource$)
     .build() {
 }
 
-class DescribePartnerEventSourceCommand extends client.Command
+class DescribePartnerEventSourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribePartnerEventSource", {})
     .n("EventBridgeClient", "DescribePartnerEventSourceCommand")
-    .sc(schemas_0.DescribePartnerEventSource$)
+    .sc(DescribePartnerEventSource$)
     .build() {
 }
 
-class DescribeReplayCommand extends client.Command
+class DescribeReplayCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeReplay", {})
     .n("EventBridgeClient", "DescribeReplayCommand")
-    .sc(schemas_0.DescribeReplay$)
+    .sc(DescribeReplay$)
     .build() {
 }
 
-class DescribeRuleCommand extends client.Command
+class DescribeRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DescribeRule", {})
     .n("EventBridgeClient", "DescribeRuleCommand")
-    .sc(schemas_0.DescribeRule$)
+    .sc(DescribeRule$)
     .build() {
 }
 
-class DisableRuleCommand extends client.Command
+class DisableRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "DisableRule", {})
     .n("EventBridgeClient", "DisableRuleCommand")
-    .sc(schemas_0.DisableRule$)
+    .sc(DisableRule$)
     .build() {
 }
 
-class EnableRuleCommand extends client.Command
+class EnableRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "EnableRule", {})
     .n("EventBridgeClient", "EnableRuleCommand")
-    .sc(schemas_0.EnableRule$)
+    .sc(EnableRule$)
     .build() {
 }
 
-class ListApiDestinationsCommand extends client.Command
+class ListApiDestinationsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListApiDestinations", {})
     .n("EventBridgeClient", "ListApiDestinationsCommand")
-    .sc(schemas_0.ListApiDestinations$)
+    .sc(ListApiDestinations$)
     .build() {
 }
 
-class ListArchivesCommand extends client.Command
+class ListArchivesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListArchives", {})
     .n("EventBridgeClient", "ListArchivesCommand")
-    .sc(schemas_0.ListArchives$)
+    .sc(ListArchives$)
     .build() {
 }
 
-class ListConnectionsCommand extends client.Command
+class ListConnectionsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListConnections", {})
     .n("EventBridgeClient", "ListConnectionsCommand")
-    .sc(schemas_0.ListConnections$)
+    .sc(ListConnections$)
     .build() {
 }
 
-class ListEndpointsCommand extends client.Command
+class ListEndpointsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListEndpoints", {})
     .n("EventBridgeClient", "ListEndpointsCommand")
-    .sc(schemas_0.ListEndpoints$)
+    .sc(ListEndpoints$)
     .build() {
 }
 
-class ListEventBusesCommand extends client.Command
+class ListEventBusesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListEventBuses", {})
     .n("EventBridgeClient", "ListEventBusesCommand")
-    .sc(schemas_0.ListEventBuses$)
+    .sc(ListEventBuses$)
     .build() {
 }
 
-class ListEventSourcesCommand extends client.Command
+class ListEventSourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListEventSources", {})
     .n("EventBridgeClient", "ListEventSourcesCommand")
-    .sc(schemas_0.ListEventSources$)
+    .sc(ListEventSources$)
     .build() {
 }
 
-class ListPartnerEventSourceAccountsCommand extends client.Command
+class ListPartnerEventSourceAccountsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListPartnerEventSourceAccounts", {})
     .n("EventBridgeClient", "ListPartnerEventSourceAccountsCommand")
-    .sc(schemas_0.ListPartnerEventSourceAccounts$)
+    .sc(ListPartnerEventSourceAccounts$)
     .build() {
 }
 
-class ListPartnerEventSourcesCommand extends client.Command
+class ListPartnerEventSourcesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListPartnerEventSources", {})
     .n("EventBridgeClient", "ListPartnerEventSourcesCommand")
-    .sc(schemas_0.ListPartnerEventSources$)
+    .sc(ListPartnerEventSources$)
     .build() {
 }
 
-class ListReplaysCommand extends client.Command
+class ListReplaysCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListReplays", {})
     .n("EventBridgeClient", "ListReplaysCommand")
-    .sc(schemas_0.ListReplays$)
+    .sc(ListReplays$)
     .build() {
 }
 
-class ListRuleNamesByTargetCommand extends client.Command
+class ListRuleNamesByTargetCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListRuleNamesByTarget", {})
     .n("EventBridgeClient", "ListRuleNamesByTargetCommand")
-    .sc(schemas_0.ListRuleNamesByTarget$)
+    .sc(ListRuleNamesByTarget$)
     .build() {
 }
 
-class ListRulesCommand extends client.Command
+class ListRulesCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListRules", {})
     .n("EventBridgeClient", "ListRulesCommand")
-    .sc(schemas_0.ListRules$)
+    .sc(ListRules$)
     .build() {
 }
 
-class ListTagsForResourceCommand extends client.Command
+class ListTagsForResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListTagsForResource", {})
     .n("EventBridgeClient", "ListTagsForResourceCommand")
-    .sc(schemas_0.ListTagsForResource$)
+    .sc(ListTagsForResource$)
     .build() {
 }
 
-class ListTargetsByRuleCommand extends client.Command
+class ListTargetsByRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "ListTargetsByRule", {})
     .n("EventBridgeClient", "ListTargetsByRuleCommand")
-    .sc(schemas_0.ListTargetsByRule$)
+    .sc(ListTargetsByRule$)
     .build() {
 }
 
-class PutEventsCommand extends client.Command
+class PutEventsCommand extends Command
     .classBuilder()
     .ep({
     ...commonParams,
     EndpointId: { type: "contextParams", name: "EndpointId" },
 })
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "PutEvents", {})
     .n("EventBridgeClient", "PutEventsCommand")
-    .sc(schemas_0.PutEvents$)
+    .sc(PutEvents$)
     .build() {
 }
 
-class PutPartnerEventsCommand extends client.Command
+class PutPartnerEventsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "PutPartnerEvents", {})
     .n("EventBridgeClient", "PutPartnerEventsCommand")
-    .sc(schemas_0.PutPartnerEvents$)
+    .sc(PutPartnerEvents$)
     .build() {
 }
 
-class PutPermissionCommand extends client.Command
+class PutPermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "PutPermission", {})
     .n("EventBridgeClient", "PutPermissionCommand")
-    .sc(schemas_0.PutPermission$)
+    .sc(PutPermission$)
     .build() {
 }
 
-class PutRuleCommand extends client.Command
+class PutRuleCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "PutRule", {})
     .n("EventBridgeClient", "PutRuleCommand")
-    .sc(schemas_0.PutRule$)
+    .sc(PutRule$)
     .build() {
 }
 
-class PutTargetsCommand extends client.Command
+class PutTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "PutTargets", {})
     .n("EventBridgeClient", "PutTargetsCommand")
-    .sc(schemas_0.PutTargets$)
+    .sc(PutTargets$)
     .build() {
 }
 
-class RemovePermissionCommand extends client.Command
+class RemovePermissionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "RemovePermission", {})
     .n("EventBridgeClient", "RemovePermissionCommand")
-    .sc(schemas_0.RemovePermission$)
+    .sc(RemovePermission$)
     .build() {
 }
 
-class RemoveTargetsCommand extends client.Command
+class RemoveTargetsCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "RemoveTargets", {})
     .n("EventBridgeClient", "RemoveTargetsCommand")
-    .sc(schemas_0.RemoveTargets$)
+    .sc(RemoveTargets$)
     .build() {
 }
 
-class StartReplayCommand extends client.Command
+class StartReplayCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "StartReplay", {})
     .n("EventBridgeClient", "StartReplayCommand")
-    .sc(schemas_0.StartReplay$)
+    .sc(StartReplay$)
     .build() {
 }
 
-class TagResourceCommand extends client.Command
+class TagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "TagResource", {})
     .n("EventBridgeClient", "TagResourceCommand")
-    .sc(schemas_0.TagResource$)
+    .sc(TagResource$)
     .build() {
 }
 
-class TestEventPatternCommand extends client.Command
+class TestEventPatternCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "TestEventPattern", {})
     .n("EventBridgeClient", "TestEventPatternCommand")
-    .sc(schemas_0.TestEventPattern$)
+    .sc(TestEventPattern$)
     .build() {
 }
 
-class UntagResourceCommand extends client.Command
+class UntagResourceCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UntagResource", {})
     .n("EventBridgeClient", "UntagResourceCommand")
-    .sc(schemas_0.UntagResource$)
+    .sc(UntagResource$)
     .build() {
 }
 
-class UpdateApiDestinationCommand extends client.Command
+class UpdateApiDestinationCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UpdateApiDestination", {})
     .n("EventBridgeClient", "UpdateApiDestinationCommand")
-    .sc(schemas_0.UpdateApiDestination$)
+    .sc(UpdateApiDestination$)
     .build() {
 }
 
-class UpdateArchiveCommand extends client.Command
+class UpdateArchiveCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UpdateArchive", {})
     .n("EventBridgeClient", "UpdateArchiveCommand")
-    .sc(schemas_0.UpdateArchive$)
+    .sc(UpdateArchive$)
     .build() {
 }
 
-class UpdateConnectionCommand extends client.Command
+class UpdateConnectionCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UpdateConnection", {})
     .n("EventBridgeClient", "UpdateConnectionCommand")
-    .sc(schemas_0.UpdateConnection$)
+    .sc(UpdateConnection$)
     .build() {
 }
 
-class UpdateEndpointCommand extends client.Command
+class UpdateEndpointCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UpdateEndpoint", {})
     .n("EventBridgeClient", "UpdateEndpointCommand")
-    .sc(schemas_0.UpdateEndpoint$)
+    .sc(UpdateEndpoint$)
     .build() {
 }
 
-class UpdateEventBusCommand extends client.Command
+class UpdateEventBusCommand extends Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [endpoints.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("AWSEvents", "UpdateEventBus", {})
     .n("EventBridgeClient", "UpdateEventBusCommand")
-    .sc(schemas_0.UpdateEventBus$)
+    .sc(UpdateEventBus$)
     .build() {
 }
 
@@ -857,7 +860,7 @@ const commands = {
 };
 class EventBridge extends EventBridgeClient {
 }
-client.createAggregatedClient(commands, EventBridge);
+createAggregatedClient(commands, EventBridge);
 
 const ApiDestinationState = {
     ACTIVE: "ACTIVE",
@@ -964,9 +967,6 @@ const PropagateTags = {
     TASK_DEFINITION: "TASK_DEFINITION",
 };
 
-exports.$Command = client.Command;
-exports.__Client = client.Client;
-exports.EventBridgeServiceException = EventBridgeServiceException.EventBridgeServiceException;
 exports.ActivateEventSourceCommand = ActivateEventSourceCommand;
 exports.ApiDestinationHttpMethod = ApiDestinationHttpMethod;
 exports.ApiDestinationState = ApiDestinationState;
@@ -1044,23 +1044,3 @@ exports.UpdateArchiveCommand = UpdateArchiveCommand;
 exports.UpdateConnectionCommand = UpdateConnectionCommand;
 exports.UpdateEndpointCommand = UpdateEndpointCommand;
 exports.UpdateEventBusCommand = UpdateEventBusCommand;
-Object.prototype.hasOwnProperty.call(schemas_0, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: schemas_0['__proto__']
-    });
-
-Object.keys(schemas_0).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = schemas_0[k];
-});
-Object.prototype.hasOwnProperty.call(errors, '__proto__') &&
-    !Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-    Object.defineProperty(exports, '__proto__', {
-        enumerable: true,
-        value: errors['__proto__']
-    });
-
-Object.keys(errors).forEach(function (k) {
-    if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = errors[k];
-});