@aws-sdk/client-backup 3.34.0 → 3.35.0

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetBackupPlanFromJSONInput, GetBackupPlanFromJSONOutput } from "../models/models_0";
+export interface GetBackupPlanFromJSONCommandInput extends GetBackupPlanFromJSONInput {
+}
+export interface GetBackupPlanFromJSONCommandOutput extends GetBackupPlanFromJSONOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a valid JSON document specifying a backup plan or an error.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetBackupPlanFromJSONCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetBackupPlanFromJSONCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetBackupPlanFromJSONCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBackupPlanFromJSONCommandInput} for command's `input` shape.
+ * @see {@link GetBackupPlanFromJSONCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBackupPlanFromJSONCommand extends $Command<GetBackupPlanFromJSONCommandInput, GetBackupPlanFromJSONCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetBackupPlanFromJSONCommandInput;
+    constructor(input: GetBackupPlanFromJSONCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackupPlanFromJSONCommandInput, GetBackupPlanFromJSONCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetBackupPlanFromTemplateInput, GetBackupPlanFromTemplateOutput } from "../models/models_0";
+export interface GetBackupPlanFromTemplateCommandInput extends GetBackupPlanFromTemplateInput {
+}
+export interface GetBackupPlanFromTemplateCommandOutput extends GetBackupPlanFromTemplateOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the template specified by its <code>templateId</code> as a backup plan.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetBackupPlanFromTemplateCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetBackupPlanFromTemplateCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetBackupPlanFromTemplateCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBackupPlanFromTemplateCommandInput} for command's `input` shape.
+ * @see {@link GetBackupPlanFromTemplateCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBackupPlanFromTemplateCommand extends $Command<GetBackupPlanFromTemplateCommandInput, GetBackupPlanFromTemplateCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetBackupPlanFromTemplateCommandInput;
+    constructor(input: GetBackupPlanFromTemplateCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackupPlanFromTemplateCommandInput, GetBackupPlanFromTemplateCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetBackupSelectionInput, GetBackupSelectionOutput } from "../models/models_0";
+export interface GetBackupSelectionCommandInput extends GetBackupSelectionInput {
+}
+export interface GetBackupSelectionCommandOutput extends GetBackupSelectionOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns selection metadata and a document in JSON format that specifies a list of
+ *          resources that are associated with a backup plan.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetBackupSelectionCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetBackupSelectionCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetBackupSelectionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBackupSelectionCommandInput} for command's `input` shape.
+ * @see {@link GetBackupSelectionCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBackupSelectionCommand extends $Command<GetBackupSelectionCommandInput, GetBackupSelectionCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetBackupSelectionCommandInput;
+    constructor(input: GetBackupSelectionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackupSelectionCommandInput, GetBackupSelectionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetBackupVaultAccessPolicyInput, GetBackupVaultAccessPolicyOutput } from "../models/models_0";
+export interface GetBackupVaultAccessPolicyCommandInput extends GetBackupVaultAccessPolicyInput {
+}
+export interface GetBackupVaultAccessPolicyCommandOutput extends GetBackupVaultAccessPolicyOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the access policy document that is associated with the named backup
+ *          vault.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetBackupVaultAccessPolicyCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetBackupVaultAccessPolicyCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetBackupVaultAccessPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBackupVaultAccessPolicyCommandInput} for command's `input` shape.
+ * @see {@link GetBackupVaultAccessPolicyCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBackupVaultAccessPolicyCommand extends $Command<GetBackupVaultAccessPolicyCommandInput, GetBackupVaultAccessPolicyCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetBackupVaultAccessPolicyCommandInput;
+    constructor(input: GetBackupVaultAccessPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackupVaultAccessPolicyCommandInput, GetBackupVaultAccessPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetBackupVaultNotificationsInput, GetBackupVaultNotificationsOutput } from "../models/models_0";
+export interface GetBackupVaultNotificationsCommandInput extends GetBackupVaultNotificationsInput {
+}
+export interface GetBackupVaultNotificationsCommandOutput extends GetBackupVaultNotificationsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns event notifications for the specified backup vault.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetBackupVaultNotificationsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetBackupVaultNotificationsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetBackupVaultNotificationsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetBackupVaultNotificationsCommandInput} for command's `input` shape.
+ * @see {@link GetBackupVaultNotificationsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetBackupVaultNotificationsCommand extends $Command<GetBackupVaultNotificationsCommandInput, GetBackupVaultNotificationsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetBackupVaultNotificationsCommandInput;
+    constructor(input: GetBackupVaultNotificationsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetBackupVaultNotificationsCommandInput, GetBackupVaultNotificationsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetRecoveryPointRestoreMetadataInput, GetRecoveryPointRestoreMetadataOutput } from "../models/models_0";
+export interface GetRecoveryPointRestoreMetadataCommandInput extends GetRecoveryPointRestoreMetadataInput {
+}
+export interface GetRecoveryPointRestoreMetadataCommandOutput extends GetRecoveryPointRestoreMetadataOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a set of metadata key-value pairs that were used to create the backup.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetRecoveryPointRestoreMetadataCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetRecoveryPointRestoreMetadataCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetRecoveryPointRestoreMetadataCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetRecoveryPointRestoreMetadataCommandInput} for command's `input` shape.
+ * @see {@link GetRecoveryPointRestoreMetadataCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetRecoveryPointRestoreMetadataCommand extends $Command<GetRecoveryPointRestoreMetadataCommandInput, GetRecoveryPointRestoreMetadataCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetRecoveryPointRestoreMetadataCommandInput;
+    constructor(input: GetRecoveryPointRestoreMetadataCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRecoveryPointRestoreMetadataCommandInput, GetRecoveryPointRestoreMetadataCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { GetSupportedResourceTypesOutput } from "../models/models_0";
+export interface GetSupportedResourceTypesCommandInput {
+}
+export interface GetSupportedResourceTypesCommandOutput extends GetSupportedResourceTypesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns the Amazon Web Services resource types supported by Backup.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, GetSupportedResourceTypesCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, GetSupportedResourceTypesCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new GetSupportedResourceTypesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSupportedResourceTypesCommandInput} for command's `input` shape.
+ * @see {@link GetSupportedResourceTypesCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class GetSupportedResourceTypesCommand extends $Command<GetSupportedResourceTypesCommandInput, GetSupportedResourceTypesCommandOutput, BackupClientResolvedConfig> {
+    readonly input: GetSupportedResourceTypesCommandInput;
+    constructor(input: GetSupportedResourceTypesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSupportedResourceTypesCommandInput, GetSupportedResourceTypesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupJobsInput, ListBackupJobsOutput } from "../models/models_0";
+export interface ListBackupJobsCommandInput extends ListBackupJobsInput {
+}
+export interface ListBackupJobsCommandOutput extends ListBackupJobsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of existing backup jobs for an authenticated account for the last 30
+ *          days. For a longer period of time, consider using these <a href="https://docs.aws.amazon.com/aws-backup/latest/devguide/monitoring.html">monitoring tools</a>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupJobsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupJobsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupJobsCommandInput} for command's `input` shape.
+ * @see {@link ListBackupJobsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupJobsCommand extends $Command<ListBackupJobsCommandInput, ListBackupJobsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupJobsCommandInput;
+    constructor(input: ListBackupJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupJobsCommandInput, ListBackupJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupPlanTemplatesInput, ListBackupPlanTemplatesOutput } from "../models/models_0";
+export interface ListBackupPlanTemplatesCommandInput extends ListBackupPlanTemplatesInput {
+}
+export interface ListBackupPlanTemplatesCommandOutput extends ListBackupPlanTemplatesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns metadata of your saved backup plan templates, including the template ID, name,
+ *          and the creation and deletion dates.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupPlanTemplatesCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupPlanTemplatesCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupPlanTemplatesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupPlanTemplatesCommandInput} for command's `input` shape.
+ * @see {@link ListBackupPlanTemplatesCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupPlanTemplatesCommand extends $Command<ListBackupPlanTemplatesCommandInput, ListBackupPlanTemplatesCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupPlanTemplatesCommandInput;
+    constructor(input: ListBackupPlanTemplatesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupPlanTemplatesCommandInput, ListBackupPlanTemplatesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupPlanVersionsInput, ListBackupPlanVersionsOutput } from "../models/models_0";
+export interface ListBackupPlanVersionsCommandInput extends ListBackupPlanVersionsInput {
+}
+export interface ListBackupPlanVersionsCommandOutput extends ListBackupPlanVersionsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns version metadata of your backup plans, including Amazon Resource Names (ARNs),
+ *          backup plan IDs, creation and deletion dates, plan names, and version IDs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupPlanVersionsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupPlanVersionsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupPlanVersionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupPlanVersionsCommandInput} for command's `input` shape.
+ * @see {@link ListBackupPlanVersionsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupPlanVersionsCommand extends $Command<ListBackupPlanVersionsCommandInput, ListBackupPlanVersionsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupPlanVersionsCommandInput;
+    constructor(input: ListBackupPlanVersionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupPlanVersionsCommandInput, ListBackupPlanVersionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupPlansInput, ListBackupPlansOutput } from "../models/models_0";
+export interface ListBackupPlansCommandInput extends ListBackupPlansInput {
+}
+export interface ListBackupPlansCommandOutput extends ListBackupPlansOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of all active backup plans for an authenticated account. The list
+ *          contains information such as Amazon Resource Names (ARNs), plan IDs, creation and deletion
+ *          dates, version IDs, plan names, and creator request IDs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupPlansCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupPlansCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupPlansCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupPlansCommandInput} for command's `input` shape.
+ * @see {@link ListBackupPlansCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupPlansCommand extends $Command<ListBackupPlansCommandInput, ListBackupPlansCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupPlansCommandInput;
+    constructor(input: ListBackupPlansCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupPlansCommandInput, ListBackupPlansCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupSelectionsInput, ListBackupSelectionsOutput } from "../models/models_0";
+export interface ListBackupSelectionsCommandInput extends ListBackupSelectionsInput {
+}
+export interface ListBackupSelectionsCommandOutput extends ListBackupSelectionsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns an array containing metadata of the resources associated with the target backup
+ *          plan.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupSelectionsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupSelectionsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupSelectionsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupSelectionsCommandInput} for command's `input` shape.
+ * @see {@link ListBackupSelectionsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupSelectionsCommand extends $Command<ListBackupSelectionsCommandInput, ListBackupSelectionsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupSelectionsCommandInput;
+    constructor(input: ListBackupSelectionsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupSelectionsCommandInput, ListBackupSelectionsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,36 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListBackupVaultsInput, ListBackupVaultsOutput } from "../models/models_0";
+export interface ListBackupVaultsCommandInput extends ListBackupVaultsInput {
+}
+export interface ListBackupVaultsCommandOutput extends ListBackupVaultsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of recovery point storage containers along with information about
+ *          them.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListBackupVaultsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListBackupVaultsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListBackupVaultsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListBackupVaultsCommandInput} for command's `input` shape.
+ * @see {@link ListBackupVaultsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListBackupVaultsCommand extends $Command<ListBackupVaultsCommandInput, ListBackupVaultsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListBackupVaultsCommandInput;
+    constructor(input: ListBackupVaultsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListBackupVaultsCommandInput, ListBackupVaultsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListCopyJobsInput, ListCopyJobsOutput } from "../models/models_0";
+export interface ListCopyJobsCommandInput extends ListCopyJobsInput {
+}
+export interface ListCopyJobsCommandOutput extends ListCopyJobsOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns metadata about your copy jobs.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListCopyJobsCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListCopyJobsCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListCopyJobsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCopyJobsCommandInput} for command's `input` shape.
+ * @see {@link ListCopyJobsCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListCopyJobsCommand extends $Command<ListCopyJobsCommandInput, ListCopyJobsCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListCopyJobsCommandInput;
+    constructor(input: ListCopyJobsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCopyJobsCommandInput, ListCopyJobsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListFrameworksInput, ListFrameworksOutput } from "../models/models_0";
+export interface ListFrameworksCommandInput extends ListFrameworksInput {
+}
+export interface ListFrameworksCommandOutput extends ListFrameworksOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of all frameworks for an Amazon Web Services account and Amazon Web Services Region.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListFrameworksCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListFrameworksCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListFrameworksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFrameworksCommandInput} for command's `input` shape.
+ * @see {@link ListFrameworksCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListFrameworksCommand extends $Command<ListFrameworksCommandInput, ListFrameworksCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListFrameworksCommandInput;
+    constructor(input: ListFrameworksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFrameworksCommandInput, ListFrameworksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,37 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListProtectedResourcesInput, ListProtectedResourcesOutput } from "../models/models_0";
+export interface ListProtectedResourcesCommandInput extends ListProtectedResourcesInput {
+}
+export interface ListProtectedResourcesCommandOutput extends ListProtectedResourcesOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns an array of resources successfully backed up by Backup, including
+ *          the time the resource was saved, an Amazon Resource Name (ARN) of the resource, and a
+ *          resource type.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListProtectedResourcesCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListProtectedResourcesCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListProtectedResourcesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListProtectedResourcesCommandInput} for command's `input` shape.
+ * @see {@link ListProtectedResourcesCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListProtectedResourcesCommand extends $Command<ListProtectedResourcesCommandInput, ListProtectedResourcesCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListProtectedResourcesCommandInput;
+    constructor(input: ListProtectedResourcesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListProtectedResourcesCommandInput, ListProtectedResourcesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,35 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { BackupClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../BackupClient";
+import { ListRecoveryPointsByBackupVaultInput, ListRecoveryPointsByBackupVaultOutput } from "../models/models_0";
+export interface ListRecoveryPointsByBackupVaultCommandInput extends ListRecoveryPointsByBackupVaultInput {
+}
+export interface ListRecoveryPointsByBackupVaultCommandOutput extends ListRecoveryPointsByBackupVaultOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns detailed information about the recovery points stored in a backup vault.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { BackupClient, ListRecoveryPointsByBackupVaultCommand } from "@aws-sdk/client-backup"; // ES Modules import
+ * // const { BackupClient, ListRecoveryPointsByBackupVaultCommand } = require("@aws-sdk/client-backup"); // CommonJS import
+ * const client = new BackupClient(config);
+ * const command = new ListRecoveryPointsByBackupVaultCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListRecoveryPointsByBackupVaultCommandInput} for command's `input` shape.
+ * @see {@link ListRecoveryPointsByBackupVaultCommandOutput} for command's `response` shape.
+ * @see {@link BackupClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListRecoveryPointsByBackupVaultCommand extends $Command<ListRecoveryPointsByBackupVaultCommandInput, ListRecoveryPointsByBackupVaultCommandOutput, BackupClientResolvedConfig> {
+    readonly input: ListRecoveryPointsByBackupVaultCommandInput;
+    constructor(input: ListRecoveryPointsByBackupVaultCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: BackupClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListRecoveryPointsByBackupVaultCommandInput, ListRecoveryPointsByBackupVaultCommandOutput>;
+    private serialize;
+    private deserialize;
+}