@aws-sdk/client-proton 3.99.0 → 3.105.0

package/dist-cjs/waiters/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./waitForComponentDeleted"), exports);
+tslib_1.__exportStar(require("./waitForComponentDeployed"), exports);
 tslib_1.__exportStar(require("./waitForEnvironmentDeployed"), exports);
 tslib_1.__exportStar(require("./waitForEnvironmentTemplateVersionRegistered"), exports);
 tslib_1.__exportStar(require("./waitForServiceCreated"), exports);

package/dist-cjs/waiters/waitForComponentDeleted.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilComponentDeleted = exports.waitForComponentDeleted = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const GetComponentCommand_1 = require("../commands/GetComponentCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetComponentCommand_1.GetComponentCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.component.deploymentStatus;
+            };
+            if (returnComparator() === "DELETE_FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+        if (exception.name && exception.name == "ResourceNotFoundException") {
+            return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+        }
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForComponentDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 4999 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForComponentDeleted = waitForComponentDeleted;
+const waitUntilComponentDeleted = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 4999 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilComponentDeleted = waitUntilComponentDeleted;

package/dist-cjs/waiters/waitForComponentDeployed.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitUntilComponentDeployed = exports.waitForComponentDeployed = void 0;
+const util_waiter_1 = require("@aws-sdk/util-waiter");
+const GetComponentCommand_1 = require("../commands/GetComponentCommand");
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        const result = await client.send(new GetComponentCommand_1.GetComponentCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.component.deploymentStatus;
+            };
+            if (returnComparator() === "SUCCEEDED") {
+                return { state: util_waiter_1.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.component.deploymentStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: util_waiter_1.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: util_waiter_1.WaiterState.RETRY, reason };
+};
+const waitForComponentDeployed = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 4999 };
+    return (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+};
+exports.waitForComponentDeployed = waitForComponentDeployed;
+const waitUntilComponentDeployed = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 4999 };
+    const result = await (0, util_waiter_1.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+    return (0, util_waiter_1.checkExceptions)(result);
+};
+exports.waitUntilComponentDeployed = waitUntilComponentDeployed;

package/dist-es/Proton.js

@@ -1,8 +1,10 @@
 import { __extends } from "tslib";
 import { AcceptEnvironmentAccountConnectionCommand, } from "./commands/AcceptEnvironmentAccountConnectionCommand";
+import { CancelComponentDeploymentCommand, } from "./commands/CancelComponentDeploymentCommand";
 import { CancelEnvironmentDeploymentCommand, } from "./commands/CancelEnvironmentDeploymentCommand";
 import { CancelServiceInstanceDeploymentCommand, } from "./commands/CancelServiceInstanceDeploymentCommand";
 import { CancelServicePipelineDeploymentCommand, } from "./commands/CancelServicePipelineDeploymentCommand";
+import { CreateComponentCommand, } from "./commands/CreateComponentCommand";
 import { CreateEnvironmentAccountConnectionCommand, } from "./commands/CreateEnvironmentAccountConnectionCommand";
 import { CreateEnvironmentCommand, } from "./commands/CreateEnvironmentCommand";
 import { CreateEnvironmentTemplateCommand, } from "./commands/CreateEnvironmentTemplateCommand";
@@ -12,6 +14,7 @@ import { CreateServiceCommand, } from "./commands/CreateServiceCommand";
 import { CreateServiceTemplateCommand, } from "./commands/CreateServiceTemplateCommand";
 import { CreateServiceTemplateVersionCommand, } from "./commands/CreateServiceTemplateVersionCommand";
 import { CreateTemplateSyncConfigCommand, } from "./commands/CreateTemplateSyncConfigCommand";
+import { DeleteComponentCommand, } from "./commands/DeleteComponentCommand";
 import { DeleteEnvironmentAccountConnectionCommand, } from "./commands/DeleteEnvironmentAccountConnectionCommand";
 import { DeleteEnvironmentCommand, } from "./commands/DeleteEnvironmentCommand";
 import { DeleteEnvironmentTemplateCommand, } from "./commands/DeleteEnvironmentTemplateCommand";
@@ -22,6 +25,7 @@ import { DeleteServiceTemplateCommand, } from "./commands/DeleteServiceTemplateC
 import { DeleteServiceTemplateVersionCommand, } from "./commands/DeleteServiceTemplateVersionCommand";
 import { DeleteTemplateSyncConfigCommand, } from "./commands/DeleteTemplateSyncConfigCommand";
 import { GetAccountSettingsCommand, } from "./commands/GetAccountSettingsCommand";
+import { GetComponentCommand, } from "./commands/GetComponentCommand";
 import { GetEnvironmentAccountConnectionCommand, } from "./commands/GetEnvironmentAccountConnectionCommand";
 import { GetEnvironmentCommand, } from "./commands/GetEnvironmentCommand";
 import { GetEnvironmentTemplateCommand, } from "./commands/GetEnvironmentTemplateCommand";
@@ -34,6 +38,9 @@ import { GetServiceTemplateCommand, } from "./commands/GetServiceTemplateCommand
 import { GetServiceTemplateVersionCommand, } from "./commands/GetServiceTemplateVersionCommand";
 import { GetTemplateSyncConfigCommand, } from "./commands/GetTemplateSyncConfigCommand";
 import { GetTemplateSyncStatusCommand, } from "./commands/GetTemplateSyncStatusCommand";
+import { ListComponentOutputsCommand, } from "./commands/ListComponentOutputsCommand";
+import { ListComponentProvisionedResourcesCommand, } from "./commands/ListComponentProvisionedResourcesCommand";
+import { ListComponentsCommand, } from "./commands/ListComponentsCommand";
 import { ListEnvironmentAccountConnectionsCommand, } from "./commands/ListEnvironmentAccountConnectionsCommand";
 import { ListEnvironmentOutputsCommand, } from "./commands/ListEnvironmentOutputsCommand";
 import { ListEnvironmentProvisionedResourcesCommand, } from "./commands/ListEnvironmentProvisionedResourcesCommand";
@@ -56,6 +63,7 @@ import { RejectEnvironmentAccountConnectionCommand, } from "./commands/RejectEnv
 import { TagResourceCommand } from "./commands/TagResourceCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateAccountSettingsCommand, } from "./commands/UpdateAccountSettingsCommand";
+import { UpdateComponentCommand, } from "./commands/UpdateComponentCommand";
 import { UpdateEnvironmentAccountConnectionCommand, } from "./commands/UpdateEnvironmentAccountConnectionCommand";
 import { UpdateEnvironmentCommand, } from "./commands/UpdateEnvironmentCommand";
 import { UpdateEnvironmentTemplateCommand, } from "./commands/UpdateEnvironmentTemplateCommand";
@@ -86,6 +94,20 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.cancelComponentDeployment = function (args, optionsOrCb, cb) {
+        var command = new CancelComponentDeploymentCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.cancelEnvironmentDeployment = function (args, optionsOrCb, cb) {
         var command = new CancelEnvironmentDeploymentCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -128,6 +150,20 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.createComponent = function (args, optionsOrCb, cb) {
+        var command = new CreateComponentCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.createEnvironment = function (args, optionsOrCb, cb) {
         var command = new CreateEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -254,6 +290,20 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.deleteComponent = function (args, optionsOrCb, cb) {
+        var command = new DeleteComponentCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.deleteEnvironment = function (args, optionsOrCb, cb) {
         var command = new DeleteEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -394,6 +444,20 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.getComponent = function (args, optionsOrCb, cb) {
+        var command = new GetComponentCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.getEnvironment = function (args, optionsOrCb, cb) {
         var command = new GetEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -562,6 +626,48 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.listComponentOutputs = function (args, optionsOrCb, cb) {
+        var command = new ListComponentOutputsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Proton.prototype.listComponentProvisionedResources = function (args, optionsOrCb, cb) {
+        var command = new ListComponentProvisionedResourcesCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
+    Proton.prototype.listComponents = function (args, optionsOrCb, cb) {
+        var command = new ListComponentsCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.listEnvironmentAccountConnections = function (args, optionsOrCb, cb) {
         var command = new ListEnvironmentAccountConnectionsCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -870,6 +976,20 @@ var Proton = (function (_super) {
             return this.send(command, optionsOrCb);
         }
     };
+    Proton.prototype.updateComponent = function (args, optionsOrCb, cb) {
+        var command = new UpdateComponentCommand(args);
+        if (typeof optionsOrCb === "function") {
+            this.send(command, optionsOrCb);
+        }
+        else if (typeof cb === "function") {
+            if (typeof optionsOrCb !== "object")
+                throw new Error("Expect http options but get ".concat(typeof optionsOrCb));
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    };
     Proton.prototype.updateEnvironment = function (args, optionsOrCb, cb) {
         var command = new UpdateEnvironmentCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/ProtonClient.js

@@ -3,6 +3,7 @@ import { resolveEndpointsConfig, resolveRegionConfig, } from "@aws-sdk/config-re
 import { getContentLengthPlugin } from "@aws-sdk/middleware-content-length";
 import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
 import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
 import { getRetryPlugin, resolveRetryConfig } from "@aws-sdk/middleware-retry";
 import { getAwsAuthPlugin, resolveAwsAuthConfig, } from "@aws-sdk/middleware-signing";
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
@@ -25,6 +26,7 @@ var ProtonClient = (function (_super) {
         _this.middlewareStack.use(getContentLengthPlugin(_this.config));
         _this.middlewareStack.use(getHostHeaderPlugin(_this.config));
         _this.middlewareStack.use(getLoggerPlugin(_this.config));
+        _this.middlewareStack.use(getRecursionDetectionPlugin(_this.config));
         _this.middlewareStack.use(getAwsAuthPlugin(_this.config));
         _this.middlewareStack.use(getUserAgentPlugin(_this.config));
         return _this;

package/dist-es/commands/CancelComponentDeploymentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CancelComponentDeploymentInput, CancelComponentDeploymentOutput } from "../models/models_0";
+import { deserializeAws_json1_0CancelComponentDeploymentCommand, serializeAws_json1_0CancelComponentDeploymentCommand, } from "../protocols/Aws_json1_0";
+var CancelComponentDeploymentCommand = (function (_super) {
+    __extends(CancelComponentDeploymentCommand, _super);
+    function CancelComponentDeploymentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CancelComponentDeploymentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "CancelComponentDeploymentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CancelComponentDeploymentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: CancelComponentDeploymentOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CancelComponentDeploymentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CancelComponentDeploymentCommand(input, context);
+    };
+    CancelComponentDeploymentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CancelComponentDeploymentCommand(output, context);
+    };
+    return CancelComponentDeploymentCommand;
+}($Command));
+export { CancelComponentDeploymentCommand };

package/dist-es/commands/CreateComponentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateComponentInput, CreateComponentOutput } from "../models/models_0";
+import { deserializeAws_json1_0CreateComponentCommand, serializeAws_json1_0CreateComponentCommand, } from "../protocols/Aws_json1_0";
+var CreateComponentCommand = (function (_super) {
+    __extends(CreateComponentCommand, _super);
+    function CreateComponentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    CreateComponentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "CreateComponentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: CreateComponentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: CreateComponentOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    CreateComponentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0CreateComponentCommand(input, context);
+    };
+    CreateComponentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0CreateComponentCommand(output, context);
+    };
+    return CreateComponentCommand;
+}($Command));
+export { CreateComponentCommand };

package/dist-es/commands/DeleteComponentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteComponentInput, DeleteComponentOutput } from "../models/models_0";
+import { deserializeAws_json1_0DeleteComponentCommand, serializeAws_json1_0DeleteComponentCommand, } from "../protocols/Aws_json1_0";
+var DeleteComponentCommand = (function (_super) {
+    __extends(DeleteComponentCommand, _super);
+    function DeleteComponentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DeleteComponentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "DeleteComponentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DeleteComponentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DeleteComponentOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DeleteComponentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0DeleteComponentCommand(input, context);
+    };
+    DeleteComponentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0DeleteComponentCommand(output, context);
+    };
+    return DeleteComponentCommand;
+}($Command));
+export { DeleteComponentCommand };

package/dist-es/commands/GetComponentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetComponentInput, GetComponentOutput } from "../models/models_0";
+import { deserializeAws_json1_0GetComponentCommand, serializeAws_json1_0GetComponentCommand, } from "../protocols/Aws_json1_0";
+var GetComponentCommand = (function (_super) {
+    __extends(GetComponentCommand, _super);
+    function GetComponentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    GetComponentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "GetComponentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: GetComponentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: GetComponentOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    GetComponentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0GetComponentCommand(input, context);
+    };
+    GetComponentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0GetComponentCommand(output, context);
+    };
+    return GetComponentCommand;
+}($Command));
+export { GetComponentCommand };

package/dist-es/commands/ListComponentOutputsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListComponentOutputsInput, ListComponentOutputsOutput } from "../models/models_0";
+import { deserializeAws_json1_0ListComponentOutputsCommand, serializeAws_json1_0ListComponentOutputsCommand, } from "../protocols/Aws_json1_0";
+var ListComponentOutputsCommand = (function (_super) {
+    __extends(ListComponentOutputsCommand, _super);
+    function ListComponentOutputsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListComponentOutputsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentOutputsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListComponentOutputsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListComponentOutputsOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListComponentOutputsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListComponentOutputsCommand(input, context);
+    };
+    ListComponentOutputsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListComponentOutputsCommand(output, context);
+    };
+    return ListComponentOutputsCommand;
+}($Command));
+export { ListComponentOutputsCommand };

package/dist-es/commands/ListComponentProvisionedResourcesCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListComponentProvisionedResourcesInput, ListComponentProvisionedResourcesOutput } from "../models/models_0";
+import { deserializeAws_json1_0ListComponentProvisionedResourcesCommand, serializeAws_json1_0ListComponentProvisionedResourcesCommand, } from "../protocols/Aws_json1_0";
+var ListComponentProvisionedResourcesCommand = (function (_super) {
+    __extends(ListComponentProvisionedResourcesCommand, _super);
+    function ListComponentProvisionedResourcesCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListComponentProvisionedResourcesCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentProvisionedResourcesCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListComponentProvisionedResourcesInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListComponentProvisionedResourcesOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListComponentProvisionedResourcesCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListComponentProvisionedResourcesCommand(input, context);
+    };
+    ListComponentProvisionedResourcesCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListComponentProvisionedResourcesCommand(output, context);
+    };
+    return ListComponentProvisionedResourcesCommand;
+}($Command));
+export { ListComponentProvisionedResourcesCommand };

package/dist-es/commands/ListComponentsCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListComponentsInput, ListComponentsOutput } from "../models/models_0";
+import { deserializeAws_json1_0ListComponentsCommand, serializeAws_json1_0ListComponentsCommand, } from "../protocols/Aws_json1_0";
+var ListComponentsCommand = (function (_super) {
+    __extends(ListComponentsCommand, _super);
+    function ListComponentsCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    ListComponentsCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "ListComponentsCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: ListComponentsInput.filterSensitiveLog,
+            outputFilterSensitiveLog: ListComponentsOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    ListComponentsCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0ListComponentsCommand(input, context);
+    };
+    ListComponentsCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0ListComponentsCommand(output, context);
+    };
+    return ListComponentsCommand;
+}($Command));
+export { ListComponentsCommand };

package/dist-es/commands/UpdateComponentCommand.js

@@ -0,0 +1,39 @@
+import { __extends } from "tslib";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateComponentInput, UpdateComponentOutput } from "../models/models_0";
+import { deserializeAws_json1_0UpdateComponentCommand, serializeAws_json1_0UpdateComponentCommand, } from "../protocols/Aws_json1_0";
+var UpdateComponentCommand = (function (_super) {
+    __extends(UpdateComponentCommand, _super);
+    function UpdateComponentCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    UpdateComponentCommand.prototype.resolveMiddleware = function (clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        var stack = clientStack.concat(this.middlewareStack);
+        var logger = configuration.logger;
+        var clientName = "ProtonClient";
+        var commandName = "UpdateComponentCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: UpdateComponentInput.filterSensitiveLog,
+            outputFilterSensitiveLog: UpdateComponentOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    UpdateComponentCommand.prototype.serialize = function (input, context) {
+        return serializeAws_json1_0UpdateComponentCommand(input, context);
+    };
+    UpdateComponentCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_json1_0UpdateComponentCommand(output, context);
+    };
+    return UpdateComponentCommand;
+}($Command));
+export { UpdateComponentCommand };