@aws-sdk/client-imagebuilder 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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