@aws-sdk/client-api-gateway 3.183.0 → 3.185.0

package/dist-es/commands/GetUsagePlanCommand.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 { GetUsagePlanRequestFilterSensitiveLog, UsagePlanFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetUsagePlanCommand, serializeAws_restJson1GetUsagePlanCommand, } from "../protocols/Aws_restJson1";
-export class GetUsagePlanCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetUsagePlanCommand = (function (_super) {
+    __extends(GetUsagePlanCommand, _super);
+    function GetUsagePlanCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetUsagePlanCommand.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 = "APIGatewayClient";
-        const commandName = "GetUsagePlanCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetUsagePlanCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetUsagePlanRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsagePlanFilterSensitiveLog,
         };
-        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);
+    };
+    GetUsagePlanCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetUsagePlanCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetUsagePlanCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetUsagePlanCommand(output, context);
-    }
-}
+    };
+    return GetUsagePlanCommand;
+}($Command));
+export { GetUsagePlanCommand };

package/dist-es/commands/GetUsagePlanKeyCommand.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 { GetUsagePlanKeyRequestFilterSensitiveLog, UsagePlanKeyFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetUsagePlanKeyCommand, serializeAws_restJson1GetUsagePlanKeyCommand, } from "../protocols/Aws_restJson1";
-export class GetUsagePlanKeyCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetUsagePlanKeyCommand = (function (_super) {
+    __extends(GetUsagePlanKeyCommand, _super);
+    function GetUsagePlanKeyCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetUsagePlanKeyCommand.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 = "APIGatewayClient";
-        const commandName = "GetUsagePlanKeyCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetUsagePlanKeyCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetUsagePlanKeyRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsagePlanKeyFilterSensitiveLog,
         };
-        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);
+    };
+    GetUsagePlanKeyCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetUsagePlanKeyCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetUsagePlanKeyCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetUsagePlanKeyCommand(output, context);
-    }
-}
+    };
+    return GetUsagePlanKeyCommand;
+}($Command));
+export { GetUsagePlanKeyCommand };

package/dist-es/commands/GetUsagePlanKeysCommand.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 { GetUsagePlanKeysRequestFilterSensitiveLog, UsagePlanKeysFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetUsagePlanKeysCommand, serializeAws_restJson1GetUsagePlanKeysCommand, } from "../protocols/Aws_restJson1";
-export class GetUsagePlanKeysCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetUsagePlanKeysCommand = (function (_super) {
+    __extends(GetUsagePlanKeysCommand, _super);
+    function GetUsagePlanKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetUsagePlanKeysCommand.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 = "APIGatewayClient";
-        const commandName = "GetUsagePlanKeysCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetUsagePlanKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetUsagePlanKeysRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsagePlanKeysFilterSensitiveLog,
         };
-        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);
+    };
+    GetUsagePlanKeysCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetUsagePlanKeysCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetUsagePlanKeysCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetUsagePlanKeysCommand(output, context);
-    }
-}
+    };
+    return GetUsagePlanKeysCommand;
+}($Command));
+export { GetUsagePlanKeysCommand };

package/dist-es/commands/GetUsagePlansCommand.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 { GetUsagePlansRequestFilterSensitiveLog, UsagePlansFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetUsagePlansCommand, serializeAws_restJson1GetUsagePlansCommand, } from "../protocols/Aws_restJson1";
-export class GetUsagePlansCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetUsagePlansCommand = (function (_super) {
+    __extends(GetUsagePlansCommand, _super);
+    function GetUsagePlansCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetUsagePlansCommand.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 = "APIGatewayClient";
-        const commandName = "GetUsagePlansCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetUsagePlansCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetUsagePlansRequestFilterSensitiveLog,
             outputFilterSensitiveLog: UsagePlansFilterSensitiveLog,
         };
-        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);
+    };
+    GetUsagePlansCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetUsagePlansCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetUsagePlansCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetUsagePlansCommand(output, context);
-    }
-}
+    };
+    return GetUsagePlansCommand;
+}($Command));
+export { GetUsagePlansCommand };

package/dist-es/commands/GetVpcLinkCommand.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 { GetVpcLinkRequestFilterSensitiveLog, VpcLinkFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetVpcLinkCommand, serializeAws_restJson1GetVpcLinkCommand, } from "../protocols/Aws_restJson1";
-export class GetVpcLinkCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVpcLinkCommand = (function (_super) {
+    __extends(GetVpcLinkCommand, _super);
+    function GetVpcLinkCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVpcLinkCommand.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 = "APIGatewayClient";
-        const commandName = "GetVpcLinkCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetVpcLinkCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVpcLinkRequestFilterSensitiveLog,
             outputFilterSensitiveLog: VpcLinkFilterSensitiveLog,
         };
-        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);
+    };
+    GetVpcLinkCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVpcLinkCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVpcLinkCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVpcLinkCommand(output, context);
-    }
-}
+    };
+    return GetVpcLinkCommand;
+}($Command));
+export { GetVpcLinkCommand };

package/dist-es/commands/GetVpcLinksCommand.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 { GetVpcLinksRequestFilterSensitiveLog, VpcLinksFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1GetVpcLinksCommand, serializeAws_restJson1GetVpcLinksCommand, } from "../protocols/Aws_restJson1";
-export class GetVpcLinksCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var GetVpcLinksCommand = (function (_super) {
+    __extends(GetVpcLinksCommand, _super);
+    function GetVpcLinksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    GetVpcLinksCommand.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 = "APIGatewayClient";
-        const commandName = "GetVpcLinksCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "GetVpcLinksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: GetVpcLinksRequestFilterSensitiveLog,
             outputFilterSensitiveLog: VpcLinksFilterSensitiveLog,
         };
-        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);
+    };
+    GetVpcLinksCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1GetVpcLinksCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    GetVpcLinksCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1GetVpcLinksCommand(output, context);
-    }
-}
+    };
+    return GetVpcLinksCommand;
+}($Command));
+export { GetVpcLinksCommand };

package/dist-es/commands/ImportApiKeysCommand.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 { ApiKeyIdsFilterSensitiveLog, ImportApiKeysRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ImportApiKeysCommand, serializeAws_restJson1ImportApiKeysCommand, } from "../protocols/Aws_restJson1";
-export class ImportApiKeysCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportApiKeysCommand = (function (_super) {
+    __extends(ImportApiKeysCommand, _super);
+    function ImportApiKeysCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportApiKeysCommand.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 = "APIGatewayClient";
-        const commandName = "ImportApiKeysCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "ImportApiKeysCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportApiKeysRequestFilterSensitiveLog,
             outputFilterSensitiveLog: ApiKeyIdsFilterSensitiveLog,
         };
-        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);
+    };
+    ImportApiKeysCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ImportApiKeysCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportApiKeysCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ImportApiKeysCommand(output, context);
-    }
-}
+    };
+    return ImportApiKeysCommand;
+}($Command));
+export { ImportApiKeysCommand };

package/dist-es/commands/ImportDocumentationPartsCommand.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 { DocumentationPartIdsFilterSensitiveLog, ImportDocumentationPartsRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ImportDocumentationPartsCommand, serializeAws_restJson1ImportDocumentationPartsCommand, } from "../protocols/Aws_restJson1";
-export class ImportDocumentationPartsCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportDocumentationPartsCommand = (function (_super) {
+    __extends(ImportDocumentationPartsCommand, _super);
+    function ImportDocumentationPartsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportDocumentationPartsCommand.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 = "APIGatewayClient";
-        const commandName = "ImportDocumentationPartsCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "ImportDocumentationPartsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportDocumentationPartsRequestFilterSensitiveLog,
             outputFilterSensitiveLog: DocumentationPartIdsFilterSensitiveLog,
         };
-        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);
+    };
+    ImportDocumentationPartsCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ImportDocumentationPartsCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportDocumentationPartsCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ImportDocumentationPartsCommand(output, context);
-    }
-}
+    };
+    return ImportDocumentationPartsCommand;
+}($Command));
+export { ImportDocumentationPartsCommand };

package/dist-es/commands/ImportRestApiCommand.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 { ImportRestApiRequestFilterSensitiveLog, RestApiFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ImportRestApiCommand, serializeAws_restJson1ImportRestApiCommand, } from "../protocols/Aws_restJson1";
-export class ImportRestApiCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var ImportRestApiCommand = (function (_super) {
+    __extends(ImportRestApiCommand, _super);
+    function ImportRestApiCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    ImportRestApiCommand.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 = "APIGatewayClient";
-        const commandName = "ImportRestApiCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "ImportRestApiCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: ImportRestApiRequestFilterSensitiveLog,
             outputFilterSensitiveLog: RestApiFilterSensitiveLog,
         };
-        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);
+    };
+    ImportRestApiCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1ImportRestApiCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    ImportRestApiCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1ImportRestApiCommand(output, context);
-    }
-}
+    };
+    return ImportRestApiCommand;
+}($Command));
+export { ImportRestApiCommand };

package/dist-es/commands/PutGatewayResponseCommand.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 { GatewayResponseFilterSensitiveLog, PutGatewayResponseRequestFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1PutGatewayResponseCommand, serializeAws_restJson1PutGatewayResponseCommand, } from "../protocols/Aws_restJson1";
-export class PutGatewayResponseCommand extends $Command {
-    constructor(input) {
-        super();
-        this.input = input;
+var PutGatewayResponseCommand = (function (_super) {
+    __extends(PutGatewayResponseCommand, _super);
+    function PutGatewayResponseCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
     }
-    resolveMiddleware(clientStack, configuration, options) {
+    PutGatewayResponseCommand.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 = "APIGatewayClient";
-        const commandName = "PutGatewayResponseCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "APIGatewayClient";
+        var commandName = "PutGatewayResponseCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
             inputFilterSensitiveLog: PutGatewayResponseRequestFilterSensitiveLog,
             outputFilterSensitiveLog: GatewayResponseFilterSensitiveLog,
         };
-        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);
+    };
+    PutGatewayResponseCommand.prototype.serialize = function (input, context) {
         return serializeAws_restJson1PutGatewayResponseCommand(input, context);
-    }
-    deserialize(output, context) {
+    };
+    PutGatewayResponseCommand.prototype.deserialize = function (output, context) {
         return deserializeAws_restJson1PutGatewayResponseCommand(output, context);
-    }
-}
+    };
+    return PutGatewayResponseCommand;
+}($Command));
+export { PutGatewayResponseCommand };