@aws-sdk/client-cloudwatch-events 3.183.0 → 3.185.0

package/dist-es/CloudWatchEvents.js

@@ -1,3 +1,4 @@
+import { __extends } from "tslib";
 import { CloudWatchEventsClient } from "./CloudWatchEventsClient";
 import { ActivateEventSourceCommand, } from "./commands/ActivateEventSourceCommand";
 import { CancelReplayCommand, } from "./commands/CancelReplayCommand";
@@ -50,719 +51,725 @@ import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateApiDestinationCommand, } from "./commands/UpdateApiDestinationCommand";
 import { UpdateArchiveCommand, } from "./commands/UpdateArchiveCommand";
 import { UpdateConnectionCommand, } from "./commands/UpdateConnectionCommand";
-export class CloudWatchEvents extends CloudWatchEventsClient {
-    activateEventSource(args, optionsOrCb, cb) {
-        const command = new ActivateEventSourceCommand(args);
+var CloudWatchEvents = (function (_super) {
+    __extends(CloudWatchEvents, _super);
+    function CloudWatchEvents() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
         }
-    }
-    createEventBus(args, optionsOrCb, cb) {
-        const command = new CreateEventBusCommand(args);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
         }
-    }
-    deleteEventBus(args, optionsOrCb, cb) {
-        const command = new DeleteEventBusCommand(args);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
         }
-    }
-    describeEventBus(args, optionsOrCb, cb) {
-        const command = new DescribeEventBusCommand(args);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
         }
-    }
-    listEventBuses(args, optionsOrCb, cb) {
-        const command = new ListEventBusesCommand(args);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
+    };
+    CloudWatchEvents.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);
         }
-    }
-}
+    };
+    return CloudWatchEvents;
+}(CloudWatchEventsClient));
+export { CloudWatchEvents };