@aws-sdk/client-rbin 3.216.0 → 3.218.0

package/dist-es/Rbin.js

@@ -3,7 +3,9 @@ import { DeleteRuleCommand } from "./commands/DeleteRuleCommand";
 import { GetRuleCommand } from "./commands/GetRuleCommand";
 import { ListRulesCommand } from "./commands/ListRulesCommand";
 import { ListTagsForResourceCommand, } from "./commands/ListTagsForResourceCommand";
+import { LockRuleCommand } from "./commands/LockRuleCommand";
 import { TagResourceCommand } from "./commands/TagResourceCommand";
+import { UnlockRuleCommand } from "./commands/UnlockRuleCommand";
 import { UntagResourceCommand, } from "./commands/UntagResourceCommand";
 import { UpdateRuleCommand } from "./commands/UpdateRuleCommand";
 import { RbinClient } from "./RbinClient";
@@ -78,6 +80,20 @@ export class Rbin extends RbinClient {
             return this.send(command, optionsOrCb);
         }
     }
+    lockRule(args, optionsOrCb, cb) {
+        const command = new LockRuleCommand(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 ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     tagResource(args, optionsOrCb, cb) {
         const command = new TagResourceCommand(args);
         if (typeof optionsOrCb === "function") {
@@ -92,6 +108,20 @@ export class Rbin extends RbinClient {
             return this.send(command, optionsOrCb);
         }
     }
+    unlockRule(args, optionsOrCb, cb) {
+        const command = new UnlockRuleCommand(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 ${typeof optionsOrCb}`);
+            this.send(command, optionsOrCb || {}, cb);
+        }
+        else {
+            return this.send(command, optionsOrCb);
+        }
+    }
     untagResource(args, optionsOrCb, cb) {
         const command = new UntagResourceCommand(args);
         if (typeof optionsOrCb === "function") {

package/dist-es/commands/LockRuleCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { LockRuleRequestFilterSensitiveLog, LockRuleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1LockRuleCommand, serializeAws_restJson1LockRuleCommand, } from "../protocols/Aws_restJson1";
+export class LockRuleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, LockRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RbinClient";
+        const commandName = "LockRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: LockRuleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: LockRuleResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1LockRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1LockRuleCommand(output, context);
+    }
+}

package/dist-es/commands/UnlockRuleCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UnlockRuleRequestFilterSensitiveLog, UnlockRuleResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UnlockRuleCommand, serializeAws_restJson1UnlockRuleCommand, } from "../protocols/Aws_restJson1";
+export class UnlockRuleCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UnlockRuleCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "RbinClient";
+        const commandName = "UnlockRuleCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UnlockRuleRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: UnlockRuleResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UnlockRuleCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UnlockRuleCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -3,6 +3,8 @@ export * from "./DeleteRuleCommand";
 export * from "./GetRuleCommand";
 export * from "./ListRulesCommand";
 export * from "./ListTagsForResourceCommand";
+export * from "./LockRuleCommand";
 export * from "./TagResourceCommand";
+export * from "./UnlockRuleCommand";
 export * from "./UntagResourceCommand";
 export * from "./UpdateRuleCommand";

package/dist-es/endpoint/ruleset.js

@@ -3,7 +3,7 @@ export const ruleSet = {
     parameters: {
         Region: {
             builtIn: "AWS::Region",
-            required: false,
+            required: true,
             documentation: "The AWS region used to dispatch the request.",
             type: "String",
         },

package/dist-es/models/models_0.js

@@ -1,4 +1,8 @@
 import { RbinServiceException as __BaseException } from "./RbinServiceException";
+export var UnlockDelayUnit;
+(function (UnlockDelayUnit) {
+    UnlockDelayUnit["DAYS"] = "DAYS";
+})(UnlockDelayUnit || (UnlockDelayUnit = {}));
 export var ResourceType;
 (function (ResourceType) {
     ResourceType["EBS_SNAPSHOT"] = "EBS_SNAPSHOT";
@@ -8,6 +12,12 @@ export var RetentionPeriodUnit;
 (function (RetentionPeriodUnit) {
     RetentionPeriodUnit["DAYS"] = "DAYS";
 })(RetentionPeriodUnit || (RetentionPeriodUnit = {}));
+export var LockState;
+(function (LockState) {
+    LockState["LOCKED"] = "locked";
+    LockState["PENDING_UNLOCK"] = "pending_unlock";
+    LockState["UNLOCKED"] = "unlocked";
+})(LockState || (LockState = {}));
 export var RuleStatus;
 (function (RuleStatus) {
     RuleStatus["AVAILABLE"] = "available";
@@ -63,6 +73,24 @@ export class ValidationException extends __BaseException {
         this.Reason = opts.Reason;
     }
 }
+export var ConflictExceptionReason;
+(function (ConflictExceptionReason) {
+    ConflictExceptionReason["INVALID_RULE_STATE"] = "INVALID_RULE_STATE";
+})(ConflictExceptionReason || (ConflictExceptionReason = {}));
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+        this.Reason = opts.Reason;
+    }
+}
 export var ResourceNotFoundExceptionReason;
 (function (ResourceNotFoundExceptionReason) {
     ResourceNotFoundExceptionReason["RULE_NOT_FOUND"] = "RULE_NOT_FOUND";
@@ -81,6 +109,12 @@ export class ResourceNotFoundException extends __BaseException {
         this.Reason = opts.Reason;
     }
 }
+export const UnlockDelayFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LockConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const ResourceTagFilterSensitiveLog = (obj) => ({
     ...obj,
 });
@@ -123,12 +157,24 @@ export const ListTagsForResourceRequestFilterSensitiveLog = (obj) => ({
 export const ListTagsForResourceResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const LockRuleRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LockRuleResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const TagResourceRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });
 export const TagResourceResponseFilterSensitiveLog = (obj) => ({
     ...obj,
 });
+export const UnlockRuleRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UnlockRuleResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
 export const UntagResourceRequestFilterSensitiveLog = (obj) => ({
     ...obj,
 });

package/dist-es/protocols/Aws_restJson1.js

@@ -1,6 +1,6 @@
 import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
-import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, map as __map, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
-import { InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ValidationException, } from "../models/models_0";
+import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, map as __map, parseEpochTimestamp as __parseEpochTimestamp, resolvedPath as __resolvedPath, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { ConflictException, InternalServerException, ResourceNotFoundException, ServiceQuotaExceededException, ValidationException, } from "../models/models_0";
 import { RbinServiceException as __BaseException } from "../models/RbinServiceException";
 export const serializeAws_restJson1CreateRuleCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
@@ -11,6 +11,9 @@ export const serializeAws_restJson1CreateRuleCommand = async (input, context) =>
     let body;
     body = JSON.stringify({
         ...(input.Description != null && { Description: input.Description }),
+        ...(input.LockConfiguration != null && {
+            LockConfiguration: serializeAws_restJson1LockConfiguration(input.LockConfiguration, context),
+        }),
         ...(input.ResourceTags != null && {
             ResourceTags: serializeAws_restJson1ResourceTags(input.ResourceTags, context),
         }),
@@ -70,6 +73,7 @@ export const serializeAws_restJson1ListRulesCommand = async (input, context) =>
     const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/list-rules";
     let body;
     body = JSON.stringify({
+        ...(input.LockState != null && { LockState: input.LockState }),
         ...(input.MaxResults != null && { MaxResults: input.MaxResults }),
         ...(input.NextToken != null && { NextToken: input.NextToken }),
         ...(input.ResourceTags != null && {
@@ -103,6 +107,29 @@ export const serializeAws_restJson1ListTagsForResourceCommand = async (input, co
         body,
     });
 };
+export const serializeAws_restJson1LockRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rules/{Identifier}/lock";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.LockConfiguration != null && {
+            LockConfiguration: serializeAws_restJson1LockConfiguration(input.LockConfiguration, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {
@@ -124,13 +151,32 @@ export const serializeAws_restJson1TagResourceCommand = async (input, context) =
         body,
     });
 };
+export const serializeAws_restJson1UnlockRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/rules/{Identifier}/unlock";
+    resolvedPath = __resolvedPath(resolvedPath, input, "Identifier", () => input.Identifier, "{Identifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
 export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
     const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
     const headers = {};
     let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{ResourceArn}";
     resolvedPath = __resolvedPath(resolvedPath, input, "ResourceArn", () => input.ResourceArn, "{ResourceArn}", false);
     const query = map({
-        tagKeys: [() => input.TagKeys !== void 0, () => (input.TagKeys || []).map((_entry) => _entry)],
+        tagKeys: [
+            __expectNonNull(input.TagKeys, `TagKeys`) != null,
+            () => (input.TagKeys || []).map((_entry) => _entry),
+        ],
     });
     let body;
     return new __HttpRequest({
@@ -186,6 +232,12 @@ export const deserializeAws_restJson1CreateRuleCommand = async (output, context)
     if (data.Identifier != null) {
         contents.Identifier = __expectString(data.Identifier);
     }
+    if (data.LockConfiguration != null) {
+        contents.LockConfiguration = deserializeAws_restJson1LockConfiguration(data.LockConfiguration, context);
+    }
+    if (data.LockState != null) {
+        contents.LockState = __expectString(data.LockState);
+    }
     if (data.ResourceTags != null) {
         contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.ResourceTags, context);
     }
@@ -246,6 +298,9 @@ const deserializeAws_restJson1DeleteRuleCommandError = async (output, context) =
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.rbin#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.rbin#InternalServerException":
             throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
@@ -279,6 +334,15 @@ export const deserializeAws_restJson1GetRuleCommand = async (output, context) =>
     if (data.Identifier != null) {
         contents.Identifier = __expectString(data.Identifier);
     }
+    if (data.LockConfiguration != null) {
+        contents.LockConfiguration = deserializeAws_restJson1LockConfiguration(data.LockConfiguration, context);
+    }
+    if (data.LockEndTime != null) {
+        contents.LockEndTime = __expectNonNull(__parseEpochTimestamp(__expectNumber(data.LockEndTime)));
+    }
+    if (data.LockState != null) {
+        contents.LockState = __expectString(data.LockState);
+    }
     if (data.ResourceTags != null) {
         contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.ResourceTags, context);
     }
@@ -397,6 +461,69 @@ const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, c
             });
     }
 };
+export const deserializeAws_restJson1LockRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1LockRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Description != null) {
+        contents.Description = __expectString(data.Description);
+    }
+    if (data.Identifier != null) {
+        contents.Identifier = __expectString(data.Identifier);
+    }
+    if (data.LockConfiguration != null) {
+        contents.LockConfiguration = deserializeAws_restJson1LockConfiguration(data.LockConfiguration, context);
+    }
+    if (data.LockState != null) {
+        contents.LockState = __expectString(data.LockState);
+    }
+    if (data.ResourceTags != null) {
+        contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.ResourceTags, context);
+    }
+    if (data.ResourceType != null) {
+        contents.ResourceType = __expectString(data.ResourceType);
+    }
+    if (data.RetentionPeriod != null) {
+        contents.RetentionPeriod = deserializeAws_restJson1RetentionPeriod(data.RetentionPeriod, context);
+    }
+    if (data.Status != null) {
+        contents.Status = __expectString(data.Status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1LockRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.rbin#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.rbin#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rbin#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.rbin#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
     if (output.statusCode !== 201 && output.statusCode >= 300) {
         return deserializeAws_restJson1TagResourceCommandError(output, context);
@@ -436,6 +563,72 @@ const deserializeAws_restJson1TagResourceCommandError = async (output, context)
             });
     }
 };
+export const deserializeAws_restJson1UnlockRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UnlockRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.Description != null) {
+        contents.Description = __expectString(data.Description);
+    }
+    if (data.Identifier != null) {
+        contents.Identifier = __expectString(data.Identifier);
+    }
+    if (data.LockConfiguration != null) {
+        contents.LockConfiguration = deserializeAws_restJson1LockConfiguration(data.LockConfiguration, context);
+    }
+    if (data.LockEndTime != null) {
+        contents.LockEndTime = __expectNonNull(__parseEpochTimestamp(__expectNumber(data.LockEndTime)));
+    }
+    if (data.LockState != null) {
+        contents.LockState = __expectString(data.LockState);
+    }
+    if (data.ResourceTags != null) {
+        contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.ResourceTags, context);
+    }
+    if (data.ResourceType != null) {
+        contents.ResourceType = __expectString(data.ResourceType);
+    }
+    if (data.RetentionPeriod != null) {
+        contents.RetentionPeriod = deserializeAws_restJson1RetentionPeriod(data.RetentionPeriod, context);
+    }
+    if (data.Status != null) {
+        contents.Status = __expectString(data.Status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UnlockRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.rbin#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.rbin#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.rbin#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.rbin#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
 export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
     if (output.statusCode !== 204 && output.statusCode >= 300) {
         return deserializeAws_restJson1UntagResourceCommandError(output, context);
@@ -486,6 +679,12 @@ export const deserializeAws_restJson1UpdateRuleCommand = async (output, context)
     if (data.Identifier != null) {
         contents.Identifier = __expectString(data.Identifier);
     }
+    if (data.LockEndTime != null) {
+        contents.LockEndTime = __expectNonNull(__parseEpochTimestamp(__expectNumber(data.LockEndTime)));
+    }
+    if (data.LockState != null) {
+        contents.LockState = __expectString(data.LockState);
+    }
     if (data.ResourceTags != null) {
         contents.ResourceTags = deserializeAws_restJson1ResourceTags(data.ResourceTags, context);
     }
@@ -507,6 +706,9 @@ const deserializeAws_restJson1UpdateRuleCommandError = async (output, context) =
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.rbin#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
         case "InternalServerException":
         case "com.amazonaws.rbin#InternalServerException":
             throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
@@ -527,6 +729,21 @@ const deserializeAws_restJson1UpdateRuleCommandError = async (output, context) =
     }
 };
 const map = __map;
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.Message != null) {
+        contents.Message = __expectString(data.Message);
+    }
+    if (data.Reason != null) {
+        contents.Reason = __expectString(data.Reason);
+    }
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -584,6 +801,11 @@ const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput,
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const serializeAws_restJson1LockConfiguration = (input, context) => {
+    return {
+        ...(input.UnlockDelay != null && { UnlockDelay: serializeAws_restJson1UnlockDelay(input.UnlockDelay, context) }),
+    };
+};
 const serializeAws_restJson1ResourceTag = (input, context) => {
     return {
         ...(input.ResourceTagKey != null && { ResourceTagKey: input.ResourceTagKey }),
@@ -616,6 +838,17 @@ const serializeAws_restJson1TagList = (input, context) => {
         return serializeAws_restJson1Tag(entry, context);
     });
 };
+const serializeAws_restJson1UnlockDelay = (input, context) => {
+    return {
+        ...(input.UnlockDelayUnit != null && { UnlockDelayUnit: input.UnlockDelayUnit }),
+        ...(input.UnlockDelayValue != null && { UnlockDelayValue: input.UnlockDelayValue }),
+    };
+};
+const deserializeAws_restJson1LockConfiguration = (output, context) => {
+    return {
+        UnlockDelay: output.UnlockDelay != null ? deserializeAws_restJson1UnlockDelay(output.UnlockDelay, context) : undefined,
+    };
+};
 const deserializeAws_restJson1ResourceTag = (output, context) => {
     return {
         ResourceTagKey: __expectString(output.ResourceTagKey),
@@ -643,6 +876,7 @@ const deserializeAws_restJson1RuleSummary = (output, context) => {
     return {
         Description: __expectString(output.Description),
         Identifier: __expectString(output.Identifier),
+        LockState: __expectString(output.LockState),
         RetentionPeriod: output.RetentionPeriod != null
             ? deserializeAws_restJson1RetentionPeriod(output.RetentionPeriod, context)
             : undefined,
@@ -676,6 +910,12 @@ const deserializeAws_restJson1TagList = (output, context) => {
     });
     return retVal;
 };
+const deserializeAws_restJson1UnlockDelay = (output, context) => {
+    return {
+        UnlockDelayUnit: __expectString(output.UnlockDelayUnit),
+        UnlockDelayValue: __expectInt32(output.UnlockDelayValue),
+    };
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-types/Rbin.d.ts

@@ -4,7 +4,9 @@ import { DeleteRuleCommandInput, DeleteRuleCommandOutput } from "./commands/Dele
 import { GetRuleCommandInput, GetRuleCommandOutput } from "./commands/GetRuleCommand";
 import { ListRulesCommandInput, ListRulesCommandOutput } from "./commands/ListRulesCommand";
 import { ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput } from "./commands/ListTagsForResourceCommand";
+import { LockRuleCommandInput, LockRuleCommandOutput } from "./commands/LockRuleCommand";
 import { TagResourceCommandInput, TagResourceCommandOutput } from "./commands/TagResourceCommand";
+import { UnlockRuleCommandInput, UnlockRuleCommandOutput } from "./commands/UnlockRuleCommand";
 import { UntagResourceCommandInput, UntagResourceCommandOutput } from "./commands/UntagResourceCommand";
 import { UpdateRuleCommandInput, UpdateRuleCommandOutput } from "./commands/UpdateRuleCommand";
 import { RbinClient } from "./RbinClient";
@@ -57,12 +59,25 @@ export declare class Rbin extends RbinClient {
     listTagsForResource(args: ListTagsForResourceCommandInput, options?: __HttpHandlerOptions): Promise<ListTagsForResourceCommandOutput>;
     listTagsForResource(args: ListTagsForResourceCommandInput, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
     listTagsForResource(args: ListTagsForResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListTagsForResourceCommandOutput) => void): void;
+    /**
+     * <p>Locks a retention rule. A locked retention rule can't be modified or deleted.</p>
+     */
+    lockRule(args: LockRuleCommandInput, options?: __HttpHandlerOptions): Promise<LockRuleCommandOutput>;
+    lockRule(args: LockRuleCommandInput, cb: (err: any, data?: LockRuleCommandOutput) => void): void;
+    lockRule(args: LockRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: LockRuleCommandOutput) => void): void;
     /**
      * <p>Assigns tags to the specified retention rule.</p>
      */
     tagResource(args: TagResourceCommandInput, options?: __HttpHandlerOptions): Promise<TagResourceCommandOutput>;
     tagResource(args: TagResourceCommandInput, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
     tagResource(args: TagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TagResourceCommandOutput) => void): void;
+    /**
+     * <p>Unlocks a retention rule. After a retention rule is unlocked, it can be modified or deleted
+     *       only after the unlock delay period expires.</p>
+     */
+    unlockRule(args: UnlockRuleCommandInput, options?: __HttpHandlerOptions): Promise<UnlockRuleCommandOutput>;
+    unlockRule(args: UnlockRuleCommandInput, cb: (err: any, data?: UnlockRuleCommandOutput) => void): void;
+    unlockRule(args: UnlockRuleCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UnlockRuleCommandOutput) => void): void;
     /**
      * <p>Unassigns a tag from a retention rule.</p>
      */
@@ -70,7 +85,9 @@ export declare class Rbin extends RbinClient {
     untagResource(args: UntagResourceCommandInput, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     untagResource(args: UntagResourceCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UntagResourceCommandOutput) => void): void;
     /**
-     * <p>Updates an existing Recycle Bin retention rule. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin-working-with-rules.html#recycle-bin-update-rule">
+     * <p>Updates an existing Recycle Bin retention rule. You can update a retention rule's description,
+     *       resource tags, and retention period at any time after creation. You can't update a retention rule's
+     *       resource type after creation. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/recycle-bin-working-with-rules.html#recycle-bin-update-rule">
      *       Update Recycle Bin retention rules</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>
      */
     updateRule(args: UpdateRuleCommandInput, options?: __HttpHandlerOptions): Promise<UpdateRuleCommandOutput>;