@aws-sdk/client-eventbridge 3.183.0 → 3.185.0

package/dist-es/commands/DeauthorizeConnectionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeauthorizeConnectionRequestFilterSensitiveLog, DeauthorizeConnectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeauthorizeConnectionCommand, serializeAws_json1_1DeauthorizeConnectionCommand, } from "../protocols/Aws_json1_1";
-export class DeauthorizeConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeauthorizeConnectionCommand = (function (_super) {
+    __extends(DeauthorizeConnectionCommand, _super);
+    function DeauthorizeConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeauthorizeConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeauthorizeConnectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeauthorizeConnectionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeauthorizeConnectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeauthorizeConnectionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeauthorizeConnectionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeauthorizeConnectionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeauthorizeConnectionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeauthorizeConnectionCommand(output, context);
-    }
-}
+    };
+    return DeauthorizeConnectionCommand;
+}($Command));
+export { DeauthorizeConnectionCommand };

package/dist-es/commands/DeleteApiDestinationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteApiDestinationRequestFilterSensitiveLog, DeleteApiDestinationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteApiDestinationCommand, serializeAws_json1_1DeleteApiDestinationCommand, } from "../protocols/Aws_json1_1";
-export class DeleteApiDestinationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteApiDestinationCommand = (function (_super) {
+    __extends(DeleteApiDestinationCommand, _super);
+    function DeleteApiDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteApiDestinationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteApiDestinationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteApiDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteApiDestinationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteApiDestinationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteApiDestinationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteApiDestinationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteApiDestinationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteApiDestinationCommand(output, context);
-    }
-}
+    };
+    return DeleteApiDestinationCommand;
+}($Command));
+export { DeleteApiDestinationCommand };

package/dist-es/commands/DeleteArchiveCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteArchiveRequestFilterSensitiveLog, DeleteArchiveResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteArchiveCommand, serializeAws_json1_1DeleteArchiveCommand, } from "../protocols/Aws_json1_1";
-export class DeleteArchiveCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteArchiveCommand = (function (_super) {
+    __extends(DeleteArchiveCommand, _super);
+    function DeleteArchiveCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteArchiveCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteArchiveCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteArchiveCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteArchiveRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteArchiveResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteArchiveCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteArchiveCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteArchiveCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteArchiveCommand(output, context);
-    }
-}
+    };
+    return DeleteArchiveCommand;
+}($Command));
+export { DeleteArchiveCommand };

package/dist-es/commands/DeleteConnectionCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteConnectionRequestFilterSensitiveLog, DeleteConnectionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteConnectionCommand, serializeAws_json1_1DeleteConnectionCommand, } from "../protocols/Aws_json1_1";
-export class DeleteConnectionCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteConnectionCommand = (function (_super) {
+    __extends(DeleteConnectionCommand, _super);
+    function DeleteConnectionCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteConnectionCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteConnectionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteConnectionCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteConnectionRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteConnectionResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteConnectionCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteConnectionCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteConnectionCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteConnectionCommand(output, context);
-    }
-}
+    };
+    return DeleteConnectionCommand;
+}($Command));
+export { DeleteConnectionCommand };

package/dist-es/commands/DeleteEndpointCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEndpointRequestFilterSensitiveLog, DeleteEndpointResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DeleteEndpointCommand, serializeAws_json1_1DeleteEndpointCommand, } from "../protocols/Aws_json1_1";
-export class DeleteEndpointCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEndpointCommand = (function (_super) {
+    __extends(DeleteEndpointCommand, _super);
+    function DeleteEndpointCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEndpointCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteEndpointCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteEndpointCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteEndpointRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DeleteEndpointResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEndpointCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteEndpointCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEndpointCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteEndpointCommand(output, context);
-    }
-}
+    };
+    return DeleteEndpointCommand;
+}($Command));
+export { DeleteEndpointCommand };

package/dist-es/commands/DeleteEventBusCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteEventBusRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_1DeleteEventBusCommand, serializeAws_json1_1DeleteEventBusCommand, } from "../protocols/Aws_json1_1";
-export class DeleteEventBusCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteEventBusCommand = (function (_super) {
+    __extends(DeleteEventBusCommand, _super);
+    function DeleteEventBusCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteEventBusCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteEventBusCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteEventBusCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteEventBusRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteEventBusCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteEventBusCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteEventBusCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteEventBusCommand(output, context);
-    }
-}
+    };
+    return DeleteEventBusCommand;
+}($Command));
+export { DeleteEventBusCommand };

package/dist-es/commands/DeletePartnerEventSourceCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeletePartnerEventSourceRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_1DeletePartnerEventSourceCommand, serializeAws_json1_1DeletePartnerEventSourceCommand, } from "../protocols/Aws_json1_1";
-export class DeletePartnerEventSourceCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeletePartnerEventSourceCommand = (function (_super) {
+    __extends(DeletePartnerEventSourceCommand, _super);
+    function DeletePartnerEventSourceCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeletePartnerEventSourceCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeletePartnerEventSourceCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeletePartnerEventSourceCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeletePartnerEventSourceRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeletePartnerEventSourceCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeletePartnerEventSourceCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeletePartnerEventSourceCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeletePartnerEventSourceCommand(output, context);
-    }
-}
+    };
+    return DeletePartnerEventSourceCommand;
+}($Command));
+export { DeletePartnerEventSourceCommand };

package/dist-es/commands/DeleteRuleCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DeleteRuleRequestFilterSensitiveLog } from "../models/models_0";
 import { deserializeAws_json1_1DeleteRuleCommand, serializeAws_json1_1DeleteRuleCommand, } from "../protocols/Aws_json1_1";
-export class DeleteRuleCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DeleteRuleCommand = (function (_super) {
+    __extends(DeleteRuleCommand, _super);
+    function DeleteRuleCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DeleteRuleCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DeleteRuleCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DeleteRuleCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DeleteRuleRequestFilterSensitiveLog,
-            outputFilterSensitiveLog: (output) => output,
+            outputFilterSensitiveLog: function (output) { return output; },
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteRuleCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DeleteRuleCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DeleteRuleCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DeleteRuleCommand(output, context);
-    }
-}
+    };
+    return DeleteRuleCommand;
+}($Command));
+export { DeleteRuleCommand };

package/dist-es/commands/DescribeApiDestinationCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeApiDestinationRequestFilterSensitiveLog, DescribeApiDestinationResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeApiDestinationCommand, serializeAws_json1_1DescribeApiDestinationCommand, } from "../protocols/Aws_json1_1";
-export class DescribeApiDestinationCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeApiDestinationCommand = (function (_super) {
+    __extends(DescribeApiDestinationCommand, _super);
+    function DescribeApiDestinationCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeApiDestinationCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DescribeApiDestinationCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DescribeApiDestinationCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeApiDestinationRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeApiDestinationResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeApiDestinationCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeApiDestinationCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeApiDestinationCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeApiDestinationCommand(output, context);
-    }
-}
+    };
+    return DescribeApiDestinationCommand;
+}($Command));
+export { DescribeApiDestinationCommand };

package/dist-es/commands/DescribeArchiveCommand.js

@@ -1,32 +1,39 @@
+import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { DescribeArchiveRequestFilterSensitiveLog, DescribeArchiveResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_json1_1DescribeArchiveCommand, serializeAws_json1_1DescribeArchiveCommand, } from "../protocols/Aws_json1_1";
-export class DescribeArchiveCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var DescribeArchiveCommand = (function (_super) {
+    __extends(DescribeArchiveCommand, _super);
+    function DescribeArchiveCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    DescribeArchiveCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
         this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "EventBridgeClient";
-        const commandName = "DescribeArchiveCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "EventBridgeClient";
+        var commandName = "DescribeArchiveCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: DescribeArchiveRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DescribeArchiveResponseFilterSensitiveLog,
         };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeArchiveCommand.prototype.serialize = function (input, context) {
         return serializeAws_json1_1DescribeArchiveCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    DescribeArchiveCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_json1_1DescribeArchiveCommand(output, context);
-    }
-}
+    };
+    return DescribeArchiveCommand;
+}($Command));
+export { DescribeArchiveCommand };