@aws-sdk/client-backup 3.36.0 → 3.39.0

package/dist-types/ts3.4/commands/PutBackupVaultLockConfigurationCommand.d.ts

@@ -6,33 +6,11 @@ export interface PutBackupVaultLockConfigurationCommandInput extends PutBackupVa
 }
 export interface PutBackupVaultLockConfigurationCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Applies Backup Vault Lock to a backup vault, preventing attempts to delete
- *          any recovery point stored in or created in a backup vault. Vault Lock also prevents
- *          attempts to update the lifecycle policy that controls the retention period of any recovery
- *          point currently stored in a backup vault. If specified, Vault Lock enforces a minimum and
- *          maximum retention period for future backup and copy jobs that target a backup vault.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { BackupClient, PutBackupVaultLockConfigurationCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, PutBackupVaultLockConfigurationCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new PutBackupVaultLockConfigurationCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutBackupVaultLockConfigurationCommandInput} for command's `input` shape.
- * @see {@link PutBackupVaultLockConfigurationCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutBackupVaultLockConfigurationCommand extends $Command<PutBackupVaultLockConfigurationCommandInput, PutBackupVaultLockConfigurationCommandOutput, BackupClientResolvedConfig> {
     readonly input: PutBackupVaultLockConfigurationCommandInput;
     constructor(input: PutBackupVaultLockConfigurationCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutBackupVaultLockConfigurationCommandInput, PutBackupVaultLockConfigurationCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/PutBackupVaultNotificationsCommand.d.ts

@@ -6,29 +6,11 @@ export interface PutBackupVaultNotificationsCommandInput extends PutBackupVaultN
 }
 export interface PutBackupVaultNotificationsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Turns on notifications on a backup vault for the specified topic and events.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { BackupClient, PutBackupVaultNotificationsCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, PutBackupVaultNotificationsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new PutBackupVaultNotificationsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutBackupVaultNotificationsCommandInput} for command's `input` shape.
- * @see {@link PutBackupVaultNotificationsCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutBackupVaultNotificationsCommand extends $Command<PutBackupVaultNotificationsCommandInput, PutBackupVaultNotificationsCommandOutput, BackupClientResolvedConfig> {
     readonly input: PutBackupVaultNotificationsCommandInput;
     constructor(input: PutBackupVaultNotificationsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutBackupVaultNotificationsCommandInput, PutBackupVaultNotificationsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartBackupJobCommand.d.ts

@@ -6,29 +6,11 @@ export interface StartBackupJobCommandInput extends StartBackupJobInput {
 }
 export interface StartBackupJobCommandOutput extends StartBackupJobOutput, __MetadataBearer {
 }
-/**
- * <p>Starts an on-demand backup job for the specified resource.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { BackupClient, StartBackupJobCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, StartBackupJobCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new StartBackupJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartBackupJobCommandInput} for command's `input` shape.
- * @see {@link StartBackupJobCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartBackupJobCommand extends $Command<StartBackupJobCommandInput, StartBackupJobCommandOutput, BackupClientResolvedConfig> {
     readonly input: StartBackupJobCommandInput;
     constructor(input: StartBackupJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartBackupJobCommandInput, StartBackupJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartCopyJobCommand.d.ts

@@ -6,30 +6,11 @@ export interface StartCopyJobCommandInput extends StartCopyJobInput {
 }
 export interface StartCopyJobCommandOutput extends StartCopyJobOutput, __MetadataBearer {
 }
-/**
- * <p>Starts a job to create a one-time copy of the specified resource.</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, StartCopyJobCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, StartCopyJobCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new StartCopyJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartCopyJobCommandInput} for command's `input` shape.
- * @see {@link StartCopyJobCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartCopyJobCommand extends $Command<StartCopyJobCommandInput, StartCopyJobCommandOutput, BackupClientResolvedConfig> {
     readonly input: StartCopyJobCommandInput;
     constructor(input: StartCopyJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartCopyJobCommandInput, StartCopyJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartReportJobCommand.d.ts

@@ -6,29 +6,11 @@ export interface StartReportJobCommandInput extends StartReportJobInput {
 }
 export interface StartReportJobCommandOutput extends StartReportJobOutput, __MetadataBearer {
 }
-/**
- * <p>Starts an on-demand report job for the specified report plan.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { BackupClient, StartReportJobCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, StartReportJobCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new StartReportJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartReportJobCommandInput} for command's `input` shape.
- * @see {@link StartReportJobCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartReportJobCommand extends $Command<StartReportJobCommandInput, StartReportJobCommandOutput, BackupClientResolvedConfig> {
     readonly input: StartReportJobCommandInput;
     constructor(input: StartReportJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartReportJobCommandInput, StartReportJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StartRestoreJobCommand.d.ts

@@ -6,29 +6,11 @@ export interface StartRestoreJobCommandInput extends StartRestoreJobInput {
 }
 export interface StartRestoreJobCommandOutput extends StartRestoreJobOutput, __MetadataBearer {
 }
-/**
- * <p>Recovers the saved resource 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, StartRestoreJobCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, StartRestoreJobCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new StartRestoreJobCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartRestoreJobCommandInput} for command's `input` shape.
- * @see {@link StartRestoreJobCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartRestoreJobCommand extends $Command<StartRestoreJobCommandInput, StartRestoreJobCommandOutput, BackupClientResolvedConfig> {
     readonly input: StartRestoreJobCommandInput;
     constructor(input: StartRestoreJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartRestoreJobCommandInput, StartRestoreJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/StopBackupJobCommand.d.ts

@@ -6,29 +6,11 @@ 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 declare class StopBackupJobCommand extends $Command<StopBackupJobCommandInput, StopBackupJobCommandOutput, BackupClientResolvedConfig> {
     readonly input: StopBackupJobCommandInput;
     constructor(input: StopBackupJobCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopBackupJobCommandInput, StopBackupJobCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/TagResourceCommand.d.ts

@@ -6,30 +6,11 @@ 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 declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, BackupClientResolvedConfig> {
     readonly input: TagResourceCommandInput;
     constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UntagResourceCommand.d.ts

@@ -6,30 +6,11 @@ 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 declare class UntagResourceCommand extends $Command<UntagResourceCommandInput, UntagResourceCommandOutput, BackupClientResolvedConfig> {
     readonly input: UntagResourceCommandInput;
     constructor(input: UntagResourceCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UntagResourceCommandInput, UntagResourceCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateBackupPlanCommand.d.ts

@@ -6,31 +6,11 @@ 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 declare class UpdateBackupPlanCommand extends $Command<UpdateBackupPlanCommandInput, UpdateBackupPlanCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateBackupPlanCommandInput;
     constructor(input: UpdateBackupPlanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBackupPlanCommandInput, UpdateBackupPlanCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateFrameworkCommand.d.ts

@@ -6,30 +6,11 @@ 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 declare class UpdateFrameworkCommand extends $Command<UpdateFrameworkCommandInput, UpdateFrameworkCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateFrameworkCommandInput;
     constructor(input: UpdateFrameworkCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFrameworkCommandInput, UpdateFrameworkCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateGlobalSettingsCommand.d.ts

@@ -6,31 +6,11 @@ export interface UpdateGlobalSettingsCommandInput extends UpdateGlobalSettingsIn
 }
 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 declare class UpdateGlobalSettingsCommand extends $Command<UpdateGlobalSettingsCommandInput, UpdateGlobalSettingsCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateGlobalSettingsCommandInput;
     constructor(input: UpdateGlobalSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateGlobalSettingsCommandInput, UpdateGlobalSettingsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateRecoveryPointLifecycleCommand.d.ts

@@ -6,38 +6,11 @@ export interface UpdateRecoveryPointLifecycleCommandInput extends UpdateRecovery
 }
 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 declare class UpdateRecoveryPointLifecycleCommand extends $Command<UpdateRecoveryPointLifecycleCommandInput, UpdateRecoveryPointLifecycleCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateRecoveryPointLifecycleCommandInput;
     constructor(input: UpdateRecoveryPointLifecycleCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRecoveryPointLifecycleCommandInput, UpdateRecoveryPointLifecycleCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateRegionSettingsCommand.d.ts

@@ -6,34 +6,11 @@ export interface UpdateRegionSettingsCommandInput extends UpdateRegionSettingsIn
 }
 export interface UpdateRegionSettingsCommandOutput extends __MetadataBearer {
 }
-/**
- * <p>Updates the current service opt-in settings for the Region. If service-opt-in is enabled
- *          for a service, Backup tries to protect that service's resources in this Region,
- *          when the resource is included in an on-demand backup or scheduled backup plan. Otherwise,
- *             Backup does not try to protect that service's resources in this Region. Use
- *          the <code>DescribeRegionSettings</code> API to determine the resource types that are
- *          supported.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { BackupClient, UpdateRegionSettingsCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, UpdateRegionSettingsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new UpdateRegionSettingsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateRegionSettingsCommandInput} for command's `input` shape.
- * @see {@link UpdateRegionSettingsCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateRegionSettingsCommand extends $Command<UpdateRegionSettingsCommandInput, UpdateRegionSettingsCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateRegionSettingsCommandInput;
     constructor(input: UpdateRegionSettingsCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateRegionSettingsCommandInput, UpdateRegionSettingsCommandOutput>;
     private serialize;
     private deserialize;

package/dist-types/ts3.4/commands/UpdateReportPlanCommand.d.ts

@@ -6,30 +6,11 @@ export interface UpdateReportPlanCommandInput extends UpdateReportPlanInput {
 }
 export interface UpdateReportPlanCommandOutput extends UpdateReportPlanOutput, __MetadataBearer {
 }
-/**
- * <p>Updates an existing report plan identified by its <code>ReportPlanName</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, UpdateReportPlanCommand } from "@aws-sdk/client-backup"; // ES Modules import
- * // const { BackupClient, UpdateReportPlanCommand } = require("@aws-sdk/client-backup"); // CommonJS import
- * const client = new BackupClient(config);
- * const command = new UpdateReportPlanCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link UpdateReportPlanCommandInput} for command's `input` shape.
- * @see {@link UpdateReportPlanCommandOutput} for command's `response` shape.
- * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class UpdateReportPlanCommand extends $Command<UpdateReportPlanCommandInput, UpdateReportPlanCommandOutput, BackupClientResolvedConfig> {
     readonly input: UpdateReportPlanCommandInput;
     constructor(input: UpdateReportPlanCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateReportPlanCommandInput, UpdateReportPlanCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,66 @@
+export * from "./CreateBackupPlanCommand";
+export * from "./CreateBackupSelectionCommand";
+export * from "./CreateBackupVaultCommand";
+export * from "./CreateFrameworkCommand";
+export * from "./CreateReportPlanCommand";
+export * from "./DeleteBackupPlanCommand";
+export * from "./DeleteBackupSelectionCommand";
+export * from "./DeleteBackupVaultAccessPolicyCommand";
+export * from "./DeleteBackupVaultCommand";
+export * from "./DeleteBackupVaultLockConfigurationCommand";
+export * from "./DeleteBackupVaultNotificationsCommand";
+export * from "./DeleteFrameworkCommand";
+export * from "./DeleteRecoveryPointCommand";
+export * from "./DeleteReportPlanCommand";
+export * from "./DescribeBackupJobCommand";
+export * from "./DescribeBackupVaultCommand";
+export * from "./DescribeCopyJobCommand";
+export * from "./DescribeFrameworkCommand";
+export * from "./DescribeGlobalSettingsCommand";
+export * from "./DescribeProtectedResourceCommand";
+export * from "./DescribeRecoveryPointCommand";
+export * from "./DescribeRegionSettingsCommand";
+export * from "./DescribeReportJobCommand";
+export * from "./DescribeReportPlanCommand";
+export * from "./DescribeRestoreJobCommand";
+export * from "./DisassociateRecoveryPointCommand";
+export * from "./ExportBackupPlanTemplateCommand";
+export * from "./GetBackupPlanCommand";
+export * from "./GetBackupPlanFromJSONCommand";
+export * from "./GetBackupPlanFromTemplateCommand";
+export * from "./GetBackupSelectionCommand";
+export * from "./GetBackupVaultAccessPolicyCommand";
+export * from "./GetBackupVaultNotificationsCommand";
+export * from "./GetRecoveryPointRestoreMetadataCommand";
+export * from "./GetSupportedResourceTypesCommand";
+export * from "./ListBackupJobsCommand";
+export * from "./ListBackupPlanTemplatesCommand";
+export * from "./ListBackupPlanVersionsCommand";
+export * from "./ListBackupPlansCommand";
+export * from "./ListBackupSelectionsCommand";
+export * from "./ListBackupVaultsCommand";
+export * from "./ListCopyJobsCommand";
+export * from "./ListFrameworksCommand";
+export * from "./ListProtectedResourcesCommand";
+export * from "./ListRecoveryPointsByBackupVaultCommand";
+export * from "./ListRecoveryPointsByResourceCommand";
+export * from "./ListReportJobsCommand";
+export * from "./ListReportPlansCommand";
+export * from "./ListRestoreJobsCommand";
+export * from "./ListTagsCommand";
+export * from "./PutBackupVaultAccessPolicyCommand";
+export * from "./PutBackupVaultLockConfigurationCommand";
+export * from "./PutBackupVaultNotificationsCommand";
+export * from "./StartBackupJobCommand";
+export * from "./StartCopyJobCommand";
+export * from "./StartReportJobCommand";
+export * from "./StartRestoreJobCommand";
+export * from "./StopBackupJobCommand";
+export * from "./TagResourceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateBackupPlanCommand";
+export * from "./UpdateFrameworkCommand";
+export * from "./UpdateGlobalSettingsCommand";
+export * from "./UpdateRecoveryPointLifecycleCommand";
+export * from "./UpdateRegionSettingsCommand";
+export * from "./UpdateReportPlanCommand";