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

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

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

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

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

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

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

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

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

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

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