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

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

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

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

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

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

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

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

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

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

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