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

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

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

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

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

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

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

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

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

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

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