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

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

package/dist-types/ts3.4/commands/ListAutomaticTapeCreationPoliciesCommand.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 { ListAutomaticTapeCreationPoliciesInput, ListAutomaticTapeCreationPoliciesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListAutomaticTapeCreationPoliciesCommandInput extends ListAutomaticTapeCreationPoliciesInput {
+}
+export interface ListAutomaticTapeCreationPoliciesCommandOutput extends ListAutomaticTapeCreationPoliciesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists the automatic tape creation policies for a gateway. If there are no automatic tape
+ *          creation policies for the gateway, it returns an empty list.</p>
+ *
+ *          <p>This operation is only supported for tape gateways.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListAutomaticTapeCreationPoliciesCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListAutomaticTapeCreationPoliciesCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListAutomaticTapeCreationPoliciesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAutomaticTapeCreationPoliciesCommandInput} for command's `input` shape.
+ * @see {@link ListAutomaticTapeCreationPoliciesCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListAutomaticTapeCreationPoliciesCommand extends $Command<ListAutomaticTapeCreationPoliciesCommandInput, ListAutomaticTapeCreationPoliciesCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListAutomaticTapeCreationPoliciesCommandInput;
+    constructor(input: ListAutomaticTapeCreationPoliciesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAutomaticTapeCreationPoliciesCommandInput, ListAutomaticTapeCreationPoliciesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListFileSharesCommand.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 { ListFileSharesInput, ListFileSharesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListFileSharesCommandInput extends ListFileSharesInput {
+}
+export interface ListFileSharesCommandOutput extends ListFileSharesOutput, __MetadataBearer {
+}
+/**
+ * <p>Gets a list of the file shares for a specific S3 File Gateway, or the list of file shares
+ *          that belong to the calling user account. This operation is 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, ListFileSharesCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListFileSharesCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListFileSharesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListFileSharesCommandInput} for command's `input` shape.
+ * @see {@link ListFileSharesCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListFileSharesCommand extends $Command<ListFileSharesCommandInput, ListFileSharesCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListFileSharesCommandInput;
+    constructor(input: ListFileSharesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListFileSharesCommandInput, ListFileSharesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

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

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListGatewaysInput, ListGatewaysOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListGatewaysCommandInput extends ListGatewaysInput {
+}
+export interface ListGatewaysCommandOutput extends ListGatewaysOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists gateways owned by an account in an Region specified in the request. The
+ *          returned list is ordered by gateway Amazon Resource Name (ARN).</p>
+ *
+ *          <p>By default, the operation returns a maximum of 100 gateways. This operation supports
+ *          pagination that allows you to optionally reduce the number of gateways returned in a
+ *          response.</p>
+ *
+ *          <p>If you have more gateways than are returned in a response (that is, the response returns
+ *          only a truncated list of your gateways), the response contains a marker that you can
+ *          specify in your next request to fetch the next page of gateways.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListGatewaysCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListGatewaysCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListGatewaysCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListGatewaysCommandInput} for command's `input` shape.
+ * @see {@link ListGatewaysCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListGatewaysCommand extends $Command<ListGatewaysCommandInput, ListGatewaysCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListGatewaysCommandInput;
+    constructor(input: ListGatewaysCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListGatewaysCommandInput, ListGatewaysCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListLocalDisksCommand.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 { ListLocalDisksInput, ListLocalDisksOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListLocalDisksCommandInput extends ListLocalDisksInput {
+}
+export interface ListLocalDisksCommandOutput extends ListLocalDisksOutput, __MetadataBearer {
+}
+/**
+ * <p>Returns a list of the gateway's local disks. To specify which gateway to describe,
+ *          you use the Amazon Resource Name (ARN) of the gateway in the body of the request.</p>
+ *
+ *          <p>The request returns a list of all disks, specifying which are configured as working
+ *          storage, cache storage, or stored volume or not configured at all. The response includes a
+ *             <code>DiskStatus</code> field. This field can have a value of present (the disk is
+ *          available to use), missing (the disk is no longer connected to the gateway), or mismatch
+ *          (the disk node is occupied by a disk that has incorrect metadata or the disk content is
+ *          corrupted).</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListLocalDisksCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListLocalDisksCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListLocalDisksCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListLocalDisksCommandInput} for command's `input` shape.
+ * @see {@link ListLocalDisksCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListLocalDisksCommand extends $Command<ListLocalDisksCommandInput, ListLocalDisksCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListLocalDisksCommandInput;
+    constructor(input: ListLocalDisksCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListLocalDisksCommandInput, ListLocalDisksCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTagsForResourceCommand.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 { ListTagsForResourceInput, ListTagsForResourceOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListTagsForResourceCommandInput extends ListTagsForResourceInput {
+}
+export interface ListTagsForResourceCommandOutput extends ListTagsForResourceOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists the tags that have been added to 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, ListTagsForResourceCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListTagsForResourceCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListTagsForResourceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTagsForResourceCommandInput} for command's `input` shape.
+ * @see {@link ListTagsForResourceCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTagsForResourceCommand extends $Command<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListTagsForResourceCommandInput;
+    constructor(input: ListTagsForResourceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTagsForResourceCommandInput, ListTagsForResourceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTapePoolsCommand.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 { ListTapePoolsInput, ListTapePoolsOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListTapePoolsCommandInput extends ListTapePoolsInput {
+}
+export interface ListTapePoolsCommandOutput extends ListTapePoolsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists custom tape pools. You specify custom tape pools to list by specifying one or more
+ *          custom tape pool Amazon Resource Names (ARNs). If you don't specify a custom tape pool ARN,
+ *          the operation lists all custom tape pools.</p>
+ *
+ *          <p>This operation supports pagination. You can optionally specify the <code>Limit</code>
+ *          parameter in the body to limit the number of tape pools in the response. If the number of
+ *          tape pools returned in the response is truncated, the response includes a
+ *             <code>Marker</code> element that you can use in your subsequent request to retrieve the
+ *          next set of tape pools.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListTapePoolsCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListTapePoolsCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListTapePoolsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTapePoolsCommandInput} for command's `input` shape.
+ * @see {@link ListTapePoolsCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTapePoolsCommand extends $Command<ListTapePoolsCommandInput, ListTapePoolsCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListTapePoolsCommandInput;
+    constructor(input: ListTapePoolsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTapePoolsCommandInput, ListTapePoolsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListTapesCommand.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 { ListTapesInput, ListTapesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListTapesCommandInput extends ListTapesInput {
+}
+export interface ListTapesCommandOutput extends ListTapesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists virtual tapes in your virtual tape library (VTL) and your virtual tape shelf
+ *          (VTS). You specify the tapes to list by specifying one or more tape Amazon Resource Names
+ *          (ARNs). If you don't specify a tape ARN, the operation lists all virtual tapes in both
+ *          your VTL and VTS.</p>
+ *
+ *          <p>This operation supports pagination. By default, the operation returns a maximum of up to
+ *          100 tapes. You can optionally specify the <code>Limit</code> parameter in the body to limit
+ *          the number of tapes in the response. If the number of tapes returned in the response is
+ *          truncated, the response includes a <code>Marker</code> element that you can use in your
+ *          subsequent request to retrieve the next set of tapes. 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, ListTapesCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListTapesCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListTapesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListTapesCommandInput} for command's `input` shape.
+ * @see {@link ListTapesCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListTapesCommand extends $Command<ListTapesCommandInput, ListTapesCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListTapesCommandInput;
+    constructor(input: ListTapesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListTapesCommandInput, ListTapesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/ts3.4/commands/ListVolumeInitiatorsCommand.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 { ListVolumeInitiatorsInput, ListVolumeInitiatorsOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListVolumeInitiatorsCommandInput extends ListVolumeInitiatorsInput {
+}
+export interface ListVolumeInitiatorsCommandOutput extends ListVolumeInitiatorsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists iSCSI initiators that are connected to a volume. You can use this operation to
+ *          determine whether a volume is being used or not. This operation is only supported in the
+ *          cached volume and stored volume gateway types.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListVolumeInitiatorsCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListVolumeInitiatorsCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListVolumeInitiatorsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVolumeInitiatorsCommandInput} for command's `input` shape.
+ * @see {@link ListVolumeInitiatorsCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListVolumeInitiatorsCommand extends $Command<ListVolumeInitiatorsCommandInput, ListVolumeInitiatorsCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListVolumeInitiatorsCommandInput;
+    constructor(input: ListVolumeInitiatorsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVolumeInitiatorsCommandInput, ListVolumeInitiatorsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,41 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListVolumeRecoveryPointsInput, ListVolumeRecoveryPointsOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListVolumeRecoveryPointsCommandInput extends ListVolumeRecoveryPointsInput {
+}
+export interface ListVolumeRecoveryPointsCommandOutput extends ListVolumeRecoveryPointsOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists the recovery points for a specified gateway. This operation is only supported in
+ *          the cached volume gateway type.</p>
+ *
+ *          <p>Each cache volume has one recovery point. A volume recovery point is a point in time at
+ *          which all data of the volume is consistent and from which you can create a snapshot or
+ *          clone a new cached volume from a source volume. To create a snapshot from a volume recovery
+ *          point use the <a>CreateSnapshotFromVolumeRecoveryPoint</a> operation.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListVolumeRecoveryPointsCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListVolumeRecoveryPointsCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListVolumeRecoveryPointsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVolumeRecoveryPointsCommandInput} for command's `input` shape.
+ * @see {@link ListVolumeRecoveryPointsCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListVolumeRecoveryPointsCommand extends $Command<ListVolumeRecoveryPointsCommandInput, ListVolumeRecoveryPointsCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListVolumeRecoveryPointsCommandInput;
+    constructor(input: ListVolumeRecoveryPointsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVolumeRecoveryPointsCommandInput, ListVolumeRecoveryPointsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,44 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListVolumesInput, ListVolumesOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface ListVolumesCommandInput extends ListVolumesInput {
+}
+export interface ListVolumesCommandOutput extends ListVolumesOutput, __MetadataBearer {
+}
+/**
+ * <p>Lists the iSCSI stored volumes of a gateway. Results are sorted by volume ARN. The
+ *          response includes only the volume ARNs. If you want additional volume information, use the
+ *             <a>DescribeStorediSCSIVolumes</a> or the <a>DescribeCachediSCSIVolumes</a> API.</p>
+ *
+ *          <p>The operation supports pagination. By default, the operation returns a maximum of up to
+ *          100 volumes. You can optionally specify the <code>Limit</code> field in the body to limit
+ *          the number of volumes in the response. If the number of volumes returned in the response is
+ *          truncated, the response includes a Marker field. You can use this Marker value in your
+ *          subsequent request to retrieve the next set of volumes. This operation is only supported in
+ *          the cached volume and stored volume gateway types.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, ListVolumesCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, ListVolumesCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new ListVolumesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListVolumesCommandInput} for command's `input` shape.
+ * @see {@link ListVolumesCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class ListVolumesCommand extends $Command<ListVolumesCommandInput, ListVolumesCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: ListVolumesCommandInput;
+    constructor(input: ListVolumesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListVolumesCommandInput, ListVolumesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,49 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { NotifyWhenUploadedInput, NotifyWhenUploadedOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface NotifyWhenUploadedCommandInput extends NotifyWhenUploadedInput {
+}
+export interface NotifyWhenUploadedCommandOutput extends NotifyWhenUploadedOutput, __MetadataBearer {
+}
+/**
+ * <p>Sends you notification through CloudWatch Events when all files written to your file
+ *          share have been uploaded to Amazon S3.</p>
+ *
+ *          <p>Storage Gateway can send a notification through Amazon CloudWatch Events when all
+ *          files written to your file share up to that point in time have been uploaded to Amazon S3.
+ *          These files include files written to the file share up to the time that you make a request
+ *          for notification. When the upload is done, Storage Gateway sends you notification through
+ *          an Amazon CloudWatch Event. You can configure CloudWatch Events to send the notification
+ *          through event targets such as Amazon SNS or Lambda function.
+ *          This operation is only supported for S3 File Gateways.</p>
+ *
+ *
+ *
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/storagegateway/latest/userguide/monitoring-file-gateway.html#get-upload-notification">Getting file upload notification</a> in the <i>Storage Gateway User
+ *             Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, NotifyWhenUploadedCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, NotifyWhenUploadedCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new NotifyWhenUploadedCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link NotifyWhenUploadedCommandInput} for command's `input` shape.
+ * @see {@link NotifyWhenUploadedCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class NotifyWhenUploadedCommand extends $Command<NotifyWhenUploadedCommandInput, NotifyWhenUploadedCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: NotifyWhenUploadedCommandInput;
+    constructor(input: NotifyWhenUploadedCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<NotifyWhenUploadedCommandInput, NotifyWhenUploadedCommandOutput>;
+    private serialize;
+    private deserialize;
+}

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

@@ -0,0 +1,65 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { RefreshCacheInput, RefreshCacheOutput } from "../models/models_0";
+import { ServiceInputTypes, ServiceOutputTypes, StorageGatewayClientResolvedConfig } from "../StorageGatewayClient";
+export interface RefreshCacheCommandInput extends RefreshCacheInput {
+}
+export interface RefreshCacheCommandOutput extends RefreshCacheOutput, __MetadataBearer {
+}
+/**
+ * <p>Refreshes the cached inventory of objects for the specified file share. This operation
+ *          finds objects in the Amazon S3 bucket that were added, removed, or replaced since the
+ *          gateway last listed the bucket's contents and cached the results. This operation does
+ *          not import files into the S3 File Gateway cache storage. It only updates the cached inventory
+ *          to reflect changes in the inventory of the objects in the S3 bucket. This operation is only
+ *          supported in the S3 File Gateway types.</p>
+ *          <p>You can subscribe to be notified through an Amazon
+ *          CloudWatch event when your <code>RefreshCache</code> operation completes. For more
+ *          information, see <a href="https://docs.aws.amazon.com/storagegateway/latest/userguide/monitoring-file-gateway.html#get-notification">Getting notified about file operations</a> in the <i>Storage Gateway
+ *                User Guide</i>. This operation is Only supported for S3 File Gateways.</p>
+ *
+ *          <p>When this API is called, it only initiates the refresh operation. When the API call
+ *          completes and returns a success code, it doesn't necessarily mean that the file
+ *          refresh has completed. You should use the refresh-complete notification to determine that
+ *          the operation has completed before you check for new files on the gateway file share. You
+ *          can subscribe to be notified through a CloudWatch event when your <code>RefreshCache</code>
+ *          operation completes.</p>
+ *
+ *          <p>Throttle limit: This API is asynchronous, so the gateway will accept no more than two
+ *          refreshes at any time. We recommend using the refresh-complete CloudWatch event
+ *          notification before issuing additional requests. For more information, see <a href="https://docs.aws.amazon.com/storagegateway/latest/userguide/monitoring-file-gateway.html#get-notification">Getting notified about file operations</a> in the <i>Storage Gateway
+ *             User Guide</i>.</p>
+ *
+ *          <p>If you invoke the RefreshCache API when two requests are already being processed, any
+ *          new request will cause an <code>InvalidGatewayRequestException</code> error because too
+ *          many requests were sent to the server.</p>
+ *
+ *
+ *
+ *          <p>For more information, see <a href="https://docs.aws.amazon.com/storagegateway/latest/userguide/monitoring-file-gateway.html#get-notification">Getting notified about file operations</a> in the <i>Storage Gateway
+ *             User Guide</i>.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { StorageGatewayClient, RefreshCacheCommand } from "@aws-sdk/client-storage-gateway"; // ES Modules import
+ * // const { StorageGatewayClient, RefreshCacheCommand } = require("@aws-sdk/client-storage-gateway"); // CommonJS import
+ * const client = new StorageGatewayClient(config);
+ * const command = new RefreshCacheCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link RefreshCacheCommandInput} for command's `input` shape.
+ * @see {@link RefreshCacheCommandOutput} for command's `response` shape.
+ * @see {@link StorageGatewayClientResolvedConfig | config} for command's `input` shape.
+ *
+ */
+export declare class RefreshCacheCommand extends $Command<RefreshCacheCommandInput, RefreshCacheCommandOutput, StorageGatewayClientResolvedConfig> {
+    readonly input: RefreshCacheCommandInput;
+    constructor(input: RefreshCacheCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: StorageGatewayClientResolvedConfig, options?: __HttpHandlerOptions): Handler<RefreshCacheCommandInput, RefreshCacheCommandOutput>;
+    private serialize;
+    private deserialize;
+}