@aws-sdk/client-ebs 3.35.0 → 3.38.0

package/dist-types/ts3.4/EBSClient.d.ts

@@ -15,143 +15,59 @@ import { StartSnapshotCommandInput, StartSnapshotCommandOutput } from "./command
 export declare type ServiceInputTypes = CompleteSnapshotCommandInput | GetSnapshotBlockCommandInput | ListChangedBlocksCommandInput | ListSnapshotBlocksCommandInput | PutSnapshotBlockCommandInput | StartSnapshotCommandInput;
 export declare type ServiceOutputTypes = CompleteSnapshotCommandOutput | GetSnapshotBlockCommandOutput | ListChangedBlocksCommandOutput | ListSnapshotBlocksCommandOutput | PutSnapshotBlockCommandOutput | StartSnapshotCommandOutput;
 export interface ClientDefaults extends Partial<__SmithyResolvedConfiguration<__HttpHandlerOptions>> {
-    /**
-     * The HTTP handler to use. Fetch in browser and Https in Nodejs.
-     */
+    
     requestHandler?: __HttpHandler;
-    /**
-     * A constructor for a class implementing the {@link __Hash} interface
-     * that computes the SHA-256 HMAC or checksum of a string or binary buffer.
-     * @internal
-     */
+    
     sha256?: __HashConstructor;
-    /**
-     * The function that will be used to convert strings into HTTP endpoints.
-     * @internal
-     */
+    
     urlParser?: __UrlParser;
-    /**
-     * A function that can calculate the length of a request body.
-     * @internal
-     */
+    
     bodyLengthChecker?: (body: any) => number | undefined;
-    /**
-     * A function that converts a stream into an array of bytes.
-     * @internal
-     */
+    
     streamCollector?: __StreamCollector;
-    /**
-     * The function that will be used to convert a base64-encoded string to a byte array.
-     * @internal
-     */
+    
     base64Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a base64-encoded string.
-     * @internal
-     */
+    
     base64Encoder?: __Encoder;
-    /**
-     * The function that will be used to convert a UTF8-encoded string to a byte array.
-     * @internal
-     */
+    
     utf8Decoder?: __Decoder;
-    /**
-     * The function that will be used to convert binary data to a UTF-8 encoded string.
-     * @internal
-     */
+    
     utf8Encoder?: __Encoder;
-    /**
-     * The runtime environment.
-     * @internal
-     */
+    
     runtime?: string;
-    /**
-     * Disable dyanamically changing the endpoint of the client based on the hostPrefix
-     * trait of an operation.
-     */
+    
     disableHostPrefix?: boolean;
-    /**
-     * Value for how many times a request will be made at most in case of retry.
-     */
+    
     maxAttempts?: number | __Provider<number>;
-    /**
-     * Specifies which retry algorithm to use.
-     */
+    
     retryMode?: string | __Provider<string>;
-    /**
-     * Optional logger for logging debug/info/warn/error.
-     */
+    
     logger?: __Logger;
-    /**
-     * Unique service identifier.
-     * @internal
-     */
+    
     serviceId?: string;
-    /**
-     * The AWS region to which this client will send requests
-     */
+    
     region?: string | __Provider<string>;
-    /**
-     * Default credentials provider; Not available in browser runtime.
-     * @internal
-     */
+    
     credentialDefaultProvider?: (input: any) => __Provider<__Credentials>;
-    /**
-     * Fetch related hostname, signing name or signing region with given region.
-     * @internal
-     */
+    
     regionInfoProvider?: RegionInfoProvider;
-    /**
-     * The provider populating default tracking information to be sent with `user-agent`, `x-amz-user-agent` header
-     * @internal
-     */
+    
     defaultUserAgentProvider?: Provider<__UserAgent>;
 }
 declare type EBSClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & RegionInputConfig & EndpointsInputConfig & RetryInputConfig & HostHeaderInputConfig & AwsAuthInputConfig & UserAgentInputConfig;
-/**
- * The configuration interface of EBSClient class constructor that set the region, credentials and other options.
- */
+
 export interface EBSClientConfig extends EBSClientConfigType {
 }
 declare type EBSClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RegionResolvedConfig & EndpointsResolvedConfig & RetryResolvedConfig & HostHeaderResolvedConfig & AwsAuthResolvedConfig & UserAgentResolvedConfig;
-/**
- * The resolved configuration interface of EBSClient class. This is resolved and normalized from the {@link EBSClientConfig | constructor configuration interface}.
- */
+
 export interface EBSClientResolvedConfig extends EBSClientResolvedConfigType {
 }
-/**
- * <p>You can use the Amazon Elastic Block Store (Amazon EBS) direct APIs to create Amazon EBS snapshots, write data directly to
- *     		your snapshots, read data on your snapshots, and identify the differences or changes between
- *     		two snapshots. If you’re an independent software vendor (ISV) who offers backup services for
- *     		Amazon EBS, the EBS direct APIs make it more efficient and cost-effective to track incremental changes on
- *     		your Amazon EBS volumes through snapshots. This can be done without having to create new volumes
- *     		from snapshots, and then use Amazon Elastic Compute Cloud (Amazon EC2) instances to compare the differences.</p>
- *
- *     	    <p>You can create incremental snapshots directly from data on-premises into volumes and the
- *     		cloud to use for quick disaster recovery. With the ability to write and read snapshots, you can
- *     		write your on-premises data to an snapshot during a disaster. Then after recovery, you can
- *     		restore it back to Amazon Web Services or on-premises from the snapshot. You no longer need to build and
- *     		maintain complex mechanisms to copy data to and from Amazon EBS.</p>
- *
- *
- *         <p>This API reference provides detailed information about the actions, data types,
- *             parameters, and errors of the EBS direct APIs. For more information about the elements that
- *             make up the EBS direct APIs, and examples of how to use them effectively, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html">Accessing the Contents of an Amazon EBS Snapshot</a> in the <i>Amazon Elastic Compute Cloud User
- *                 Guide</i>. For more information about the supported Amazon Web Services Regions, endpoints,
- *             and service quotas for the EBS direct APIs, see <a href="https://docs.aws.amazon.com/general/latest/gr/ebs-service.html">Amazon Elastic Block Store Endpoints and Quotas</a> in
- *             the <i>Amazon Web Services General Reference</i>.</p>
- */
+
 export declare class EBSClient extends __Client<__HttpHandlerOptions, ServiceInputTypes, ServiceOutputTypes, EBSClientResolvedConfig> {
-    /**
-     * The resolved configuration of EBSClient class. This is resolved and normalized from the {@link EBSClientConfig | constructor configuration interface}.
-     */
+    
     readonly config: EBSClientResolvedConfig;
     constructor(configuration: EBSClientConfig);
-    /**
-     * Destroy underlying resources, like sockets. It's usually not necessary to do this.
-     * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
-     * Otherwise, sockets might stay open for quite a long time before the server terminates them.
-     */
+    
     destroy(): void;
 }
 export {};

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

@@ -6,31 +6,11 @@ export interface CompleteSnapshotCommandInput extends CompleteSnapshotRequest {
 }
 export interface CompleteSnapshotCommandOutput extends CompleteSnapshotResponse, __MetadataBearer {
 }
-/**
- * <p>Seals and completes the snapshot after all of the required blocks of data have been
- *             written to it. Completing the snapshot changes the status to <code>completed</code>. You
- *             cannot write new blocks to a snapshot after it has been completed.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, CompleteSnapshotCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, CompleteSnapshotCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new CompleteSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link CompleteSnapshotCommandInput} for command's `input` shape.
- * @see {@link CompleteSnapshotCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class CompleteSnapshotCommand extends $Command<CompleteSnapshotCommandInput, CompleteSnapshotCommandOutput, EBSClientResolvedConfig> {
     readonly input: CompleteSnapshotCommandInput;
     constructor(input: CompleteSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CompleteSnapshotCommandInput, CompleteSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface GetSnapshotBlockCommandInput extends GetSnapshotBlockRequest {
 }
 export interface GetSnapshotBlockCommandOutput extends GetSnapshotBlockResponse, __MetadataBearer {
 }
-/**
- * <p>Returns the data in a block in an Amazon Elastic Block Store snapshot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, GetSnapshotBlockCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, GetSnapshotBlockCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new GetSnapshotBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link GetSnapshotBlockCommandInput} for command's `input` shape.
- * @see {@link GetSnapshotBlockCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class GetSnapshotBlockCommand extends $Command<GetSnapshotBlockCommandInput, GetSnapshotBlockCommandOutput, EBSClientResolvedConfig> {
     readonly input: GetSnapshotBlockCommandInput;
     constructor(input: GetSnapshotBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSnapshotBlockCommandInput, GetSnapshotBlockCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,30 +6,11 @@ export interface ListChangedBlocksCommandInput extends ListChangedBlocksRequest
 }
 export interface ListChangedBlocksCommandOutput extends ListChangedBlocksResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about the blocks that are different between two
- *             Amazon Elastic Block Store snapshots of the same volume/snapshot lineage.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, ListChangedBlocksCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, ListChangedBlocksCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new ListChangedBlocksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListChangedBlocksCommandInput} for command's `input` shape.
- * @see {@link ListChangedBlocksCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListChangedBlocksCommand extends $Command<ListChangedBlocksCommandInput, ListChangedBlocksCommandOutput, EBSClientResolvedConfig> {
     readonly input: ListChangedBlocksCommandInput;
     constructor(input: ListChangedBlocksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListChangedBlocksCommandInput, ListChangedBlocksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,29 +6,11 @@ export interface ListSnapshotBlocksCommandInput extends ListSnapshotBlocksReques
 }
 export interface ListSnapshotBlocksCommandOutput extends ListSnapshotBlocksResponse, __MetadataBearer {
 }
-/**
- * <p>Returns information about the blocks in an Amazon Elastic Block Store snapshot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, ListSnapshotBlocksCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, ListSnapshotBlocksCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new ListSnapshotBlocksCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link ListSnapshotBlocksCommandInput} for command's `input` shape.
- * @see {@link ListSnapshotBlocksCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class ListSnapshotBlocksCommand extends $Command<ListSnapshotBlocksCommandInput, ListSnapshotBlocksCommandOutput, EBSClientResolvedConfig> {
     readonly input: ListSnapshotBlocksCommandInput;
     constructor(input: ListSnapshotBlocksCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSnapshotBlocksCommandInput, ListSnapshotBlocksCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -1,47 +1,22 @@
-/// <reference types="node" />
+
 import { Command as $Command } from "@aws-sdk/smithy-client";
 import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
 import { EBSClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../EBSClient";
 import { PutSnapshotBlockRequest, PutSnapshotBlockResponse } from "../models/models_0";
 declare type PutSnapshotBlockCommandInputType = Pick<PutSnapshotBlockRequest, Exclude<keyof PutSnapshotBlockRequest, "BlockData">> & {
-    /**
-     * For *`PutSnapshotBlockRequest["BlockData"]`*, see {@link PutSnapshotBlockRequest.BlockData}.
-     */
+    
     BlockData: PutSnapshotBlockRequest["BlockData"] | string | Uint8Array | Buffer;
 };
-/**
- * This interface extends from `PutSnapshotBlockRequest` interface. There are more parameters than `BlockData` defined in {@link PutSnapshotBlockRequest}
- */
+
 export interface PutSnapshotBlockCommandInput extends PutSnapshotBlockCommandInputType {
 }
 export interface PutSnapshotBlockCommandOutput extends PutSnapshotBlockResponse, __MetadataBearer {
 }
-/**
- * <p>Writes a block of data to a snapshot. If the specified block contains
- *             data, the existing data is overwritten. The target snapshot must be in the
- *                 <code>pending</code> state.</p>
- *     	    <p>Data written to a snapshot must be aligned with 512-KiB sectors.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, PutSnapshotBlockCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, PutSnapshotBlockCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new PutSnapshotBlockCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link PutSnapshotBlockCommandInput} for command's `input` shape.
- * @see {@link PutSnapshotBlockCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class PutSnapshotBlockCommand extends $Command<PutSnapshotBlockCommandInput, PutSnapshotBlockCommandOutput, EBSClientResolvedConfig> {
     readonly input: PutSnapshotBlockCommandInput;
     constructor(input: PutSnapshotBlockCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<PutSnapshotBlockCommandInput, PutSnapshotBlockCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -6,32 +6,11 @@ export interface StartSnapshotCommandInput extends StartSnapshotRequest {
 }
 export interface StartSnapshotCommandOutput extends StartSnapshotResponse, __MetadataBearer {
 }
-/**
- * <p>Creates a new Amazon EBS snapshot. The new snapshot enters the <code>pending</code> state
- *             after the request completes. </p>
- *         <p>After creating the snapshot, use <a href="https://docs.aws.amazon.com/ebs/latest/APIReference/API_PutSnapshotBlock.html"> PutSnapshotBlock</a> to
- *             write blocks of data to the snapshot.</p>
- * @example
- * Use a bare-bones client and the command you need to make an API call.
- * ```javascript
- * import { EBSClient, StartSnapshotCommand } from "@aws-sdk/client-ebs"; // ES Modules import
- * // const { EBSClient, StartSnapshotCommand } = require("@aws-sdk/client-ebs"); // CommonJS import
- * const client = new EBSClient(config);
- * const command = new StartSnapshotCommand(input);
- * const response = await client.send(command);
- * ```
- *
- * @see {@link StartSnapshotCommandInput} for command's `input` shape.
- * @see {@link StartSnapshotCommandOutput} for command's `response` shape.
- * @see {@link EBSClientResolvedConfig | config} for command's `input` shape.
- *
- */
+
 export declare class StartSnapshotCommand extends $Command<StartSnapshotCommandInput, StartSnapshotCommandOutput, EBSClientResolvedConfig> {
     readonly input: StartSnapshotCommandInput;
     constructor(input: StartSnapshotCommandInput);
-    /**
-     * @internal
-     */
+    
     resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: EBSClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartSnapshotCommandInput, StartSnapshotCommandOutput>;
     private serialize;
     private deserialize;

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

@@ -0,0 +1,6 @@
+export * from "./CompleteSnapshotCommand";
+export * from "./GetSnapshotBlockCommand";
+export * from "./ListChangedBlocksCommand";
+export * from "./ListSnapshotBlocksCommand";
+export * from "./PutSnapshotBlockCommand";
+export * from "./StartSnapshotCommand";

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

@@ -1,12 +1,5 @@
-export * from "./EBSClient";
 export * from "./EBS";
-export * from "./commands/CompleteSnapshotCommand";
-export * from "./commands/GetSnapshotBlockCommand";
-export * from "./commands/ListChangedBlocksCommand";
-export * from "./pagination/ListChangedBlocksPaginator";
-export * from "./commands/ListSnapshotBlocksCommand";
-export * from "./pagination/ListSnapshotBlocksPaginator";
-export * from "./commands/PutSnapshotBlockCommand";
-export * from "./commands/StartSnapshotCommand";
-export * from "./pagination/Interfaces";
-export * from "./models/index";
+export * from "./EBSClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";