@aws-sdk/client-eventbridge 3.183.0 → 3.185.0

package/dist-es/EventBridge.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { ActivateEventSourceCommand, } from "./commands/ActivateEventSourceCommand";
 import { CancelReplayCommand, } from "./commands/CancelReplayCommand";
 import { CreateApiDestinationCommand, } from "./commands/CreateApiDestinationCommand";
@@ -55,789 +56,795 @@ import { UpdateArchiveCommand, } from "./commands/UpdateArchiveCommand";
 import { UpdateConnectionCommand, } from "./commands/UpdateConnectionCommand";
 import { UpdateEndpointCommand, } from "./commands/UpdateEndpointCommand";
 import { EventBridgeClient } from "./EventBridgeClient";
-export class EventBridge extends EventBridgeClient {
-    activateEventSource(args, optionsOrCb, cb) {
-        const command = new ActivateEventSourceCommand(args);
+var EventBridge = (function (_super) {
+    __extends(EventBridge, _super);
+    function EventBridge() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EventBridge.prototype.activateEventSource = function (args, optionsOrCb, cb) {
+        var command = new ActivateEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    cancelReplay(args, optionsOrCb, cb) {
-        const command = new CancelReplayCommand(args);
+    };
+    EventBridge.prototype.cancelReplay = function (args, optionsOrCb, cb) {
+        var command = new CancelReplayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createApiDestination(args, optionsOrCb, cb) {
-        const command = new CreateApiDestinationCommand(args);
+    };
+    EventBridge.prototype.createApiDestination = function (args, optionsOrCb, cb) {
+        var command = new CreateApiDestinationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createArchive(args, optionsOrCb, cb) {
-        const command = new CreateArchiveCommand(args);
+    };
+    EventBridge.prototype.createArchive = function (args, optionsOrCb, cb) {
+        var command = new CreateArchiveCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createConnection(args, optionsOrCb, cb) {
-        const command = new CreateConnectionCommand(args);
+    };
+    EventBridge.prototype.createConnection = function (args, optionsOrCb, cb) {
+        var command = new CreateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEndpoint(args, optionsOrCb, cb) {
-        const command = new CreateEndpointCommand(args);
+    };
+    EventBridge.prototype.createEndpoint = function (args, optionsOrCb, cb) {
+        var command = new CreateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createEventBus(args, optionsOrCb, cb) {
-        const command = new CreateEventBusCommand(args);
+    };
+    EventBridge.prototype.createEventBus = function (args, optionsOrCb, cb) {
+        var command = new CreateEventBusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    createPartnerEventSource(args, optionsOrCb, cb) {
-        const command = new CreatePartnerEventSourceCommand(args);
+    };
+    EventBridge.prototype.createPartnerEventSource = function (args, optionsOrCb, cb) {
+        var command = new CreatePartnerEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deactivateEventSource(args, optionsOrCb, cb) {
-        const command = new DeactivateEventSourceCommand(args);
+    };
+    EventBridge.prototype.deactivateEventSource = function (args, optionsOrCb, cb) {
+        var command = new DeactivateEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deauthorizeConnection(args, optionsOrCb, cb) {
-        const command = new DeauthorizeConnectionCommand(args);
+    };
+    EventBridge.prototype.deauthorizeConnection = function (args, optionsOrCb, cb) {
+        var command = new DeauthorizeConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteApiDestination(args, optionsOrCb, cb) {
-        const command = new DeleteApiDestinationCommand(args);
+    };
+    EventBridge.prototype.deleteApiDestination = function (args, optionsOrCb, cb) {
+        var command = new DeleteApiDestinationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteArchive(args, optionsOrCb, cb) {
-        const command = new DeleteArchiveCommand(args);
+    };
+    EventBridge.prototype.deleteArchive = function (args, optionsOrCb, cb) {
+        var command = new DeleteArchiveCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteConnection(args, optionsOrCb, cb) {
-        const command = new DeleteConnectionCommand(args);
+    };
+    EventBridge.prototype.deleteConnection = function (args, optionsOrCb, cb) {
+        var command = new DeleteConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEndpoint(args, optionsOrCb, cb) {
-        const command = new DeleteEndpointCommand(args);
+    };
+    EventBridge.prototype.deleteEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DeleteEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteEventBus(args, optionsOrCb, cb) {
-        const command = new DeleteEventBusCommand(args);
+    };
+    EventBridge.prototype.deleteEventBus = function (args, optionsOrCb, cb) {
+        var command = new DeleteEventBusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deletePartnerEventSource(args, optionsOrCb, cb) {
-        const command = new DeletePartnerEventSourceCommand(args);
+    };
+    EventBridge.prototype.deletePartnerEventSource = function (args, optionsOrCb, cb) {
+        var command = new DeletePartnerEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    deleteRule(args, optionsOrCb, cb) {
-        const command = new DeleteRuleCommand(args);
+    };
+    EventBridge.prototype.deleteRule = function (args, optionsOrCb, cb) {
+        var command = new DeleteRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeApiDestination(args, optionsOrCb, cb) {
-        const command = new DescribeApiDestinationCommand(args);
+    };
+    EventBridge.prototype.describeApiDestination = function (args, optionsOrCb, cb) {
+        var command = new DescribeApiDestinationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeArchive(args, optionsOrCb, cb) {
-        const command = new DescribeArchiveCommand(args);
+    };
+    EventBridge.prototype.describeArchive = function (args, optionsOrCb, cb) {
+        var command = new DescribeArchiveCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeConnection(args, optionsOrCb, cb) {
-        const command = new DescribeConnectionCommand(args);
+    };
+    EventBridge.prototype.describeConnection = function (args, optionsOrCb, cb) {
+        var command = new DescribeConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEndpoint(args, optionsOrCb, cb) {
-        const command = new DescribeEndpointCommand(args);
+    };
+    EventBridge.prototype.describeEndpoint = function (args, optionsOrCb, cb) {
+        var command = new DescribeEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEventBus(args, optionsOrCb, cb) {
-        const command = new DescribeEventBusCommand(args);
+    };
+    EventBridge.prototype.describeEventBus = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventBusCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeEventSource(args, optionsOrCb, cb) {
-        const command = new DescribeEventSourceCommand(args);
+    };
+    EventBridge.prototype.describeEventSource = function (args, optionsOrCb, cb) {
+        var command = new DescribeEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describePartnerEventSource(args, optionsOrCb, cb) {
-        const command = new DescribePartnerEventSourceCommand(args);
+    };
+    EventBridge.prototype.describePartnerEventSource = function (args, optionsOrCb, cb) {
+        var command = new DescribePartnerEventSourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeReplay(args, optionsOrCb, cb) {
-        const command = new DescribeReplayCommand(args);
+    };
+    EventBridge.prototype.describeReplay = function (args, optionsOrCb, cb) {
+        var command = new DescribeReplayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    describeRule(args, optionsOrCb, cb) {
-        const command = new DescribeRuleCommand(args);
+    };
+    EventBridge.prototype.describeRule = function (args, optionsOrCb, cb) {
+        var command = new DescribeRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    disableRule(args, optionsOrCb, cb) {
-        const command = new DisableRuleCommand(args);
+    };
+    EventBridge.prototype.disableRule = function (args, optionsOrCb, cb) {
+        var command = new DisableRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    enableRule(args, optionsOrCb, cb) {
-        const command = new EnableRuleCommand(args);
+    };
+    EventBridge.prototype.enableRule = function (args, optionsOrCb, cb) {
+        var command = new EnableRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listApiDestinations(args, optionsOrCb, cb) {
-        const command = new ListApiDestinationsCommand(args);
+    };
+    EventBridge.prototype.listApiDestinations = function (args, optionsOrCb, cb) {
+        var command = new ListApiDestinationsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listArchives(args, optionsOrCb, cb) {
-        const command = new ListArchivesCommand(args);
+    };
+    EventBridge.prototype.listArchives = function (args, optionsOrCb, cb) {
+        var command = new ListArchivesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listConnections(args, optionsOrCb, cb) {
-        const command = new ListConnectionsCommand(args);
+    };
+    EventBridge.prototype.listConnections = function (args, optionsOrCb, cb) {
+        var command = new ListConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEndpoints(args, optionsOrCb, cb) {
-        const command = new ListEndpointsCommand(args);
+    };
+    EventBridge.prototype.listEndpoints = function (args, optionsOrCb, cb) {
+        var command = new ListEndpointsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEventBuses(args, optionsOrCb, cb) {
-        const command = new ListEventBusesCommand(args);
+    };
+    EventBridge.prototype.listEventBuses = function (args, optionsOrCb, cb) {
+        var command = new ListEventBusesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listEventSources(args, optionsOrCb, cb) {
-        const command = new ListEventSourcesCommand(args);
+    };
+    EventBridge.prototype.listEventSources = function (args, optionsOrCb, cb) {
+        var command = new ListEventSourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPartnerEventSourceAccounts(args, optionsOrCb, cb) {
-        const command = new ListPartnerEventSourceAccountsCommand(args);
+    };
+    EventBridge.prototype.listPartnerEventSourceAccounts = function (args, optionsOrCb, cb) {
+        var command = new ListPartnerEventSourceAccountsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listPartnerEventSources(args, optionsOrCb, cb) {
-        const command = new ListPartnerEventSourcesCommand(args);
+    };
+    EventBridge.prototype.listPartnerEventSources = function (args, optionsOrCb, cb) {
+        var command = new ListPartnerEventSourcesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listReplays(args, optionsOrCb, cb) {
-        const command = new ListReplaysCommand(args);
+    };
+    EventBridge.prototype.listReplays = function (args, optionsOrCb, cb) {
+        var command = new ListReplaysCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRuleNamesByTarget(args, optionsOrCb, cb) {
-        const command = new ListRuleNamesByTargetCommand(args);
+    };
+    EventBridge.prototype.listRuleNamesByTarget = function (args, optionsOrCb, cb) {
+        var command = new ListRuleNamesByTargetCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listRules(args, optionsOrCb, cb) {
-        const command = new ListRulesCommand(args);
+    };
+    EventBridge.prototype.listRules = function (args, optionsOrCb, cb) {
+        var command = new ListRulesCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTagsForResource(args, optionsOrCb, cb) {
-        const command = new ListTagsForResourceCommand(args);
+    };
+    EventBridge.prototype.listTagsForResource = function (args, optionsOrCb, cb) {
+        var command = new ListTagsForResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    listTargetsByRule(args, optionsOrCb, cb) {
-        const command = new ListTargetsByRuleCommand(args);
+    };
+    EventBridge.prototype.listTargetsByRule = function (args, optionsOrCb, cb) {
+        var command = new ListTargetsByRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putEvents(args, optionsOrCb, cb) {
-        const command = new PutEventsCommand(args);
+    };
+    EventBridge.prototype.putEvents = function (args, optionsOrCb, cb) {
+        var command = new PutEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putPartnerEvents(args, optionsOrCb, cb) {
-        const command = new PutPartnerEventsCommand(args);
+    };
+    EventBridge.prototype.putPartnerEvents = function (args, optionsOrCb, cb) {
+        var command = new PutPartnerEventsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putPermission(args, optionsOrCb, cb) {
-        const command = new PutPermissionCommand(args);
+    };
+    EventBridge.prototype.putPermission = function (args, optionsOrCb, cb) {
+        var command = new PutPermissionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putRule(args, optionsOrCb, cb) {
-        const command = new PutRuleCommand(args);
+    };
+    EventBridge.prototype.putRule = function (args, optionsOrCb, cb) {
+        var command = new PutRuleCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    putTargets(args, optionsOrCb, cb) {
-        const command = new PutTargetsCommand(args);
+    };
+    EventBridge.prototype.putTargets = function (args, optionsOrCb, cb) {
+        var command = new PutTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removePermission(args, optionsOrCb, cb) {
-        const command = new RemovePermissionCommand(args);
+    };
+    EventBridge.prototype.removePermission = function (args, optionsOrCb, cb) {
+        var command = new RemovePermissionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    removeTargets(args, optionsOrCb, cb) {
-        const command = new RemoveTargetsCommand(args);
+    };
+    EventBridge.prototype.removeTargets = function (args, optionsOrCb, cb) {
+        var command = new RemoveTargetsCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    startReplay(args, optionsOrCb, cb) {
-        const command = new StartReplayCommand(args);
+    };
+    EventBridge.prototype.startReplay = function (args, optionsOrCb, cb) {
+        var command = new StartReplayCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    tagResource(args, optionsOrCb, cb) {
-        const command = new TagResourceCommand(args);
+    };
+    EventBridge.prototype.tagResource = function (args, optionsOrCb, cb) {
+        var command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    testEventPattern(args, optionsOrCb, cb) {
-        const command = new TestEventPatternCommand(args);
+    };
+    EventBridge.prototype.testEventPattern = function (args, optionsOrCb, cb) {
+        var command = new TestEventPatternCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    untagResource(args, optionsOrCb, cb) {
-        const command = new UntagResourceCommand(args);
+    };
+    EventBridge.prototype.untagResource = function (args, optionsOrCb, cb) {
+        var command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateApiDestination(args, optionsOrCb, cb) {
-        const command = new UpdateApiDestinationCommand(args);
+    };
+    EventBridge.prototype.updateApiDestination = function (args, optionsOrCb, cb) {
+        var command = new UpdateApiDestinationCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateArchive(args, optionsOrCb, cb) {
-        const command = new UpdateArchiveCommand(args);
+    };
+    EventBridge.prototype.updateArchive = function (args, optionsOrCb, cb) {
+        var command = new UpdateArchiveCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateConnection(args, optionsOrCb, cb) {
-        const command = new UpdateConnectionCommand(args);
+    };
+    EventBridge.prototype.updateConnection = function (args, optionsOrCb, cb) {
+        var command = new UpdateConnectionCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-    updateEndpoint(args, optionsOrCb, cb) {
-        const command = new UpdateEndpointCommand(args);
+    };
+    EventBridge.prototype.updateEndpoint = function (args, optionsOrCb, cb) {
+        var command = new UpdateEndpointCommand(args);
         if (typeof optionsOrCb === "function") {
             this.send(command, optionsOrCb);
         }
         else if (typeof cb === "function") {
             if (typeof optionsOrCb !== "object")
-                throw new Error(`Expect http options but get ${typeof optionsOrCb}`);
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
             this.send(command, optionsOrCb || {}, cb);
         }
         else {
             return this.send(command, optionsOrCb);
         }
-    }
-}
+    };
+    return EventBridge;
+}(EventBridgeClient));
+export { EventBridge };