@aws-sdk/client-secrets-manager 3.34.0 → 3.37.0

package/dist/types/ts3.4/commands/GetRandomPasswordCommand.d.ts

@@ -1,47 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { GetRandomPasswordRequest, GetRandomPasswordResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetRandomPasswordCommandInput extends GetRandomPasswordRequest {
-}
-export interface GetRandomPasswordCommandOutput extends GetRandomPasswordResponse, __MetadataBearer {
-}
-/**
- * <p>Generates a random password of the specified complexity. This operation is intended for
- *       use in the Lambda rotation function. Per best practice, we recommend that you specify the
- *       maximum length and include every character type that the system you are generating a password
- *       for can support.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:GetRandomPassword</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, GetRandomPasswordCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, GetRandomPasswordCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new GetRandomPasswordCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetRandomPasswordCommandInput} for command's `input` shape.
- * @see {@link GetRandomPasswordCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetRandomPasswordCommand extends $Command<GetRandomPasswordCommandInput, GetRandomPasswordCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: GetRandomPasswordCommandInput;
-    constructor(input: GetRandomPasswordCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetRandomPasswordCommandInput, GetRandomPasswordCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetResourcePolicyCommand.d.ts

@@ -1,61 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { GetResourcePolicyRequest, GetResourcePolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetResourcePolicyCommandInput extends GetResourcePolicyRequest {
-}
-export interface GetResourcePolicyCommandOutput extends GetResourcePolicyResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves the JSON text of the resource-based policy document attached to the specified
- *       secret. The JSON request string input and response output displays formatted code
- *       with white space and line breaks for better readability. Submit your input as a single line
- *       JSON string.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:GetResourcePolicy</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To attach a resource policy to a secret, use <a>PutResourcePolicy</a>.</p>
- *             </li>
- *             <li>
- *                <p>To delete the resource-based policy attached to a secret, use <a>DeleteResourcePolicy</a>.</p>
- *             </li>
- *             <li>
- *                <p>To list all of the currently available secrets, use <a>ListSecrets</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, GetResourcePolicyCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, GetResourcePolicyCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new GetResourcePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetResourcePolicyCommandInput} for command's `input` shape.
- * @see {@link GetResourcePolicyCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetResourcePolicyCommand extends $Command<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: GetResourcePolicyCommandInput;
-    constructor(input: GetResourcePolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetResourcePolicyCommandInput, GetResourcePolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/GetSecretValueCommand.d.ts

@@ -1,62 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { GetSecretValueRequest, GetSecretValueResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface GetSecretValueCommandInput extends GetSecretValueRequest {
-}
-export interface GetSecretValueCommandOutput extends GetSecretValueResponse, __MetadataBearer {
-}
-/**
- * <p>Retrieves the contents of the encrypted fields <code>SecretString</code> or
- *         <code>SecretBinary</code> from the specified version of a secret, whichever contains
- *       content.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:GetSecretValue</p>
- *             </li>
- *             <li>
- *                <p>kms:Decrypt - required only if you use a customer-managed Amazon Web Services KMS key to encrypt the
- *           secret. You do not need this permission to use the account's default Amazon Web Services managed CMK for
- *           Secrets Manager.</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To create a new version of the secret with different encrypted information, use <a>PutSecretValue</a>.</p>
- *             </li>
- *             <li>
- *                <p>To retrieve the non-encrypted details for the secret, use <a>DescribeSecret</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, GetSecretValueCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new GetSecretValueCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSecretValueCommandInput} for command's `input` shape.
- * @see {@link GetSecretValueCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class GetSecretValueCommand extends $Command<GetSecretValueCommandInput, GetSecretValueCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: GetSecretValueCommandInput;
-    constructor(input: GetSecretValueCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSecretValueCommandInput, GetSecretValueCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListSecretVersionIdsCommand.d.ts

@@ -1,63 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { ListSecretVersionIdsRequest, ListSecretVersionIdsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListSecretVersionIdsCommandInput extends ListSecretVersionIdsRequest {
-}
-export interface ListSecretVersionIdsCommandOutput extends ListSecretVersionIdsResponse, __MetadataBearer {
-}
-/**
- * <p>Lists all of the versions attached to the specified secret. The output does not include
- *       the <code>SecretString</code> or <code>SecretBinary</code> fields. By default, the list
- *       includes only versions that have at least one staging label in <code>VersionStage</code>
- *       attached.</p>
- *          <note>
- *             <p>Always check the <code>NextToken</code> response parameter
- *     when calling any of the <code>List*</code> operations. These operations can occasionally return
- *     an empty or shorter than expected list of results even when there more results become available.
- *     When this happens, the <code>NextToken</code> response parameter contains a value to pass to the
- *     next call to the same API to request the next part of the list.</p>
- *          </note>
- *          <p>
- *             <b>Minimum
- *       permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:ListSecretVersionIds</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To list the secrets in an account, use <a>ListSecrets</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, ListSecretVersionIdsCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, ListSecretVersionIdsCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new ListSecretVersionIdsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSecretVersionIdsCommandInput} for command's `input` shape.
- * @see {@link ListSecretVersionIdsCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListSecretVersionIdsCommand extends $Command<ListSecretVersionIdsCommandInput, ListSecretVersionIdsCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: ListSecretVersionIdsCommandInput;
-    constructor(input: ListSecretVersionIdsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSecretVersionIdsCommandInput, ListSecretVersionIdsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ListSecretsCommand.d.ts

@@ -1,64 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { ListSecretsRequest, ListSecretsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ListSecretsCommandInput extends ListSecretsRequest {
-}
-export interface ListSecretsCommandOutput extends ListSecretsResponse, __MetadataBearer {
-}
-/**
- * <p>Lists all of the secrets that are stored by Secrets Manager in the Amazon Web Services account. To list the
- *       versions currently stored for a specific secret, use <a>ListSecretVersionIds</a>.
- *       The encrypted fields <code>SecretString</code> and <code>SecretBinary</code> are not included
- *       in the output. To get that information, call the <a>GetSecretValue</a>
- *       operation.</p>
- *          <note>
- *             <p>Always check the <code>NextToken</code> response parameter
- *     when calling any of the <code>List*</code> operations. These operations can occasionally return
- *     an empty or shorter than expected list of results even when there more results become available.
- *     When this happens, the <code>NextToken</code> response parameter contains a value to pass to the
- *     next call to the same API to request the next part of the list.</p>
- *          </note>
- *          <p>
- *             <b>Minimum
- *         permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:ListSecrets</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To list the versions attached to a secret, use <a>ListSecretVersionIds</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, ListSecretsCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, ListSecretsCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new ListSecretsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSecretsCommandInput} for command's `input` shape.
- * @see {@link ListSecretsCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ListSecretsCommand extends $Command<ListSecretsCommandInput, ListSecretsCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: ListSecretsCommandInput;
-    constructor(input: ListSecretsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSecretsCommandInput, ListSecretsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/PutResourcePolicyCommand.d.ts

@@ -1,66 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { PutResourcePolicyRequest, PutResourcePolicyResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface PutResourcePolicyCommandInput extends PutResourcePolicyRequest {
-}
-export interface PutResourcePolicyCommandOutput extends PutResourcePolicyResponse, __MetadataBearer {
-}
-/**
- * <p>Attaches the contents of the specified resource-based permission policy to a secret. A
- *       resource-based policy is optional. Alternatively, you can use IAM identity-based policies
- *       that specify the secret's Amazon Resource Name (ARN) in the policy statement's
- *         <code>Resources</code> element. You can also use a combination of both identity-based and
- *       resource-based policies. The affected users and roles receive the permissions that are
- *       permitted by all of the relevant policies. For more information, see <a href="http://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_resource-based-policies.html">Using Resource-Based
- *         Policies for Amazon Web Services Secrets Manager</a>. For the complete description of the Amazon Web Services policy syntax and
- *       grammar, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html">IAM JSON
- *         Policy Reference</a> in the <i>IAM User Guide</i>.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:PutResourcePolicy</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To retrieve the resource policy attached to a secret, use <a>GetResourcePolicy</a>.</p>
- *             </li>
- *             <li>
- *                <p>To delete the resource-based policy attached to a secret, use <a>DeleteResourcePolicy</a>.</p>
- *             </li>
- *             <li>
- *                <p>To list all of the currently available secrets, use <a>ListSecrets</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, PutResourcePolicyCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, PutResourcePolicyCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new PutResourcePolicyCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutResourcePolicyCommandInput} for command's `input` shape.
- * @see {@link PutResourcePolicyCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class PutResourcePolicyCommand extends $Command<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: PutResourcePolicyCommandInput;
-    constructor(input: PutResourcePolicyCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutResourcePolicyCommandInput, PutResourcePolicyCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/ReplicateSecretToRegionsCommand.d.ts

@@ -1,36 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { ReplicateSecretToRegionsRequest, ReplicateSecretToRegionsResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface ReplicateSecretToRegionsCommandInput extends ReplicateSecretToRegionsRequest {
-}
-export interface ReplicateSecretToRegionsCommandOutput extends ReplicateSecretToRegionsResponse, __MetadataBearer {
-}
-/**
- * <p>Converts an existing secret to a multi-Region secret and begins replication the secret to a
- *       list of new regions. </p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, ReplicateSecretToRegionsCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, ReplicateSecretToRegionsCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new ReplicateSecretToRegionsCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ReplicateSecretToRegionsCommandInput} for command's `input` shape.
- * @see {@link ReplicateSecretToRegionsCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class ReplicateSecretToRegionsCommand extends $Command<ReplicateSecretToRegionsCommandInput, ReplicateSecretToRegionsCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: ReplicateSecretToRegionsCommandInput;
-    constructor(input: ReplicateSecretToRegionsCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ReplicateSecretToRegionsCommandInput, ReplicateSecretToRegionsCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RestoreSecretCommand.d.ts

@@ -1,53 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { RestoreSecretRequest, RestoreSecretResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RestoreSecretCommandInput extends RestoreSecretRequest {
-}
-export interface RestoreSecretCommandOutput extends RestoreSecretResponse, __MetadataBearer {
-}
-/**
- * <p>Cancels the scheduled deletion of a secret by removing the <code>DeletedDate</code> time
- *       stamp. This makes the secret accessible to query once again.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:RestoreSecret</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To delete a secret, use <a>DeleteSecret</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, RestoreSecretCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, RestoreSecretCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new RestoreSecretCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RestoreSecretCommandInput} for command's `input` shape.
- * @see {@link RestoreSecretCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RestoreSecretCommand extends $Command<RestoreSecretCommandInput, RestoreSecretCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: RestoreSecretCommandInput;
-    constructor(input: RestoreSecretCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RestoreSecretCommandInput, RestoreSecretCommandOutput>;
-    private serialize;
-    private deserialize;
-}

package/dist/types/ts3.4/commands/RotateSecretCommand.d.ts

@@ -1,96 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { RotateSecretRequest, RotateSecretResponse } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface RotateSecretCommandInput extends RotateSecretRequest {
-}
-export interface RotateSecretCommandOutput extends RotateSecretResponse, __MetadataBearer {
-}
-/**
- * <p>Configures and starts the asynchronous process of rotating this secret. If you include the
- *       configuration parameters, the operation sets those values for the secret and then immediately
- *       starts a rotation. If you do not include the configuration parameters, the operation starts a
- *       rotation with the values already stored in the secret. After the rotation completes, the
- *       protected service and its clients all use the new version of the secret. </p>
- *          <p>This required configuration information includes the ARN of an Amazon Web Services Lambda function and
- *       optionally, the time between scheduled rotations. The Lambda rotation function creates a new
- *       version of the secret and creates or updates the credentials on the protected service to
- *       match. After testing the new credentials, the function marks the new secret with the staging
- *       label <code>AWSCURRENT</code> so that your clients all immediately begin to use the new version. For more
- *       information about rotating secrets and how to configure a Lambda function to rotate the
- *       secrets for your protected service, see <a href="https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html">Rotating Secrets in Amazon Web Services Secrets Manager</a> in the
- *         <i>Amazon Web Services Secrets Manager User Guide</i>.</p>
- *          <p>Secrets Manager schedules the next rotation when the previous
- *     one completes. Secrets Manager schedules the date by adding the rotation interval (number of days) to the
- *     actual date of the last rotation. The service chooses the hour within that 24-hour date window
- *     randomly. The minute is also chosen somewhat randomly, but weighted towards the top of the hour
- *     and influenced by a variety of factors that help distribute load.</p>
- *          <p>The
- *       rotation function must end with the versions of the secret in one of two states:</p>
- *          <ul>
- *             <li>
- *                <p>The <code>AWSPENDING</code> and <code>AWSCURRENT</code> staging labels are attached to the same version of
- *           the secret, or</p>
- *             </li>
- *             <li>
- *                <p>The <code>AWSPENDING</code> staging label is not attached to any version of the secret.</p>
- *             </li>
- *          </ul>
- *          <p>If the <code>AWSPENDING</code> staging label is present but not attached to the same version as
- *       <code>AWSCURRENT</code> then any later invocation of <code>RotateSecret</code> assumes that a previous
- *       rotation request is still in progress and returns an error.</p>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:RotateSecret</p>
- *             </li>
- *             <li>
- *                <p>lambda:InvokeFunction (on the function specified in the secret's metadata)</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To list the secrets in your account, use <a>ListSecrets</a>.</p>
- *             </li>
- *             <li>
- *                <p>To get the details for a version of a secret, use <a>DescribeSecret</a>.</p>
- *             </li>
- *             <li>
- *                <p>To create a new version of a secret, use <a>CreateSecret</a>.</p>
- *             </li>
- *             <li>
- *                <p>To attach staging labels to or remove staging labels from a version of a secret, use
- *             <a>UpdateSecretVersionStage</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, RotateSecretCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, RotateSecretCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(config);
- * const command = new RotateSecretCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link RotateSecretCommandInput} for command's `input` shape.
- * @see {@link RotateSecretCommandOutput} for command's `response` shape.
- * @see {@link SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class RotateSecretCommand extends $Command<RotateSecretCommandInput, RotateSecretCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: RotateSecretCommandInput;
-    constructor(input: RotateSecretCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RotateSecretCommandInput, RotateSecretCommandOutput>;
-    private serialize;
-    private deserialize;
-}

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

@@ -1,90 +0,0 @@
-import { SecretsManagerClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../SecretsManagerClient";
-import { TagResourceRequest } from "../models/models_0";
-import { Command as $Command } from "@aws-sdk/smithy-client";
-import { Handler, MiddlewareStack, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer } from "@aws-sdk/types";
-export interface TagResourceCommandInput extends TagResourceRequest {
-}
-export interface TagResourceCommandOutput extends __MetadataBearer {
-}
-/**
- * <p>Attaches one or more tags, each consisting of a key name and a value, to the specified
- *       secret. Tags are part of the secret's overall metadata, and are not associated with any
- *       specific version of the secret. This operation only appends tags to the existing list of tags.
- *       To remove tags, you must use <a>UntagResource</a>.</p>
- *          <p>The following basic restrictions apply to tags:</p>
- *         <ul>
- *             <li>
- *                <p>Maximum number of tags per secret—50</p>
- *             </li>
- *             <li>
- *                <p>Maximum key length—127 Unicode characters in UTF-8</p>
- *             </li>
- *             <li>
- *                <p>Maximum value length—255 Unicode characters in UTF-8</p>
- *             </li>
- *             <li>
- *                <p>Tag keys and values are case sensitive.</p>
- *             </li>
- *             <li>
- *                <p>Do not use the <code>aws:</code> prefix in your tag names or values because Amazon Web Services reserves it
- *             for Amazon Web Services use. You can't edit or delete tag names or values with this
- *               prefix. Tags with this prefix do not count against your tags per secret limit.</p>
- *             </li>
- *             <li>
- *                <p>If you use your tagging schema across multiple services and resources,
- *               remember other services might have restrictions on allowed characters. Generally
- *               allowed characters: letters, spaces, and numbers representable in UTF-8, plus the
- *               following special characters: + - = . _ : / @.</p>
- *             </li>
- *          </ul>
- *          <important>
- *             <p>If you use tags as part of your security strategy, then adding or removing a tag can
- *         change permissions. If successfully completing this operation would result in you losing
- *         your permissions for this secret, then the operation is blocked and returns an Access Denied
- *         error.</p>
- *          </important>
- *          <p>
- *             <b>Minimum permissions</b>
- *          </p>
- *          <p>To run this command, you must have the following permissions:</p>
- *          <ul>
- *             <li>
- *                <p>secretsmanager:TagResource</p>
- *             </li>
- *          </ul>
- *          <p>
- *             <b>Related operations</b>
- *          </p>
- *          <ul>
- *             <li>
- *                <p>To remove one or more tags from the collection attached to a secret, use <a>UntagResource</a>.</p>
- *             </li>
- *             <li>
- *                <p>To view the list of tags attached to a secret, use <a>DescribeSecret</a>.</p>
- *             </li>
- *          </ul>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { SecretsManagerClient, TagResourceCommand } from "@aws-sdk/client-secrets-manager"; // ES Modules import
- * // const { SecretsManagerClient, TagResourceCommand } = require("@aws-sdk/client-secrets-manager"); // CommonJS import
- * const client = new SecretsManagerClient(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 SecretsManagerClientResolvedConfig | config} for command's `input` shape.
- *
- */
-export declare class TagResourceCommand extends $Command<TagResourceCommandInput, TagResourceCommandOutput, SecretsManagerClientResolvedConfig> {
-    readonly input: TagResourceCommandInput;
-    constructor(input: TagResourceCommandInput);
-    /**
-     * @internal
-     */
-    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: SecretsManagerClientResolvedConfig, options?: __HttpHandlerOptions): Handler<TagResourceCommandInput, TagResourceCommandOutput>;
-    private serialize;
-    private deserialize;
-}