@aws-sdk/client-cloudformation 3.51.0 → 3.52.0

package/dist-es/commands/DescribeChangeSetHooksCommand.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 { DescribeChangeSetHooksInput, DescribeChangeSetHooksOutput } from "../models/models_0";
+import { deserializeAws_queryDescribeChangeSetHooksCommand, serializeAws_queryDescribeChangeSetHooksCommand, } from "../protocols/Aws_query";
+var DescribeChangeSetHooksCommand = (function (_super) {
+    __extends(DescribeChangeSetHooksCommand, _super);
+    function DescribeChangeSetHooksCommand(input) {
+        var _this = _super.call(this) || this;
+        _this.input = input;
+        return _this;
+    }
+    DescribeChangeSetHooksCommand.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 = "CloudFormationClient";
+        var commandName = "DescribeChangeSetHooksCommand";
+        var handlerExecutionContext = {
+            logger: logger,
+            clientName: clientName,
+            commandName: commandName,
+            inputFilterSensitiveLog: DescribeChangeSetHooksInput.filterSensitiveLog,
+            outputFilterSensitiveLog: DescribeChangeSetHooksOutput.filterSensitiveLog,
+        };
+        var requestHandler = configuration.requestHandler;
+        return stack.resolve(function (request) {
+            return requestHandler.handle(request.request, options || {});
+        }, handlerExecutionContext);
+    };
+    DescribeChangeSetHooksCommand.prototype.serialize = function (input, context) {
+        return serializeAws_queryDescribeChangeSetHooksCommand(input, context);
+    };
+    DescribeChangeSetHooksCommand.prototype.deserialize = function (output, context) {
+        return deserializeAws_queryDescribeChangeSetHooksCommand(output, context);
+    };
+    return DescribeChangeSetHooksCommand;
+}($Command));
+export { DescribeChangeSetHooksCommand };

package/dist-es/commands/index.js

@@ -14,6 +14,7 @@ export * from "./DeleteStackSetCommand";
 export * from "./DeregisterTypeCommand";
 export * from "./DescribeAccountLimitsCommand";
 export * from "./DescribeChangeSetCommand";
+export * from "./DescribeChangeSetHooksCommand";
 export * from "./DescribePublisherCommand";
 export * from "./DescribeStackDriftDetectionStatusCommand";
 export * from "./DescribeStackEventsCommand";

package/dist-es/models/models_0.js

@@ -13,6 +13,7 @@ export var LoggingConfig;
 })(LoggingConfig || (LoggingConfig = {}));
 export var ThirdPartyType;
 (function (ThirdPartyType) {
+    ThirdPartyType["HOOK"] = "HOOK";
     ThirdPartyType["MODULE"] = "MODULE";
     ThirdPartyType["RESOURCE"] = "RESOURCE";
 })(ThirdPartyType || (ThirdPartyType = {}));
@@ -141,6 +142,37 @@ export var Change;
 (function (Change) {
     Change.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(Change || (Change = {}));
+export var HookFailureMode;
+(function (HookFailureMode) {
+    HookFailureMode["FAIL"] = "FAIL";
+    HookFailureMode["WARN"] = "WARN";
+})(HookFailureMode || (HookFailureMode = {}));
+export var HookInvocationPoint;
+(function (HookInvocationPoint) {
+    HookInvocationPoint["PRE_PROVISION"] = "PRE_PROVISION";
+})(HookInvocationPoint || (HookInvocationPoint = {}));
+export var ChangeSetHookResourceTargetDetails;
+(function (ChangeSetHookResourceTargetDetails) {
+    ChangeSetHookResourceTargetDetails.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ChangeSetHookResourceTargetDetails || (ChangeSetHookResourceTargetDetails = {}));
+export var HookTargetType;
+(function (HookTargetType) {
+    HookTargetType["RESOURCE"] = "RESOURCE";
+})(HookTargetType || (HookTargetType = {}));
+export var ChangeSetHookTargetDetails;
+(function (ChangeSetHookTargetDetails) {
+    ChangeSetHookTargetDetails.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ChangeSetHookTargetDetails || (ChangeSetHookTargetDetails = {}));
+export var ChangeSetHook;
+(function (ChangeSetHook) {
+    ChangeSetHook.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(ChangeSetHook || (ChangeSetHook = {}));
+export var ChangeSetHooksStatus;
+(function (ChangeSetHooksStatus) {
+    ChangeSetHooksStatus["PLANNED"] = "PLANNED";
+    ChangeSetHooksStatus["PLANNING"] = "PLANNING";
+    ChangeSetHooksStatus["UNAVAILABLE"] = "UNAVAILABLE";
+})(ChangeSetHooksStatus || (ChangeSetHooksStatus = {}));
 export var ChangeSetStatus;
 (function (ChangeSetStatus) {
     ChangeSetStatus["CREATE_COMPLETE"] = "CREATE_COMPLETE";
@@ -314,6 +346,14 @@ export var DescribeChangeSetOutput;
 (function (DescribeChangeSetOutput) {
     DescribeChangeSetOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DescribeChangeSetOutput || (DescribeChangeSetOutput = {}));
+export var DescribeChangeSetHooksInput;
+(function (DescribeChangeSetHooksInput) {
+    DescribeChangeSetHooksInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeChangeSetHooksInput || (DescribeChangeSetHooksInput = {}));
+export var DescribeChangeSetHooksOutput;
+(function (DescribeChangeSetHooksOutput) {
+    DescribeChangeSetHooksOutput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
+})(DescribeChangeSetHooksOutput || (DescribeChangeSetHooksOutput = {}));
 export var DescribePublisherInput;
 (function (DescribePublisherInput) {
     DescribePublisherInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
@@ -358,6 +398,13 @@ export var DescribeStackEventsInput;
 (function (DescribeStackEventsInput) {
     DescribeStackEventsInput.filterSensitiveLog = function (obj) { return (__assign({}, obj)); };
 })(DescribeStackEventsInput || (DescribeStackEventsInput = {}));
+export var HookStatus;
+(function (HookStatus) {
+    HookStatus["HOOK_COMPLETE_FAILED"] = "HOOK_COMPLETE_FAILED";
+    HookStatus["HOOK_COMPLETE_SUCCEEDED"] = "HOOK_COMPLETE_SUCCEEDED";
+    HookStatus["HOOK_FAILED"] = "HOOK_FAILED";
+    HookStatus["HOOK_IN_PROGRESS"] = "HOOK_IN_PROGRESS";
+})(HookStatus || (HookStatus = {}));
 export var ResourceStatus;
 (function (ResourceStatus) {
     ResourceStatus["CREATE_COMPLETE"] = "CREATE_COMPLETE";
@@ -840,11 +887,13 @@ export var HandlerErrorCode;
     HandlerErrorCode["AccessDenied"] = "AccessDenied";
     HandlerErrorCode["AlreadyExists"] = "AlreadyExists";
     HandlerErrorCode["GeneralServiceException"] = "GeneralServiceException";
+    HandlerErrorCode["HandlerInternalFailure"] = "HandlerInternalFailure";
     HandlerErrorCode["InternalFailure"] = "InternalFailure";
     HandlerErrorCode["InvalidCredentials"] = "InvalidCredentials";
     HandlerErrorCode["InvalidRequest"] = "InvalidRequest";
     HandlerErrorCode["InvalidTypeConfiguration"] = "InvalidTypeConfiguration";
     HandlerErrorCode["NetworkFailure"] = "NetworkFailure";
+    HandlerErrorCode["NonCompliant"] = "NonCompliant";
     HandlerErrorCode["NotFound"] = "NotFound";
     HandlerErrorCode["NotUpdatable"] = "NotUpdatable";
     HandlerErrorCode["ResourceConflict"] = "ResourceConflict";
@@ -852,6 +901,7 @@ export var HandlerErrorCode;
     HandlerErrorCode["ServiceLimitExceeded"] = "ServiceLimitExceeded";
     HandlerErrorCode["ServiceTimeout"] = "NotStabilized";
     HandlerErrorCode["Throttling"] = "Throttling";
+    HandlerErrorCode["Unknown"] = "Unknown";
 })(HandlerErrorCode || (HandlerErrorCode = {}));
 export var RecordHandlerProgressInput;
 (function (RecordHandlerProgressInput) {

package/dist-es/protocols/Aws_query.js

@@ -164,6 +164,16 @@ export var serializeAws_queryDescribeChangeSetCommand = function (input, context
         return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
     });
 }); };
+export var serializeAws_queryDescribeChangeSetHooksCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var headers, body;
+    return __generator(this, function (_a) {
+        headers = {
+            "content-type": "application/x-www-form-urlencoded",
+        };
+        body = buildFormUrlencodedString(__assign(__assign({}, serializeAws_queryDescribeChangeSetHooksInput(input, context)), { Action: "DescribeChangeSetHooks", Version: "2010-05-15" }));
+        return [2, buildHttpRpcRequest(context, headers, "/", undefined, body)];
+    });
+}); };
 export var serializeAws_queryDescribePublisherCommand = function (input, context) { return __awaiter(void 0, void 0, void 0, function () {
     var headers, body;
     return __generator(this, function (_a) {
@@ -1706,6 +1716,62 @@ var deserializeAws_queryDescribeChangeSetCommandError = function (output, contex
         }
     });
 }); };
+export var deserializeAws_queryDescribeChangeSetHooksCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var data, contents, response;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (output.statusCode >= 300) {
+                    return [2, deserializeAws_queryDescribeChangeSetHooksCommandError(output, context)];
+                }
+                return [4, parseBody(output.body, context)];
+            case 1:
+                data = _a.sent();
+                contents = {};
+                contents = deserializeAws_queryDescribeChangeSetHooksOutput(data.DescribeChangeSetHooksResult, context);
+                response = __assign({ $metadata: deserializeMetadata(output) }, contents);
+                return [2, Promise.resolve(response)];
+        }
+    });
+}); };
+var deserializeAws_queryDescribeChangeSetHooksCommandError = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
+    var parsedOutput, _a, response, errorCode, _b, _c, parsedBody, message;
+    var _d;
+    return __generator(this, function (_e) {
+        switch (_e.label) {
+            case 0:
+                _a = [__assign({}, output)];
+                _d = {};
+                return [4, parseBody(output.body, context)];
+            case 1:
+                parsedOutput = __assign.apply(void 0, _a.concat([(_d.body = _e.sent(), _d)]));
+                errorCode = "UnknownError";
+                errorCode = loadQueryErrorCode(output, parsedOutput.body);
+                _b = errorCode;
+                switch (_b) {
+                    case "ChangeSetNotFoundException": return [3, 2];
+                    case "com.amazonaws.cloudformation#ChangeSetNotFoundException": return [3, 2];
+                }
+                return [3, 4];
+            case 2:
+                _c = [{}];
+                return [4, deserializeAws_queryChangeSetNotFoundExceptionResponse(parsedOutput, context)];
+            case 3:
+                response = __assign.apply(void 0, [__assign.apply(void 0, _c.concat([(_e.sent())])), { name: errorCode, $metadata: deserializeMetadata(output) }]);
+                return [3, 5];
+            case 4:
+                parsedBody = parsedOutput.body;
+                errorCode = parsedBody.Error.code || parsedBody.Error.Code || errorCode;
+                response = __assign(__assign({}, parsedBody.Error), { name: "" + errorCode, message: parsedBody.Error.message || parsedBody.Error.Message || errorCode, $fault: "client", $metadata: deserializeMetadata(output) });
+                _e.label = 5;
+            case 5:
+                message = response.message || response.Message || errorCode;
+                response.message = message;
+                delete response.Message;
+                return [2, Promise.reject(Object.assign(new Error(message), response))];
+        }
+    });
+}); };
 export var deserializeAws_queryDescribePublisherCommand = function (output, context) { return __awaiter(void 0, void 0, void 0, function () {
     var data, contents, response;
     return __generator(this, function (_a) {
@@ -5269,6 +5335,22 @@ var serializeAws_queryDescribeAccountLimitsInput = function (input, context) {
     }
     return entries;
 };
+var serializeAws_queryDescribeChangeSetHooksInput = function (input, context) {
+    var entries = {};
+    if (input.ChangeSetName !== undefined && input.ChangeSetName !== null) {
+        entries["ChangeSetName"] = input.ChangeSetName;
+    }
+    if (input.StackName !== undefined && input.StackName !== null) {
+        entries["StackName"] = input.StackName;
+    }
+    if (input.NextToken !== undefined && input.NextToken !== null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.LogicalResourceId !== undefined && input.LogicalResourceId !== null) {
+        entries["LogicalResourceId"] = input.LogicalResourceId;
+    }
+    return entries;
+};
 var serializeAws_queryDescribeChangeSetInput = function (input, context) {
     var entries = {};
     if (input.ChangeSetName !== undefined && input.ChangeSetName !== null) {
@@ -6982,11 +7064,15 @@ var deserializeAws_queryCFNRegistryException = function (output, context) {
 var deserializeAws_queryChange = function (output, context) {
     var contents = {
         Type: undefined,
+        HookInvocationCount: undefined,
         ResourceChange: undefined,
     };
     if (output["Type"] !== undefined) {
         contents.Type = __expectString(output["Type"]);
     }
+    if (output["HookInvocationCount"] !== undefined) {
+        contents.HookInvocationCount = __strictParseInt32(output["HookInvocationCount"]);
+    }
     if (output["ResourceChange"] !== undefined) {
         contents.ResourceChange = deserializeAws_queryResourceChange(output["ResourceChange"], context);
     }
@@ -7002,6 +7088,75 @@ var deserializeAws_queryChanges = function (output, context) {
         return deserializeAws_queryChange(entry, context);
     });
 };
+var deserializeAws_queryChangeSetHook = function (output, context) {
+    var contents = {
+        InvocationPoint: undefined,
+        FailureMode: undefined,
+        TypeName: undefined,
+        TypeVersionId: undefined,
+        TypeConfigurationVersionId: undefined,
+        TargetDetails: undefined,
+    };
+    if (output["InvocationPoint"] !== undefined) {
+        contents.InvocationPoint = __expectString(output["InvocationPoint"]);
+    }
+    if (output["FailureMode"] !== undefined) {
+        contents.FailureMode = __expectString(output["FailureMode"]);
+    }
+    if (output["TypeName"] !== undefined) {
+        contents.TypeName = __expectString(output["TypeName"]);
+    }
+    if (output["TypeVersionId"] !== undefined) {
+        contents.TypeVersionId = __expectString(output["TypeVersionId"]);
+    }
+    if (output["TypeConfigurationVersionId"] !== undefined) {
+        contents.TypeConfigurationVersionId = __expectString(output["TypeConfigurationVersionId"]);
+    }
+    if (output["TargetDetails"] !== undefined) {
+        contents.TargetDetails = deserializeAws_queryChangeSetHookTargetDetails(output["TargetDetails"], context);
+    }
+    return contents;
+};
+var deserializeAws_queryChangeSetHookResourceTargetDetails = function (output, context) {
+    var contents = {
+        LogicalResourceId: undefined,
+        ResourceType: undefined,
+        ResourceAction: undefined,
+    };
+    if (output["LogicalResourceId"] !== undefined) {
+        contents.LogicalResourceId = __expectString(output["LogicalResourceId"]);
+    }
+    if (output["ResourceType"] !== undefined) {
+        contents.ResourceType = __expectString(output["ResourceType"]);
+    }
+    if (output["ResourceAction"] !== undefined) {
+        contents.ResourceAction = __expectString(output["ResourceAction"]);
+    }
+    return contents;
+};
+var deserializeAws_queryChangeSetHooks = function (output, context) {
+    return (output || [])
+        .filter(function (e) { return e != null; })
+        .map(function (entry) {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_queryChangeSetHook(entry, context);
+    });
+};
+var deserializeAws_queryChangeSetHookTargetDetails = function (output, context) {
+    var contents = {
+        TargetType: undefined,
+        ResourceTargetDetails: undefined,
+    };
+    if (output["TargetType"] !== undefined) {
+        contents.TargetType = __expectString(output["TargetType"]);
+    }
+    if (output["ResourceTargetDetails"] !== undefined) {
+        contents.ResourceTargetDetails = deserializeAws_queryChangeSetHookResourceTargetDetails(output["ResourceTargetDetails"], context);
+    }
+    return contents;
+};
 var deserializeAws_queryChangeSetNotFoundException = function (output, context) {
     var contents = {
         Message: undefined,
@@ -7191,6 +7346,42 @@ var deserializeAws_queryDescribeAccountLimitsOutput = function (output, context)
     }
     return contents;
 };
+var deserializeAws_queryDescribeChangeSetHooksOutput = function (output, context) {
+    var contents = {
+        ChangeSetId: undefined,
+        ChangeSetName: undefined,
+        Hooks: undefined,
+        Status: undefined,
+        NextToken: undefined,
+        StackId: undefined,
+        StackName: undefined,
+    };
+    if (output["ChangeSetId"] !== undefined) {
+        contents.ChangeSetId = __expectString(output["ChangeSetId"]);
+    }
+    if (output["ChangeSetName"] !== undefined) {
+        contents.ChangeSetName = __expectString(output["ChangeSetName"]);
+    }
+    if (output.Hooks === "") {
+        contents.Hooks = [];
+    }
+    if (output["Hooks"] !== undefined && output["Hooks"]["member"] !== undefined) {
+        contents.Hooks = deserializeAws_queryChangeSetHooks(__getArrayIfSingleItem(output["Hooks"]["member"]), context);
+    }
+    if (output["Status"] !== undefined) {
+        contents.Status = __expectString(output["Status"]);
+    }
+    if (output["NextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["NextToken"]);
+    }
+    if (output["StackId"] !== undefined) {
+        contents.StackId = __expectString(output["StackId"]);
+    }
+    if (output["StackName"] !== undefined) {
+        contents.StackName = __expectString(output["StackName"]);
+    }
+    return contents;
+};
 var deserializeAws_queryDescribeChangeSetOutput = function (output, context) {
     var contents = {
         ChangeSetName: undefined,
@@ -8707,6 +8898,11 @@ var deserializeAws_queryStackEvent = function (output, context) {
         ResourceStatusReason: undefined,
         ResourceProperties: undefined,
         ClientRequestToken: undefined,
+        HookType: undefined,
+        HookStatus: undefined,
+        HookStatusReason: undefined,
+        HookInvocationPoint: undefined,
+        HookFailureMode: undefined,
     };
     if (output["StackId"] !== undefined) {
         contents.StackId = __expectString(output["StackId"]);
@@ -8741,6 +8937,21 @@ var deserializeAws_queryStackEvent = function (output, context) {
     if (output["ClientRequestToken"] !== undefined) {
         contents.ClientRequestToken = __expectString(output["ClientRequestToken"]);
     }
+    if (output["HookType"] !== undefined) {
+        contents.HookType = __expectString(output["HookType"]);
+    }
+    if (output["HookStatus"] !== undefined) {
+        contents.HookStatus = __expectString(output["HookStatus"]);
+    }
+    if (output["HookStatusReason"] !== undefined) {
+        contents.HookStatusReason = __expectString(output["HookStatusReason"]);
+    }
+    if (output["HookInvocationPoint"] !== undefined) {
+        contents.HookInvocationPoint = __expectString(output["HookInvocationPoint"]);
+    }
+    if (output["HookFailureMode"] !== undefined) {
+        contents.HookFailureMode = __expectString(output["HookFailureMode"]);
+    }
     return contents;
 };
 var deserializeAws_queryStackEvents = function (output, context) {