@aws-sdk/client-imagebuilder 3.183.0 → 3.185.0

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

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

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

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

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

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

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

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

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

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