@aws-sdk/client-rbin 3.215.0 → 3.217.0

package/dist-types/commands/LockRuleCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { LockRuleRequest, LockRuleResponse } from "../models/models_0";
+import { RbinClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RbinClient";
+export interface LockRuleCommandInput extends LockRuleRequest {
+}
+export interface LockRuleCommandOutput extends LockRuleResponse, __MetadataBearer {
+}
+/**
+ * <p>Locks a retention rule. A locked retention rule can't be modified or deleted.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RbinClient, LockRuleCommand } from "@aws-sdk/client-rbin"; // ES Modules import
+ * // const { RbinClient, LockRuleCommand } = require("@aws-sdk/client-rbin"); // CommonJS import
+ * const client = new RbinClient(config);
+ * const command = new LockRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link LockRuleCommandInput} for command's `input` shape.
+ * @see {@link LockRuleCommandOutput} for command's `response` shape.
+ * @see {@link RbinClientResolvedConfig | config} for RbinClient's `config` shape.
+ *
+ */
+export declare class LockRuleCommand extends $Command<LockRuleCommandInput, LockRuleCommandOutput, RbinClientResolvedConfig> {
+    readonly input: LockRuleCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: LockRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RbinClientResolvedConfig, options?: __HttpHandlerOptions): Handler<LockRuleCommandInput, LockRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UnlockRuleCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UnlockRuleRequest, UnlockRuleResponse } from "../models/models_0";
+import { RbinClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RbinClient";
+export interface UnlockRuleCommandInput extends UnlockRuleRequest {
+}
+export interface UnlockRuleCommandOutput extends UnlockRuleResponse, __MetadataBearer {
+}
+/**
+ * <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>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RbinClient, UnlockRuleCommand } from "@aws-sdk/client-rbin"; // ES Modules import
+ * // const { RbinClient, UnlockRuleCommand } = require("@aws-sdk/client-rbin"); // CommonJS import
+ * const client = new RbinClient(config);
+ * const command = new UnlockRuleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UnlockRuleCommandInput} for command's `input` shape.
+ * @see {@link UnlockRuleCommandOutput} for command's `response` shape.
+ * @see {@link RbinClientResolvedConfig | config} for RbinClient's `config` shape.
+ *
+ */
+export declare class UnlockRuleCommand extends $Command<UnlockRuleCommandInput, UnlockRuleCommandOutput, RbinClientResolvedConfig> {
+    readonly input: UnlockRuleCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UnlockRuleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RbinClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UnlockRuleCommandInput, UnlockRuleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateRuleCommand.d.ts

@@ -8,7 +8,9 @@ export interface UpdateRuleCommandInput extends UpdateRuleRequest {
 export interface UpdateRuleCommandOutput extends UpdateRuleResponse, __MetadataBearer {
 }
 /**
- * <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>
  * @example
  * Use a bare-bones client and the command you need to make an API call.

package/dist-types/commands/index.d.ts

@@ -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-types/endpoint/EndpointParameters.d.ts

@@ -12,7 +12,7 @@ export declare const resolveClientEndpointParameters: <T>(options: T & ClientInp
     defaultSigningName: string;
 };
 export interface EndpointParameters extends __EndpointParameters {
-    Region?: string;
+    Region: string;
     UseDualStack?: boolean;
     UseFIPS?: boolean;
     Endpoint?: string;

package/dist-types/models/models_0.d.ts

@@ -1,5 +1,34 @@
 import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
 import { RbinServiceException as __BaseException } from "./RbinServiceException";
+export declare enum UnlockDelayUnit {
+    DAYS = "DAYS"
+}
+/**
+ * <p>Information about the retention rule unlock delay. The unlock delay is the period after which
+ *       a retention rule can be modified or edited after it has been unlocked by a user with the required
+ *       permissions. The retention rule can't be modified or deleted during the unlock delay.</p>
+ */
+export interface UnlockDelay {
+    /**
+     * <p>The unlock delay period, measured in the unit specified for <b>
+     *       UnlockDelayUnit</b>.</p>
+     */
+    UnlockDelayValue: number | undefined;
+    /**
+     * <p>The unit of time in which to measure the unlock delay. Currently, the unlock delay can
+     *       be measure only in days.</p>
+     */
+    UnlockDelayUnit: UnlockDelayUnit | string | undefined;
+}
+/**
+ * <p>Information about a retention rule lock configuration.</p>
+ */
+export interface LockConfiguration {
+    /**
+     * <p>Information about the retention rule unlock delay.</p>
+     */
+    UnlockDelay: UnlockDelay | undefined;
+}
 /**
  * <p>Information about the resource tags used to identify resources that are retained by the retention
  *       rule.</p>
@@ -79,6 +108,15 @@ export interface CreateRuleRequest {
      *       resource type in the Region in which the rule is created, even if the resources are not tagged.</p>
      */
     ResourceTags?: ResourceTag[];
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration?: LockConfiguration;
+}
+export declare enum LockState {
+    LOCKED = "locked",
+    PENDING_UNLOCK = "pending_unlock",
+    UNLOCKED = "unlocked"
 }
 export declare enum RuleStatus {
     AVAILABLE = "available",
@@ -115,6 +153,37 @@ export interface CreateRuleResponse {
      *       state retain resources.</p>
      */
     Status?: RuleStatus | string;
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration?: LockConfiguration;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
 }
 /**
  * <p>The service could not respond to the request due to an internal problem.</p>
@@ -167,6 +236,25 @@ export declare class ValidationException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
 }
+export declare enum ConflictExceptionReason {
+    INVALID_RULE_STATE = "INVALID_RULE_STATE"
+}
+/**
+ * <p>The specified retention rule lock request can't be completed.</p>
+ */
+export declare class ConflictException extends __BaseException {
+    readonly name: "ConflictException";
+    readonly $fault: "client";
+    Message?: string;
+    /**
+     * <p>The reason for the exception.</p>
+     */
+    Reason?: ConflictExceptionReason | string;
+    /**
+     * @internal
+     */
+    constructor(opts: __ExceptionOptionType<ConflictException, __BaseException>);
+}
 export interface DeleteRuleRequest {
     /**
      * <p>The unique ID of the retention rule.</p>
@@ -227,6 +315,43 @@ export interface GetRuleResponse {
      *       state retain resources.</p>
      */
     Status?: RuleStatus | string;
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration?: LockConfiguration;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
+    /**
+     * <p>The date and time at which the unlock delay is set to expire. Only returned
+     *       for retention rules that have been unlocked and that are still within the unlock
+     *       delay period.</p>
+     */
+    LockEndTime?: Date;
 }
 export interface ListRulesRequest {
     /**
@@ -251,6 +376,11 @@ export interface ListRulesRequest {
      *       rule.</p>
      */
     ResourceTags?: ResourceTag[];
+    /**
+     * <p>The lock state of the retention rules to list. Only retention rules with the specified
+     *       lock state are returned.</p>
+     */
+    LockState?: LockState | string;
 }
 /**
  * <p>Information about a Recycle Bin retention rule.</p>
@@ -268,6 +398,33 @@ export interface RuleSummary {
      * <p>Information about the retention period for which the retention rule is to retain resources.</p>
      */
     RetentionPeriod?: RetentionPeriod;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
 }
 export interface ListRulesResponse {
     /**
@@ -291,6 +448,75 @@ export interface ListTagsForResourceResponse {
      */
     Tags?: Tag[];
 }
+export interface LockRuleRequest {
+    /**
+     * <p>The unique ID of the retention rule.</p>
+     */
+    Identifier: string | undefined;
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration: LockConfiguration | undefined;
+}
+export interface LockRuleResponse {
+    /**
+     * <p>The unique ID of the retention rule.</p>
+     */
+    Identifier?: string;
+    /**
+     * <p>The retention rule description.</p>
+     */
+    Description?: string;
+    /**
+     * <p>The resource type retained by the retention rule.</p>
+     */
+    ResourceType?: ResourceType | string;
+    /**
+     * <p>Information about the retention period for which the retention rule is to retain resources.</p>
+     */
+    RetentionPeriod?: RetentionPeriod;
+    /**
+     * <p>Information about the resource tags used to identify resources that are retained by the retention
+     *       rule.</p>
+     */
+    ResourceTags?: ResourceTag[];
+    /**
+     * <p>The state of the retention rule. Only retention rules that are in the <code>available</code>
+     *       state retain resources.</p>
+     */
+    Status?: RuleStatus | string;
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration?: LockConfiguration;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
+}
 export interface TagResourceRequest {
     /**
      * <p>The Amazon Resource Name (ARN) of the retention rule.</p>
@@ -303,6 +529,77 @@ export interface TagResourceRequest {
 }
 export interface TagResourceResponse {
 }
+export interface UnlockRuleRequest {
+    /**
+     * <p>The unique ID of the retention rule.</p>
+     */
+    Identifier: string | undefined;
+}
+export interface UnlockRuleResponse {
+    /**
+     * <p>The unique ID of the retention rule.</p>
+     */
+    Identifier?: string;
+    /**
+     * <p>The retention rule description.</p>
+     */
+    Description?: string;
+    /**
+     * <p>The resource type retained by the retention rule.</p>
+     */
+    ResourceType?: ResourceType | string;
+    /**
+     * <p>Information about the retention period for which the retention rule is to retain resources.</p>
+     */
+    RetentionPeriod?: RetentionPeriod;
+    /**
+     * <p>Information about the resource tags used to identify resources that are retained by the retention
+     *       rule.</p>
+     */
+    ResourceTags?: ResourceTag[];
+    /**
+     * <p>The state of the retention rule. Only retention rules that are in the <code>available</code>
+     *       state retain resources.</p>
+     */
+    Status?: RuleStatus | string;
+    /**
+     * <p>Information about the retention rule lock configuration.</p>
+     */
+    LockConfiguration?: LockConfiguration;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
+    /**
+     * <p>The date and time at which the unlock delay is set to expire. Only returned
+     *       for retention rules that have been unlocked and that are still within the unlock
+     *       delay period.</p>
+     */
+    LockEndTime?: Date;
+}
 export interface UntagResourceRequest {
     /**
      * <p>The Amazon Resource Name (ARN) of the retention rule.</p>
@@ -329,9 +626,10 @@ export interface UpdateRuleRequest {
      */
     Description?: string;
     /**
-     * <p>The resource type to be retained by the retention rule. Currently, only Amazon EBS snapshots
-     *       and EBS-backed AMIs are supported. To retain snapshots, specify <code>EBS_SNAPSHOT</code>. To
-     *       retain EBS-backed AMIs, specify <code>EC2_IMAGE</code>.</p>
+     * <note>
+     *             <p>This parameter is currently not supported. You can't update a retention rule's resource type
+     *       after creation.</p>
+     *          </note>
      */
     ResourceType?: ResourceType | string;
     /**
@@ -373,7 +671,48 @@ export interface UpdateRuleResponse {
      *       state retain resources.</p>
      */
     Status?: RuleStatus | string;
+    /**
+     * <p>The lock state for the retention rule.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>locked</code> - The retention rule is locked and can't be modified or deleted.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>pending_unlock</code> - The retention rule has been unlocked but it is still within
+     *           the unlock delay period. The retention rule can be modified or deleted only after the unlock
+     *           delay period has expired.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>unlocked</code> - The retention rule is unlocked and it can be modified or deleted by
+     *           any user with the required permissions.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>null</code> - The retention rule has never been locked. Once a retention rule has
+     *         been locked, it can transition between the <code>locked</code> and <code>unlocked</code> states
+     *         only; it can never transition back to <code>null</code>.</p>
+     *             </li>
+     *          </ul>
+     */
+    LockState?: LockState | string;
+    /**
+     * <p>The date and time at which the unlock delay is set to expire. Only returned
+     *       for retention rules that have been unlocked and that are still within the unlock
+     *       delay period.</p>
+     */
+    LockEndTime?: Date;
 }
+/**
+ * @internal
+ */
+export declare const UnlockDelayFilterSensitiveLog: (obj: UnlockDelay) => any;
+/**
+ * @internal
+ */
+export declare const LockConfigurationFilterSensitiveLog: (obj: LockConfiguration) => any;
 /**
  * @internal
  */
@@ -430,6 +769,14 @@ export declare const ListTagsForResourceRequestFilterSensitiveLog: (obj: ListTag
  * @internal
  */
 export declare const ListTagsForResourceResponseFilterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+/**
+ * @internal
+ */
+export declare const LockRuleRequestFilterSensitiveLog: (obj: LockRuleRequest) => any;
+/**
+ * @internal
+ */
+export declare const LockRuleResponseFilterSensitiveLog: (obj: LockRuleResponse) => any;
 /**
  * @internal
  */
@@ -438,6 +785,14 @@ export declare const TagResourceRequestFilterSensitiveLog: (obj: TagResourceRequ
  * @internal
  */
 export declare const TagResourceResponseFilterSensitiveLog: (obj: TagResourceResponse) => any;
+/**
+ * @internal
+ */
+export declare const UnlockRuleRequestFilterSensitiveLog: (obj: UnlockRuleRequest) => any;
+/**
+ * @internal
+ */
+export declare const UnlockRuleResponseFilterSensitiveLog: (obj: UnlockRuleResponse) => any;
 /**
  * @internal
  */

package/dist-types/protocols/Aws_restJson1.d.ts

@@ -5,7 +5,9 @@ import { DeleteRuleCommandInput, DeleteRuleCommandOutput } from "../commands/Del
 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";
 export declare const serializeAws_restJson1CreateRuleCommand: (input: CreateRuleCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
@@ -13,7 +15,9 @@ export declare const serializeAws_restJson1DeleteRuleCommand: (input: DeleteRule
 export declare const serializeAws_restJson1GetRuleCommand: (input: GetRuleCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1ListRulesCommand: (input: ListRulesCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1ListTagsForResourceCommand: (input: ListTagsForResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1LockRuleCommand: (input: LockRuleCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1TagResourceCommand: (input: TagResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1UnlockRuleCommand: (input: UnlockRuleCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1UntagResourceCommand: (input: UntagResourceCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const serializeAws_restJson1UpdateRuleCommand: (input: UpdateRuleCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
 export declare const deserializeAws_restJson1CreateRuleCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CreateRuleCommandOutput>;
@@ -21,6 +25,8 @@ export declare const deserializeAws_restJson1DeleteRuleCommand: (output: __HttpR
 export declare const deserializeAws_restJson1GetRuleCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<GetRuleCommandOutput>;
 export declare const deserializeAws_restJson1ListRulesCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListRulesCommandOutput>;
 export declare const deserializeAws_restJson1ListTagsForResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ListTagsForResourceCommandOutput>;
+export declare const deserializeAws_restJson1LockRuleCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<LockRuleCommandOutput>;
 export declare const deserializeAws_restJson1TagResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<TagResourceCommandOutput>;
+export declare const deserializeAws_restJson1UnlockRuleCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UnlockRuleCommandOutput>;
 export declare const deserializeAws_restJson1UntagResourceCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UntagResourceCommandOutput>;
 export declare const deserializeAws_restJson1UpdateRuleCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<UpdateRuleCommandOutput>;

package/dist-types/ts3.4/Rbin.d.ts

@@ -19,10 +19,18 @@ 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,
@@ -98,6 +106,19 @@ export declare class Rbin extends RbinClient {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: ListTagsForResourceCommandOutput) => void
   ): void;
+  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;
   tagResource(
     args: TagResourceCommandInput,
     options?: __HttpHandlerOptions
@@ -111,6 +132,19 @@ export declare class Rbin extends RbinClient {
     options: __HttpHandlerOptions,
     cb: (err: any, data?: TagResourceCommandOutput) => void
   ): void;
+  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;
   untagResource(
     args: UntagResourceCommandInput,
     options?: __HttpHandlerOptions