@aws-sdk/client-backup 3.31.0 → 3.35.0

package/src/commands/StopBackupJobCommand.ts

@@ -0,0 +1,95 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { StopBackupJobInput } from "../models/models_0";
+import {
+  deserializeAws_restJson1StopBackupJobCommand,
+  serializeAws_restJson1StopBackupJobCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface StopBackupJobCommandInput extends StopBackupJobInput {}
+export interface StopBackupJobCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Attempts to cancel a job to create a one-time backup of a resource.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, StopBackupJobCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, StopBackupJobCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new StopBackupJobCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopBackupJobCommandInput} for command's `input` shape.
+ * @see {@link StopBackupJobCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class StopBackupJobCommand extends $Command<
+  StopBackupJobCommandInput,
+  StopBackupJobCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: StopBackupJobCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<StopBackupJobCommandInput, StopBackupJobCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "StopBackupJobCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: StopBackupJobInput.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: StopBackupJobCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1StopBackupJobCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<StopBackupJobCommandOutput> {
+    return deserializeAws_restJson1StopBackupJobCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/TagResourceCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { TagResourceInput } from "../models/models_0";
+import {
+  deserializeAws_restJson1TagResourceCommand,
+  serializeAws_restJson1TagResourceCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface TagResourceCommandInput extends TagResourceInput {}
+export interface TagResourceCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Assigns a set of key-value pairs to a recovery point, backup plan, or backup vault
+ *          identified by an Amazon Resource Name (ARN).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, TagResourceCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, TagResourceCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new TagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link TagResourceCommandInput} for command's `input` shape.
+ * @see {@link TagResourceCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class TagResourceCommand extends $Command<
+  TagResourceCommandInput,
+  TagResourceCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: TagResourceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<TagResourceCommandInput, TagResourceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "TagResourceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: TagResourceInput.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: TagResourceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1TagResourceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<TagResourceCommandOutput> {
+    return deserializeAws_restJson1TagResourceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/UntagResourceCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { UntagResourceInput } from "../models/models_0";
+import {
+  deserializeAws_restJson1UntagResourceCommand,
+  serializeAws_restJson1UntagResourceCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface UntagResourceCommandInput extends UntagResourceInput {}
+export interface UntagResourceCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Removes a set of key-value pairs from a recovery point, backup plan, or backup vault
+ *          identified by an Amazon Resource Name (ARN)</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, UntagResourceCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, UntagResourceCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new UntagResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UntagResourceCommandInput} for command's `input` shape.
+ * @see {@link UntagResourceCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class UntagResourceCommand extends $Command<
+  UntagResourceCommandInput,
+  UntagResourceCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: UntagResourceCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<UntagResourceCommandInput, UntagResourceCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "UntagResourceCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: UntagResourceInput.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: UntagResourceCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1UntagResourceCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UntagResourceCommandOutput> {
+    return deserializeAws_restJson1UntagResourceCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/UpdateBackupPlanCommand.ts

@@ -0,0 +1,97 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { UpdateBackupPlanInput, UpdateBackupPlanOutput } from "../models/models_0";
+import {
+  deserializeAws_restJson1UpdateBackupPlanCommand,
+  serializeAws_restJson1UpdateBackupPlanCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface UpdateBackupPlanCommandInput extends UpdateBackupPlanInput {}
+export interface UpdateBackupPlanCommandOutput extends UpdateBackupPlanOutput, __MetadataBearer {}
+
+/**
+ * <p>Updates an existing backup plan identified by its <code>backupPlanId</code> with the
+ *          input document in JSON format. The new version is uniquely identified by a
+ *             <code>VersionId</code>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, UpdateBackupPlanCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, UpdateBackupPlanCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new UpdateBackupPlanCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateBackupPlanCommandInput} for command's `input` shape.
+ * @see {@link UpdateBackupPlanCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class UpdateBackupPlanCommand extends $Command<
+  UpdateBackupPlanCommandInput,
+  UpdateBackupPlanCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: UpdateBackupPlanCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<UpdateBackupPlanCommandInput, UpdateBackupPlanCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "UpdateBackupPlanCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: UpdateBackupPlanInput.filterSensitiveLog,
+      outputFilterSensitiveLog: UpdateBackupPlanOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: UpdateBackupPlanCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1UpdateBackupPlanCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateBackupPlanCommandOutput> {
+    return deserializeAws_restJson1UpdateBackupPlanCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/UpdateFrameworkCommand.ts

@@ -0,0 +1,96 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { UpdateFrameworkInput, UpdateFrameworkOutput } from "../models/models_0";
+import {
+  deserializeAws_restJson1UpdateFrameworkCommand,
+  serializeAws_restJson1UpdateFrameworkCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface UpdateFrameworkCommandInput extends UpdateFrameworkInput {}
+export interface UpdateFrameworkCommandOutput extends UpdateFrameworkOutput, __MetadataBearer {}
+
+/**
+ * <p>Updates an existing framework identified by its <code>FrameworkName</code> with the
+ *          input document in JSON format.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, UpdateFrameworkCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, UpdateFrameworkCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new UpdateFrameworkCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFrameworkCommandInput} for command's `input` shape.
+ * @see {@link UpdateFrameworkCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class UpdateFrameworkCommand extends $Command<
+  UpdateFrameworkCommandInput,
+  UpdateFrameworkCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: UpdateFrameworkCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<UpdateFrameworkCommandInput, UpdateFrameworkCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "UpdateFrameworkCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: UpdateFrameworkInput.filterSensitiveLog,
+      outputFilterSensitiveLog: UpdateFrameworkOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: UpdateFrameworkCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1UpdateFrameworkCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateFrameworkCommandOutput> {
+    return deserializeAws_restJson1UpdateFrameworkCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/UpdateGlobalSettingsCommand.ts

@@ -0,0 +1,97 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { UpdateGlobalSettingsInput } from "../models/models_0";
+import {
+  deserializeAws_restJson1UpdateGlobalSettingsCommand,
+  serializeAws_restJson1UpdateGlobalSettingsCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface UpdateGlobalSettingsCommandInput extends UpdateGlobalSettingsInput {}
+export interface UpdateGlobalSettingsCommandOutput extends __MetadataBearer {}
+
+/**
+ * <p>Updates whether the Amazon Web Services account is opted in to cross-account backup.
+ *          Returns an error if the account is not an Organizations management account. Use the
+ *             <code>DescribeGlobalSettings</code> API to determine the current settings.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, UpdateGlobalSettingsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, UpdateGlobalSettingsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new UpdateGlobalSettingsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateGlobalSettingsCommandInput} for command's `input` shape.
+ * @see {@link UpdateGlobalSettingsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class UpdateGlobalSettingsCommand extends $Command<
+  UpdateGlobalSettingsCommandInput,
+  UpdateGlobalSettingsCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: UpdateGlobalSettingsCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<UpdateGlobalSettingsCommandInput, UpdateGlobalSettingsCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "UpdateGlobalSettingsCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: UpdateGlobalSettingsInput.filterSensitiveLog,
+      outputFilterSensitiveLog: (output: any) => output,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: UpdateGlobalSettingsCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1UpdateGlobalSettingsCommand(input, context);
+  }
+
+  private deserialize(output: __HttpResponse, context: __SerdeContext): Promise<UpdateGlobalSettingsCommandOutput> {
+    return deserializeAws_restJson1UpdateGlobalSettingsCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}

package/src/commands/UpdateRecoveryPointLifecycleCommand.ts

@@ -0,0 +1,109 @@
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import {
+  FinalizeHandlerArguments,
+  Handler,
+  HandlerExecutionContext,
+  HttpHandlerOptions as __HttpHandlerOptions,
+  MetadataBearer as __MetadataBearer,
+  MiddlewareStack,
+  SerdeContext as __SerdeContext,
+} from "@aws-sdk/types";
+
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { UpdateRecoveryPointLifecycleInput, UpdateRecoveryPointLifecycleOutput } from "../models/models_0";
+import {
+  deserializeAws_restJson1UpdateRecoveryPointLifecycleCommand,
+  serializeAws_restJson1UpdateRecoveryPointLifecycleCommand,
+} from "../protocols/Aws_restJson1";
+
+export interface UpdateRecoveryPointLifecycleCommandInput extends UpdateRecoveryPointLifecycleInput {}
+export interface UpdateRecoveryPointLifecycleCommandOutput
+  extends UpdateRecoveryPointLifecycleOutput,
+    __MetadataBearer {}
+
+/**
+ * <p>Sets the transition lifecycle of a recovery point.</p>
+ *          <p>The lifecycle defines when a protected resource is transitioned to cold storage and when
+ *          it expires. Backup transitions and expires backups automatically according to
+ *          the lifecycle that you define.</p>
+ *          <p>Backups transitioned to cold storage must be stored in cold storage for a minimum of 90
+ *          days. Therefore, the “expire after days” setting must be 90 days greater than the
+ *          “transition to cold after days” setting. The “transition to cold after days” setting cannot
+ *          be changed after a backup has been transitioned to cold.</p>
+ *          <p>Only Amazon EFS file system backups can be transitioned to cold storage.</p>
+ *          <p>Does not support continuous backups.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, UpdateRecoveryPointLifecycleCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, UpdateRecoveryPointLifecycleCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new UpdateRecoveryPointLifecycleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateRecoveryPointLifecycleCommandInput} for command's `input` shape.
+ * @see {@link UpdateRecoveryPointLifecycleCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export class UpdateRecoveryPointLifecycleCommand extends $Command<
+  UpdateRecoveryPointLifecycleCommandInput,
+  UpdateRecoveryPointLifecycleCommandOutput,
+  BackupClientResolvedConfig
+> {
+  // Start section: command_properties
+  // End section: command_properties
+
+  constructor(readonly input: UpdateRecoveryPointLifecycleCommandInput) {
+    // Start section: command_constructor
+    super();
+    // End section: command_constructor
+  }
+
+  /**
+   * @internal
+   */
+  resolveMiddleware(
+    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
+    configuration: BackupClientResolvedConfig,
+    options?: __HttpHandlerOptions
+  ): Handler<UpdateRecoveryPointLifecycleCommandInput, UpdateRecoveryPointLifecycleCommandOutput> {
+    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+
+    const stack = clientStack.concat(this.middlewareStack);
+
+    const { logger } = configuration;
+    const clientName = "BackupClient";
+    const commandName = "UpdateRecoveryPointLifecycleCommand";
+    const handlerExecutionContext: HandlerExecutionContext = {
+      logger,
+      clientName,
+      commandName,
+      inputFilterSensitiveLog: UpdateRecoveryPointLifecycleInput.filterSensitiveLog,
+      outputFilterSensitiveLog: UpdateRecoveryPointLifecycleOutput.filterSensitiveLog,
+    };
+    const { requestHandler } = configuration;
+    return stack.resolve(
+      (request: FinalizeHandlerArguments<any>) =>
+        requestHandler.handle(request.request as __HttpRequest, options || {}),
+      handlerExecutionContext
+    );
+  }
+
+  private serialize(input: UpdateRecoveryPointLifecycleCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
+    return serializeAws_restJson1UpdateRecoveryPointLifecycleCommand(input, context);
+  }
+
+  private deserialize(
+    output: __HttpResponse,
+    context: __SerdeContext
+  ): Promise<UpdateRecoveryPointLifecycleCommandOutput> {
+    return deserializeAws_restJson1UpdateRecoveryPointLifecycleCommand(output, context);
+  }
+
+  // Start section: command_body_extra
+  // End section: command_body_extra
+}