@aws-sdk/client-storage-gateway 3.32.0 → 3.36.0

package/dist-types/ts3.4/commands/RemoveTagsFromResourceCommand.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 { RemoveTagsFromResourceInput, RemoveTagsFromResourceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface RemoveTagsFromResourceCommandInput extends RemoveTagsFromResourceInput {
+}
+export interface RemoveTagsFromResourceCommandOutput extends RemoveTagsFromResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Removes one or more tags from the specified resource. This operation is supported in
+ *          storage gateways of all types.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, RemoveTagsFromResourceCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, RemoveTagsFromResourceCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new RemoveTagsFromResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RemoveTagsFromResourceCommandInput} for command's `input` shape.
+ * @see {@link RemoveTagsFromResourceCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RemoveTagsFromResourceCommand extends $Command<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: RemoveTagsFromResourceCommandInput;
+    constructor(input: RemoveTagsFromResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RemoveTagsFromResourceCommandInput, RemoveTagsFromResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ResetCacheInput, ResetCacheOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ResetCacheCommandInput extends ResetCacheInput {
+}
+export interface ResetCacheCommandOutput extends ResetCacheOutput, __MetadataBearer {
+}
+/**
+ * <p>Resets all cache disks that have encountered an error and makes the disks available for
+ *          reconfiguration as cache storage. If your cache disk encounters an error, the gateway
+ *          prevents read and write operations on virtual tapes in the gateway. For example, an error
+ *          can occur when a disk is corrupted or removed from the gateway. When a cache is reset, the
+ *          gateway loses its cache storage. At this point, you can reconfigure the disks as cache
+ *          disks. This operation is only supported in the cached volume and tape types.</p>
+ *
+ *          <important>
+ *             <p>If the cache disk you are resetting contains data that has not been uploaded to
+ *             Amazon S3 yet, that data can be lost. After you reset cache disks, there will be no
+ *             configured cache disks left in the gateway, so you must configure at least one new cache
+ *             disk for your gateway to function properly.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ResetCacheCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ResetCacheCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ResetCacheCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ResetCacheCommandInput} for command's `input` shape.
+ * @see {@link ResetCacheCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ResetCacheCommand extends $Command<ResetCacheCommandInput, ResetCacheCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ResetCacheCommandInput;
+    constructor(input: ResetCacheCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ResetCacheCommandInput, ResetCacheCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RetrieveTapeArchiveInput, RetrieveTapeArchiveOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface RetrieveTapeArchiveCommandInput extends RetrieveTapeArchiveInput {
+}
+export interface RetrieveTapeArchiveCommandOutput extends RetrieveTapeArchiveOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves an archived virtual tape from the virtual tape shelf (VTS) to a tape gateway.
+ *          Virtual tapes archived in the VTS are not associated with any gateway. However after a tape
+ *          is retrieved, it is associated with a gateway, even though it is also listed in the VTS,
+ *          that is, archive. This operation is only supported in the tape gateway type.</p>
+ *
+ *          <p>Once a tape is successfully retrieved to a gateway, it cannot be retrieved again to
+ *          another gateway. You must archive the tape again before you can retrieve it to another
+ *          gateway. This operation is only supported in the tape gateway type.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, RetrieveTapeArchiveCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, RetrieveTapeArchiveCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new RetrieveTapeArchiveCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RetrieveTapeArchiveCommandInput} for command's `input` shape.
+ * @see {@link RetrieveTapeArchiveCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RetrieveTapeArchiveCommand extends $Command<RetrieveTapeArchiveCommandInput, RetrieveTapeArchiveCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: RetrieveTapeArchiveCommandInput;
+    constructor(input: RetrieveTapeArchiveCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RetrieveTapeArchiveCommandInput, RetrieveTapeArchiveCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,46 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RetrieveTapeRecoveryPointInput, RetrieveTapeRecoveryPointOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface RetrieveTapeRecoveryPointCommandInput extends RetrieveTapeRecoveryPointInput {
+}
+export interface RetrieveTapeRecoveryPointCommandOutput extends RetrieveTapeRecoveryPointOutput, __MetadataBearer {
+}
+/**
+ * <p>Retrieves the recovery point for the specified virtual tape. This operation is only
+ *          supported in the tape gateway type.</p>
+ *
+ *          <p>A recovery point is a point in time view of a virtual tape at which all the data on the
+ *          tape is consistent. If your gateway crashes, virtual tapes that have recovery points can be
+ *          recovered to a new gateway.</p>
+ *
+ *          <note>
+ *             <p>The virtual tape can be retrieved to only one gateway. The retrieved tape is
+ *             read-only. The virtual tape can be retrieved to only a tape gateway. There is no charge
+ *             for retrieving recovery points.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, RetrieveTapeRecoveryPointCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, RetrieveTapeRecoveryPointCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new RetrieveTapeRecoveryPointCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RetrieveTapeRecoveryPointCommandInput} for command's `input` shape.
+ * @see {@link RetrieveTapeRecoveryPointCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RetrieveTapeRecoveryPointCommand extends $Command<RetrieveTapeRecoveryPointCommandInput, RetrieveTapeRecoveryPointCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: RetrieveTapeRecoveryPointCommandInput;
+    constructor(input: RetrieveTapeRecoveryPointCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RetrieveTapeRecoveryPointCommandInput, RetrieveTapeRecoveryPointCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,38 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { SetLocalConsolePasswordInput, SetLocalConsolePasswordOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface SetLocalConsolePasswordCommandInput extends SetLocalConsolePasswordInput {
+}
+export interface SetLocalConsolePasswordCommandOutput extends SetLocalConsolePasswordOutput, __MetadataBearer {
+}
+/**
+ * <p>Sets the password for your VM local console. When you log in to the local console for
+ *          the first time, you log in to the VM with the default credentials. We recommend that you
+ *          set a new password. You don't need to know the default password to set a new
+ *          password.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, SetLocalConsolePasswordCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, SetLocalConsolePasswordCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new SetLocalConsolePasswordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetLocalConsolePasswordCommandInput} for command's `input` shape.
+ * @see {@link SetLocalConsolePasswordCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetLocalConsolePasswordCommand extends $Command<SetLocalConsolePasswordCommandInput, SetLocalConsolePasswordCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: SetLocalConsolePasswordCommandInput;
+    constructor(input: SetLocalConsolePasswordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetLocalConsolePasswordCommandInput, SetLocalConsolePasswordCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/SetSMBGuestPasswordCommand.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 { SetSMBGuestPasswordInput, SetSMBGuestPasswordOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface SetSMBGuestPasswordCommandInput extends SetSMBGuestPasswordInput {
+}
+export interface SetSMBGuestPasswordCommandOutput extends SetSMBGuestPasswordOutput, __MetadataBearer {
+}
+/**
+ * <p>Sets the password for the guest user <code>smbguest</code>. The <code>smbguest</code>
+ *          user is the user when the authentication method for the file share is set to
+ *          <code>GuestAccess</code>. This operation only supported for S3 File Gateways</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, SetSMBGuestPasswordCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, SetSMBGuestPasswordCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new SetSMBGuestPasswordCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link SetSMBGuestPasswordCommandInput} for command's `input` shape.
+ * @see {@link SetSMBGuestPasswordCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class SetSMBGuestPasswordCommand extends $Command<SetSMBGuestPasswordCommandInput, SetSMBGuestPasswordCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: SetSMBGuestPasswordCommandInput;
+    constructor(input: SetSMBGuestPasswordCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<SetSMBGuestPasswordCommandInput, SetSMBGuestPasswordCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,58 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ShutdownGatewayInput, ShutdownGatewayOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ShutdownGatewayCommandInput extends ShutdownGatewayInput {
+}
+export interface ShutdownGatewayCommandOutput extends ShutdownGatewayOutput, __MetadataBearer {
+}
+/**
+ * <p>Shuts down a gateway. To specify which gateway to shut down, use the Amazon Resource
+ *          Name (ARN) of the gateway in the body of your request.</p>
+ *
+ *          <p>The operation shuts down the gateway service component running in the gateway's
+ *          virtual machine (VM) and not the host VM.</p>
+ *
+ *          <note>
+ *             <p>If you want to shut down the VM, it is recommended that you first shut down the
+ *             gateway component in the VM to avoid unpredictable conditions.</p>
+ *          </note>
+ *
+ *          <p>After the gateway is shutdown, you cannot call any other API except <a>StartGateway</a>, <a>DescribeGatewayInformation</a>, and <a>ListGateways</a>. For more information, see <a>ActivateGateway</a>.
+ *          Your applications cannot read from or write to the gateway's storage volumes, and
+ *          there are no snapshots taken.</p>
+ *
+ *          <note>
+ *             <p>When you make a shutdown request, you will get a <code>200 OK</code> success response
+ *             immediately. However, it might take some time for the gateway to shut down. You can call
+ *             the <a>DescribeGatewayInformation</a> API to check the status. For more
+ *             information, see <a>ActivateGateway</a>.</p>
+ *          </note>
+ *
+ *          <p>If do not intend to use the gateway again, you must delete the gateway (using <a>DeleteGateway</a>) to no longer pay software charges associated with the
+ *          gateway.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ShutdownGatewayCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ShutdownGatewayCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ShutdownGatewayCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ShutdownGatewayCommandInput} for command's `input` shape.
+ * @see {@link ShutdownGatewayCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ShutdownGatewayCommand extends $Command<ShutdownGatewayCommandInput, ShutdownGatewayCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ShutdownGatewayCommandInput;
+    constructor(input: ShutdownGatewayCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ShutdownGatewayCommandInput, ShutdownGatewayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,42 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartAvailabilityMonitorTestInput, StartAvailabilityMonitorTestOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface StartAvailabilityMonitorTestCommandInput extends StartAvailabilityMonitorTestInput {
+}
+export interface StartAvailabilityMonitorTestCommandOutput extends StartAvailabilityMonitorTestOutput, __MetadataBearer {
+}
+/**
+ * <p>Start a test that verifies that the specified gateway is configured for High
+ *          Availability monitoring in your host environment. This request only initiates the test and
+ *          that a successful response only indicates that the test was started. It doesn't
+ *          indicate that the test passed. For the status of the test, invoke the
+ *             <code>DescribeAvailabilityMonitorTest</code> API.</p>
+ *          <note>
+ *             <p>Starting this test will cause your gateway to go offline for a brief period.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, StartAvailabilityMonitorTestCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, StartAvailabilityMonitorTestCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new StartAvailabilityMonitorTestCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartAvailabilityMonitorTestCommandInput} for command's `input` shape.
+ * @see {@link StartAvailabilityMonitorTestCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartAvailabilityMonitorTestCommand extends $Command<StartAvailabilityMonitorTestCommandInput, StartAvailabilityMonitorTestCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: StartAvailabilityMonitorTestCommandInput;
+    constructor(input: StartAvailabilityMonitorTestCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartAvailabilityMonitorTestCommandInput, StartAvailabilityMonitorTestCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,47 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { StartGatewayInput, StartGatewayOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface StartGatewayCommandInput extends StartGatewayInput {
+}
+export interface StartGatewayCommandOutput extends StartGatewayOutput, __MetadataBearer {
+}
+/**
+ * <p>Starts a gateway that you previously shut down (see <a>ShutdownGateway</a>).
+ *          After the gateway starts, you can then make other API calls, your applications can read
+ *          from or write to the gateway's storage volumes and you will be able to take snapshot
+ *          backups.</p>
+ *
+ *          <note>
+ *             <p>When you make a request, you will get a 200 OK success response immediately. However,
+ *             it might take some time for the gateway to be ready. You should call <a>DescribeGatewayInformation</a> and check the status before making any
+ *             additional API calls. For more information, see <a>ActivateGateway</a>.</p>
+ *          </note>
+ *
+ *          <p>To specify which gateway to start, use the Amazon Resource Name (ARN) of the gateway in
+ *          your request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, StartGatewayCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, StartGatewayCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new StartGatewayCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartGatewayCommandInput} for command's `input` shape.
+ * @see {@link StartGatewayCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class StartGatewayCommand extends $Command<StartGatewayCommandInput, StartGatewayCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: StartGatewayCommandInput;
+    constructor(input: StartGatewayCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartGatewayCommandInput, StartGatewayCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateAutomaticTapeCreationPolicyInput, UpdateAutomaticTapeCreationPolicyOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface UpdateAutomaticTapeCreationPolicyCommandInput extends UpdateAutomaticTapeCreationPolicyInput {
+}
+export interface UpdateAutomaticTapeCreationPolicyCommandOutput extends UpdateAutomaticTapeCreationPolicyOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the automatic tape creation policy of a gateway. Use this to update the policy
+ *          with a new set of automatic tape creation rules. This is only supported for tape
+ *          gateways.</p>
+ *
+ *          <p>By default, there is no automatic tape creation policy.</p>
+ *
+ *          <note>
+ *             <p>A gateway can have only one automatic tape creation policy.</p>
+ *          </note>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, UpdateAutomaticTapeCreationPolicyCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, UpdateAutomaticTapeCreationPolicyCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new UpdateAutomaticTapeCreationPolicyCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateAutomaticTapeCreationPolicyCommandInput} for command's `input` shape.
+ * @see {@link UpdateAutomaticTapeCreationPolicyCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateAutomaticTapeCreationPolicyCommand extends $Command<UpdateAutomaticTapeCreationPolicyCommandInput, UpdateAutomaticTapeCreationPolicyCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: UpdateAutomaticTapeCreationPolicyCommandInput;
+    constructor(input: UpdateAutomaticTapeCreationPolicyCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateAutomaticTapeCreationPolicyCommandInput, UpdateAutomaticTapeCreationPolicyCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,45 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateBandwidthRateLimitInput, UpdateBandwidthRateLimitOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface UpdateBandwidthRateLimitCommandInput extends UpdateBandwidthRateLimitInput {
+}
+export interface UpdateBandwidthRateLimitCommandOutput extends UpdateBandwidthRateLimitOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the bandwidth rate limits of a gateway. You can update both the upload and
+ *          download bandwidth rate limit or specify only one of the two. If you don't set a
+ *          bandwidth rate limit, the existing rate limit remains. This operation is supported for the
+ *          stored volume, cached volume, and tape gateway types.</p>
+ *
+ *          <p>By default, a gateway's bandwidth rate limits are not set. If you don't set
+ *          any limit, the gateway does not have any limitations on its bandwidth usage and could
+ *          potentially use the maximum available bandwidth.</p>
+ *
+ *          <p>To specify which gateway to update, use the Amazon Resource Name (ARN) of the gateway in
+ *          your request.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, UpdateBandwidthRateLimitCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, UpdateBandwidthRateLimitCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new UpdateBandwidthRateLimitCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateBandwidthRateLimitCommandInput} for command's `input` shape.
+ * @see {@link UpdateBandwidthRateLimitCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateBandwidthRateLimitCommand extends $Command<UpdateBandwidthRateLimitCommandInput, UpdateBandwidthRateLimitCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: UpdateBandwidthRateLimitCommandInput;
+    constructor(input: UpdateBandwidthRateLimitCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBandwidthRateLimitCommandInput, UpdateBandwidthRateLimitCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,40 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateBandwidthRateLimitScheduleInput, UpdateBandwidthRateLimitScheduleOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface UpdateBandwidthRateLimitScheduleCommandInput extends UpdateBandwidthRateLimitScheduleInput {
+}
+export interface UpdateBandwidthRateLimitScheduleCommandOutput extends UpdateBandwidthRateLimitScheduleOutput, __MetadataBearer {
+}
+/**
+ * <p>
+ *          Updates the bandwidth rate limit schedule for a specified gateway. By default, gateways do
+ *          not have bandwidth rate limit schedules, which means no bandwidth rate limiting is in effect.
+ *          Use this to initiate or update a gateway's bandwidth rate limit schedule.
+ *          This operation is supported in the volume and tape gateway types.
+ *       </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, UpdateBandwidthRateLimitScheduleCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, UpdateBandwidthRateLimitScheduleCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new UpdateBandwidthRateLimitScheduleCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateBandwidthRateLimitScheduleCommandInput} for command's `input` shape.
+ * @see {@link UpdateBandwidthRateLimitScheduleCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateBandwidthRateLimitScheduleCommand extends $Command<UpdateBandwidthRateLimitScheduleCommandInput, UpdateBandwidthRateLimitScheduleCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: UpdateBandwidthRateLimitScheduleCommandInput;
+    constructor(input: UpdateBandwidthRateLimitScheduleCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateBandwidthRateLimitScheduleCommandInput, UpdateBandwidthRateLimitScheduleCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,43 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { UpdateChapCredentialsInput, UpdateChapCredentialsOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface UpdateChapCredentialsCommandInput extends UpdateChapCredentialsInput {
+}
+export interface UpdateChapCredentialsCommandOutput extends UpdateChapCredentialsOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates the Challenge-Handshake Authentication Protocol (CHAP) credentials for a
+ *          specified iSCSI target. By default, a gateway does not have CHAP enabled; however, for
+ *          added security, you might use it. This operation is supported in the volume and tape
+ *          gateway types.</p>
+ *
+ *          <important>
+ *             <p>When you update CHAP credentials, all existing connections on the target are closed
+ *             and initiators must reconnect with the new credentials.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, UpdateChapCredentialsCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, UpdateChapCredentialsCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new UpdateChapCredentialsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateChapCredentialsCommandInput} for command's `input` shape.
+ * @see {@link UpdateChapCredentialsCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateChapCredentialsCommand extends $Command<UpdateChapCredentialsCommandInput, UpdateChapCredentialsCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: UpdateChapCredentialsCommandInput;
+    constructor(input: UpdateChapCredentialsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateChapCredentialsCommandInput, UpdateChapCredentialsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/UpdateFileSystemAssociationCommand.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 { UpdateFileSystemAssociationInput, UpdateFileSystemAssociationOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface UpdateFileSystemAssociationCommandInput extends UpdateFileSystemAssociationInput {
+}
+export interface UpdateFileSystemAssociationCommandOutput extends UpdateFileSystemAssociationOutput, __MetadataBearer {
+}
+/**
+ * <p>Updates a file system association. This operation is only supported in the FSx File Gateways.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, UpdateFileSystemAssociationCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, UpdateFileSystemAssociationCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new UpdateFileSystemAssociationCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateFileSystemAssociationCommandInput} for command's `input` shape.
+ * @see {@link UpdateFileSystemAssociationCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class UpdateFileSystemAssociationCommand extends $Command<UpdateFileSystemAssociationCommandInput, UpdateFileSystemAssociationCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: UpdateFileSystemAssociationCommandInput;
+    constructor(input: UpdateFileSystemAssociationCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateFileSystemAssociationCommandInput, UpdateFileSystemAssociationCommandOutput>;
+    private serialize;
+    private deserialize;
+}