@aws-sdk/client-ebs 3.928.0 → 3.930.0

package/dist-cjs/index.js

@@ -6,6 +6,7 @@ var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detect
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
 var core = require('@smithy/core');
+var schema = require('@smithy/core/schema');
 var middlewareContentLength = require('@smithy/middleware-content-length');
 var middlewareEndpoint = require('@smithy/middleware-endpoint');
 var middlewareRetry = require('@smithy/middleware-retry');
@@ -14,9 +15,6 @@ var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
 var protocolHttp = require('@smithy/protocol-http');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core$1 = require('@aws-sdk/core');
-var uuid = require('@smithy/uuid');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -92,6 +90,7 @@ class EBSClient extends smithyClient.Client {
         const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
         const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
         this.config = _config_8;
+        this.middlewareStack.use(schema.getSchemaSerdePlugin(this.config));
         this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
         this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
         this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
@@ -111,18 +110,18 @@ class EBSClient extends smithyClient.Client {
     }
 }
 
-class EBSServiceException extends smithyClient.ServiceException {
+let EBSServiceException$1 = class EBSServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, EBSServiceException.prototype);
     }
-}
+};
 
 const AccessDeniedExceptionReason = {
     DEPENDENCY_ACCESS_DENIED: "DEPENDENCY_ACCESS_DENIED",
     UNAUTHORIZED_ACCOUNT: "UNAUTHORIZED_ACCOUNT",
 };
-class AccessDeniedException extends EBSServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends EBSServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -137,7 +136,7 @@ class AccessDeniedException extends EBSServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ChecksumAggregationMethod = {
     CHECKSUM_AGGREGATION_LINEAR: "LINEAR",
 };
@@ -149,7 +148,7 @@ const Status = {
     ERROR: "error",
     PENDING: "pending",
 };
-class InternalServerException extends EBSServiceException {
+let InternalServerException$1 = class InternalServerException extends EBSServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -162,13 +161,13 @@ class InternalServerException extends EBSServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const RequestThrottledExceptionReason = {
     ACCOUNT_THROTTLED: "ACCOUNT_THROTTLED",
     DEPENDENCY_REQUEST_THROTTLED: "DEPENDENCY_REQUEST_THROTTLED",
     RESOURCE_LEVEL_THROTTLE: "RESOURCE_LEVEL_THROTTLE",
 };
-class RequestThrottledException extends EBSServiceException {
+let RequestThrottledException$1 = class RequestThrottledException extends EBSServiceException$1 {
     name = "RequestThrottledException";
     $fault = "client";
     Message;
@@ -183,14 +182,14 @@ class RequestThrottledException extends EBSServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ResourceNotFoundExceptionReason = {
     DEPENDENCY_RESOURCE_NOT_FOUND: "DEPENDENCY_RESOURCE_NOT_FOUND",
     GRANT_NOT_FOUND: "GRANT_NOT_FOUND",
     IMAGE_NOT_FOUND: "IMAGE_NOT_FOUND",
     SNAPSHOT_NOT_FOUND: "SNAPSHOT_NOT_FOUND",
 };
-class ResourceNotFoundException extends EBSServiceException {
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends EBSServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -205,11 +204,11 @@ class ResourceNotFoundException extends EBSServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ServiceQuotaExceededExceptionReason = {
     DEPENDENCY_SERVICE_QUOTA_EXCEEDED: "DEPENDENCY_SERVICE_QUOTA_EXCEEDED",
 };
-class ServiceQuotaExceededException extends EBSServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends EBSServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -224,7 +223,7 @@ class ServiceQuotaExceededException extends EBSServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
+};
 const ValidationExceptionReason = {
     CONFLICTING_BLOCK_UPDATE: "CONFLICTING_BLOCK_UPDATE",
     INVALID_BLOCK: "INVALID_BLOCK",
@@ -242,7 +241,7 @@ const ValidationExceptionReason = {
     UNRELATED_SNAPSHOTS: "UNRELATED_SNAPSHOTS",
     WRITE_REQUEST_TIMEOUT: "WRITE_REQUEST_TIMEOUT",
 };
-class ValidationException extends EBSServiceException {
+let ValidationException$1 = class ValidationException extends EBSServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -257,8 +256,8 @@ class ValidationException extends EBSServiceException {
         this.Message = opts.Message;
         this.Reason = opts.Reason;
     }
-}
-class ConcurrentLimitExceededException extends EBSServiceException {
+};
+let ConcurrentLimitExceededException$1 = class ConcurrentLimitExceededException extends EBSServiceException$1 {
     name = "ConcurrentLimitExceededException";
     $fault = "client";
     Message;
@@ -271,8 +270,8 @@ class ConcurrentLimitExceededException extends EBSServiceException {
         Object.setPrototypeOf(this, ConcurrentLimitExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ConflictException extends EBSServiceException {
+};
+let ConflictException$1 = class ConflictException extends EBSServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -285,430 +284,517 @@ class ConflictException extends EBSServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const SSEType = {
     NONE: "none",
     SSE_EBS: "sse-ebs",
     SSE_KMS: "sse-kms",
 };
-const ChangedBlockFilterSensitiveLog = (obj) => ({
-    ...obj,
-});
-const GetSnapshotBlockResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BlockData && { BlockData: smithyClient.SENSITIVE_STRING }),
-});
-const ListChangedBlocksResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ChangedBlocks && { ChangedBlocks: smithyClient.SENSITIVE_STRING }),
-});
-const ListSnapshotBlocksResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.Blocks && { Blocks: smithyClient.SENSITIVE_STRING }),
-});
-const PutSnapshotBlockRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.BlockData && { BlockData: smithyClient.SENSITIVE_STRING }),
-});
-const StartSnapshotRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.KmsKeyArn && { KmsKeyArn: smithyClient.SENSITIVE_STRING }),
-});
-const StartSnapshotResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.KmsKeyArn && { KmsKeyArn: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_CompleteSnapshotCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        [_xac]: [() => smithyClient.isSerializableHeaderValue(input[_CBC]), () => input[_CBC].toString()],
-        [_xac_]: input[_C],
-        [_xaca]: input[_CA],
-        [_xacam]: input[_CAM],
-    });
-    b.bp("/snapshots/completion/{SnapshotId}");
-    b.p("SnapshotId", () => input.SnapshotId, "{SnapshotId}", false);
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetSnapshotBlockCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/snapshots/{SnapshotId}/blocks/{BlockIndex}");
-    b.p("SnapshotId", () => input.SnapshotId, "{SnapshotId}", false);
-    b.p("BlockIndex", () => input.BlockIndex.toString(), "{BlockIndex}", false);
-    const query = smithyClient.map({
-        [_bT]: [, smithyClient.expectNonNull(input[_BT], `BlockToken`)],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListChangedBlocksCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/snapshots/{SecondSnapshotId}/changedblocks");
-    b.p("SecondSnapshotId", () => input.SecondSnapshotId, "{SecondSnapshotId}", false);
-    const query = smithyClient.map({
-        [_fSI]: [, input[_FSI]],
-        [_pT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_sBI]: [() => input.StartingBlockIndex !== void 0, () => input[_SBI].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListSnapshotBlocksCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/snapshots/{SnapshotId}/blocks");
-    b.p("SnapshotId", () => input.SnapshotId, "{SnapshotId}", false);
-    const query = smithyClient.map({
-        [_pT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_sBI]: [() => input.StartingBlockIndex !== void 0, () => input[_SBI].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_PutSnapshotBlockCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "x-amz-content-sha256": "UNSIGNED-PAYLOAD",
-        "content-type": "application/octet-stream",
-        [_xadl]: [() => smithyClient.isSerializableHeaderValue(input[_DL]), () => input[_DL].toString()],
-        [_xap]: [() => smithyClient.isSerializableHeaderValue(input[_P]), () => input[_P].toString()],
-        [_xac_]: input[_C],
-        [_xaca]: input[_CA],
-    });
-    b.bp("/snapshots/{SnapshotId}/blocks/{BlockIndex}");
-    b.p("SnapshotId", () => input.SnapshotId, "{SnapshotId}", false);
-    b.p("BlockIndex", () => input.BlockIndex.toString(), "{BlockIndex}", false);
-    let body;
-    if (input.BlockData !== undefined) {
-        body = input.BlockData;
-    }
-    b.m("PUT").h(headers).b(body);
-    return b.build();
-};
-const se_StartSnapshotCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/snapshots");
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        Description: [],
-        Encrypted: [],
-        KmsKeyArn: [],
-        ParentSnapshotId: [],
-        Tags: (_) => smithyClient._json(_),
-        Timeout: [],
-        VolumeSize: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_CompleteSnapshotCommand = async (output, context) => {
-    if (output.statusCode !== 202 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        Status: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetSnapshotBlockCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_DL]: [() => void 0 !== output.headers[_xadl], () => smithyClient.strictParseInt32(output.headers[_xadl])],
-        [_C]: [, output.headers[_xac_]],
-        [_CA]: [, output.headers[_xaca]],
-    });
-    const data = output.body;
-    context.sdkStreamMixin(data);
-    contents.BlockData = data;
-    return contents;
-};
-const de_ListChangedBlocksCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        BlockSize: smithyClient.expectInt32,
-        ChangedBlocks: smithyClient._json,
-        ExpiryTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        VolumeSize: smithyClient.expectLong,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListSnapshotBlocksCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        BlockSize: smithyClient.expectInt32,
-        Blocks: smithyClient._json,
-        ExpiryTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NextToken: smithyClient.expectString,
-        VolumeSize: smithyClient.expectLong,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_PutSnapshotBlockCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-        [_C]: [, output.headers[_xac_]],
-        [_CA]: [, output.headers[_xaca]],
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_StartSnapshotCommand = async (output, context) => {
-    if (output.statusCode !== 201 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    const data = smithyClient.expectNonNull(smithyClient.expectObject(await core$1.parseJsonBody(output.body, context)), "body");
-    const doc = smithyClient.take(data, {
-        BlockSize: smithyClient.expectInt32,
-        Description: smithyClient.expectString,
-        KmsKeyArn: smithyClient.expectString,
-        OwnerId: smithyClient.expectString,
-        ParentSnapshotId: smithyClient.expectString,
-        SnapshotId: smithyClient.expectString,
-        SseType: smithyClient.expectString,
-        StartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Status: smithyClient.expectString,
-        Tags: smithyClient._json,
-        VolumeSize: smithyClient.expectLong,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_CommandError = async (output, context) => {
-    const parsedOutput = {
-        ...output,
-        body: await core$1.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.ebs#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.ebs#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "RequestThrottledException":
-        case "com.amazonaws.ebs#RequestThrottledException":
-            throw await de_RequestThrottledExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.ebs#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.ebs#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.ebs#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ConcurrentLimitExceededException":
-        case "com.amazonaws.ebs#ConcurrentLimitExceededException":
-            throw await de_ConcurrentLimitExceededExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.ebs#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(EBSServiceException);
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConcurrentLimitExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConcurrentLimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConflictExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ConflictException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_RequestThrottledExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new RequestThrottledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ServiceQuotaExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const contents = smithyClient.map({});
-    const data = parsedOutput.body;
-    const doc = smithyClient.take(data, {
-        Message: smithyClient.expectString,
-        Reason: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const deserializeMetadata = (output) => ({
-    httpStatusCode: output.statusCode,
-    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
-    extendedRequestId: output.headers["x-amz-id-2"],
-    cfId: output.headers["x-amz-cf-id"],
-});
+const _ADE = "AccessDeniedException";
+const _B = "Block";
+const _BD = "BlockData";
+const _BI = "BlockIndex";
+const _BS = "BlockSize";
 const _BT = "BlockToken";
+const _Bl = "Blocks";
 const _C = "Checksum";
 const _CA = "ChecksumAlgorithm";
 const _CAM = "ChecksumAggregationMethod";
+const _CB = "ChangedBlock";
 const _CBC = "ChangedBlocksCount";
+const _CBh = "ChangedBlocks";
+const _CE = "ConflictException";
+const _CLEE = "ConcurrentLimitExceededException";
+const _CS = "CompleteSnapshot";
+const _CSR = "CompleteSnapshotRequest";
+const _CSRo = "CompleteSnapshotResponse";
+const _CT = "ClientToken";
+const _D = "Description";
 const _DL = "DataLength";
+const _E = "Encrypted";
+const _ET = "ExpiryTime";
+const _FBT = "FirstBlockToken";
 const _FSI = "FirstSnapshotId";
+const _GSB = "GetSnapshotBlock";
+const _GSBR = "GetSnapshotBlockRequest";
+const _GSBRe = "GetSnapshotBlockResponse";
+const _ISE = "InternalServerException";
+const _K = "Key";
+const _KKA = "KmsKeyArn";
+const _LCB = "ListChangedBlocks";
+const _LCBR = "ListChangedBlocksRequest";
+const _LCBRi = "ListChangedBlocksResponse";
+const _LSB = "ListSnapshotBlocks";
+const _LSBR = "ListSnapshotBlocksRequest";
+const _LSBRi = "ListSnapshotBlocksResponse";
+const _M = "Message";
 const _MR = "MaxResults";
 const _NT = "NextToken";
+const _OI = "OwnerId";
 const _P = "Progress";
+const _PSB = "PutSnapshotBlock";
+const _PSBR = "PutSnapshotBlockRequest";
+const _PSBRu = "PutSnapshotBlockResponse";
+const _PSI = "ParentSnapshotId";
+const _R = "Reason";
+const _RNFE = "ResourceNotFoundException";
+const _RTE = "RequestThrottledException";
+const _S = "Status";
 const _SBI = "StartingBlockIndex";
+const _SBT = "SecondBlockToken";
+const _SI = "SnapshotId";
+const _SQEE = "ServiceQuotaExceededException";
+const _SS = "StartSnapshot";
+const _SSI = "SecondSnapshotId";
+const _SSR = "StartSnapshotRequest";
+const _SSRt = "StartSnapshotResponse";
+const _ST = "StartTime";
+const _STs = "SseType";
+const _T = "Tags";
+const _Ta = "Tag";
+const _Ti = "Timeout";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VS = "VolumeSize";
 const _bT = "blockToken";
+const _c = "client";
+const _e = "error";
 const _fSI = "firstSnapshotId";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
 const _mR = "maxResults";
 const _pT = "pageToken";
+const _s = "streaming";
 const _sBI = "startingBlockIndex";
-const _xac = "x-amz-changedblockscount";
-const _xac_ = "x-amz-checksum";
-const _xaca = "x-amz-checksum-algorithm";
-const _xacam = "x-amz-checksum-aggregation-method";
-const _xadl = "x-amz-data-length";
-const _xap = "x-amz-progress";
+const _se = "sensitive";
+const _ser = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.ebs";
+const _xaC = "x-amz-ChangedBlocksCount";
+const _xaCA = "x-amz-Checksum-Algorithm";
+const _xaCAM = "x-amz-Checksum-Aggregation-Method";
+const _xaC_ = "x-amz-Checksum";
+const _xaDL = "x-amz-Data-Length";
+const _xaP = "x-amz-Progress";
+const n0 = "com.amazonaws.ebs";
+var BlockData = [
+    0,
+    n0,
+    _BD,
+    {
+        [_s]: 1,
+        [_se]: 1,
+    },
+    42,
+];
+var KmsKeyArn = [0, n0, _KKA, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var Block = [3, n0, _B, 0, [_BI, _BT], [1, 0]];
+var ChangedBlock = [3, n0, _CB, 8, [_BI, _FBT, _SBT], [1, 0, 0]];
+var CompleteSnapshotRequest = [
+    3,
+    n0,
+    _CSR,
+    0,
+    [_SI, _CBC, _C, _CA, _CAM],
+    [
+        [0, 1],
+        [
+            1,
+            {
+                [_hH]: _xaC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaC_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaCA,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaCAM,
+            },
+        ],
+    ],
+];
+var CompleteSnapshotResponse = [3, n0, _CSRo, 0, [_S], [0]];
+var ConcurrentLimitExceededException = [
+    -3,
+    n0,
+    _CLEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConcurrentLimitExceededException, ConcurrentLimitExceededException$1);
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var GetSnapshotBlockRequest = [
+    3,
+    n0,
+    _GSBR,
+    0,
+    [_SI, _BI, _BT],
+    [
+        [0, 1],
+        [1, 1],
+        [
+            0,
+            {
+                [_hQ]: _bT,
+            },
+        ],
+    ],
+];
+var GetSnapshotBlockResponse = [
+    3,
+    n0,
+    _GSBRe,
+    0,
+    [_DL, _BD, _C, _CA],
+    [
+        [
+            1,
+            {
+                [_hH]: _xaDL,
+            },
+        ],
+        [() => BlockData, 16],
+        [
+            0,
+            {
+                [_hH]: _xaC_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaCA,
+            },
+        ],
+    ],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _ser,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var ListChangedBlocksRequest = [
+    3,
+    n0,
+    _LCBR,
+    0,
+    [_FSI, _SSI, _NT, _MR, _SBI],
+    [
+        [
+            0,
+            {
+                [_hQ]: _fSI,
+            },
+        ],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _pT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _sBI,
+            },
+        ],
+    ],
+];
+var ListChangedBlocksResponse = [
+    3,
+    n0,
+    _LCBRi,
+    0,
+    [_CBh, _ET, _VS, _BS, _NT],
+    [[() => ChangedBlocks, 0], 4, 1, 1, 0],
+];
+var ListSnapshotBlocksRequest = [
+    3,
+    n0,
+    _LSBR,
+    0,
+    [_SI, _NT, _MR, _SBI],
+    [
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _pT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _sBI,
+            },
+        ],
+    ],
+];
+var ListSnapshotBlocksResponse = [
+    3,
+    n0,
+    _LSBRi,
+    0,
+    [_Bl, _ET, _VS, _BS, _NT],
+    [[() => Blocks, 0], 4, 1, 1, 0],
+];
+var PutSnapshotBlockRequest = [
+    3,
+    n0,
+    _PSBR,
+    0,
+    [_SI, _BI, _BD, _DL, _P, _C, _CA],
+    [
+        [0, 1],
+        [1, 1],
+        [() => BlockData, 16],
+        [
+            1,
+            {
+                [_hH]: _xaDL,
+            },
+        ],
+        [
+            1,
+            {
+                [_hH]: _xaP,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaC_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaCA,
+            },
+        ],
+    ],
+];
+var PutSnapshotBlockResponse = [
+    3,
+    n0,
+    _PSBRu,
+    0,
+    [_C, _CA],
+    [
+        [
+            0,
+            {
+                [_hH]: _xaC_,
+            },
+        ],
+        [
+            0,
+            {
+                [_hH]: _xaCA,
+            },
+        ],
+    ],
+];
+var RequestThrottledException = [
+    -3,
+    n0,
+    _RTE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(RequestThrottledException, RequestThrottledException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var StartSnapshotRequest = [
+    3,
+    n0,
+    _SSR,
+    0,
+    [_VS, _PSI, _T, _D, _CT, _E, _KKA, _Ti],
+    [1, 0, () => Tags, 0, [0, 4], 2, [() => KmsKeyArn, 0], 1],
+];
+var StartSnapshotResponse = [
+    3,
+    n0,
+    _SSRt,
+    0,
+    [_D, _SI, _OI, _S, _ST, _VS, _BS, _T, _PSI, _KKA, _STs],
+    [0, 0, 0, 0, 4, 1, 1, () => Tags, 0, [() => KmsKeyArn, 0], 0],
+];
+var Tag = [3, n0, _Ta, 0, [_K, _V], [0, 0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M, _R],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var EBSServiceException = [-3, _sm, "EBSServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(EBSServiceException, EBSServiceException$1);
+var Blocks = [1, n0, _Bl, 8, () => Block];
+var ChangedBlocks = [1, n0, _CBh, 0, [() => ChangedBlock, 0]];
+var Tags = [1, n0, _T, 0, () => Tag];
+var CompleteSnapshot = [
+    9,
+    n0,
+    _CS,
+    {
+        [_h]: ["POST", "/snapshots/completion/{SnapshotId}", 202],
+    },
+    () => CompleteSnapshotRequest,
+    () => CompleteSnapshotResponse,
+];
+var GetSnapshotBlock = [
+    9,
+    n0,
+    _GSB,
+    {
+        [_h]: ["GET", "/snapshots/{SnapshotId}/blocks/{BlockIndex}", 200],
+    },
+    () => GetSnapshotBlockRequest,
+    () => GetSnapshotBlockResponse,
+];
+var ListChangedBlocks = [
+    9,
+    n0,
+    _LCB,
+    {
+        [_h]: ["GET", "/snapshots/{SecondSnapshotId}/changedblocks", 200],
+    },
+    () => ListChangedBlocksRequest,
+    () => ListChangedBlocksResponse,
+];
+var ListSnapshotBlocks = [
+    9,
+    n0,
+    _LSB,
+    {
+        [_h]: ["GET", "/snapshots/{SnapshotId}/blocks", 200],
+    },
+    () => ListSnapshotBlocksRequest,
+    () => ListSnapshotBlocksResponse,
+];
+var PutSnapshotBlock = [
+    9,
+    n0,
+    _PSB,
+    {
+        [_h]: ["PUT", "/snapshots/{SnapshotId}/blocks/{BlockIndex}", 201],
+    },
+    () => PutSnapshotBlockRequest,
+    () => PutSnapshotBlockResponse,
+];
+var StartSnapshot = [
+    9,
+    n0,
+    _SS,
+    {
+        [_h]: ["POST", "/snapshots", 201],
+    },
+    () => StartSnapshotRequest,
+    () => StartSnapshotResponse,
+];
 
 class CompleteSnapshotCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "CompleteSnapshot", {})
     .n("EBSClient", "CompleteSnapshotCommand")
-    .f(void 0, void 0)
-    .ser(se_CompleteSnapshotCommand)
-    .de(de_CompleteSnapshotCommand)
+    .sc(CompleteSnapshot)
     .build() {
 }
 
@@ -716,16 +802,11 @@ class GetSnapshotBlockCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "GetSnapshotBlock", {})
     .n("EBSClient", "GetSnapshotBlockCommand")
-    .f(void 0, GetSnapshotBlockResponseFilterSensitiveLog)
-    .ser(se_GetSnapshotBlockCommand)
-    .de(de_GetSnapshotBlockCommand)
+    .sc(GetSnapshotBlock)
     .build() {
 }
 
@@ -733,16 +814,11 @@ class ListChangedBlocksCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "ListChangedBlocks", {})
     .n("EBSClient", "ListChangedBlocksCommand")
-    .f(void 0, ListChangedBlocksResponseFilterSensitiveLog)
-    .ser(se_ListChangedBlocksCommand)
-    .de(de_ListChangedBlocksCommand)
+    .sc(ListChangedBlocks)
     .build() {
 }
 
@@ -750,16 +826,11 @@ class ListSnapshotBlocksCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "ListSnapshotBlocks", {})
     .n("EBSClient", "ListSnapshotBlocksCommand")
-    .f(void 0, ListSnapshotBlocksResponseFilterSensitiveLog)
-    .ser(se_ListSnapshotBlocksCommand)
-    .de(de_ListSnapshotBlocksCommand)
+    .sc(ListSnapshotBlocks)
     .build() {
 }
 
@@ -767,16 +838,11 @@ class PutSnapshotBlockCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "PutSnapshotBlock", {})
     .n("EBSClient", "PutSnapshotBlockCommand")
-    .f(PutSnapshotBlockRequestFilterSensitiveLog, void 0)
-    .ser(se_PutSnapshotBlockCommand)
-    .de(de_PutSnapshotBlockCommand)
+    .sc(PutSnapshotBlock)
     .build() {
 }
 
@@ -784,16 +850,11 @@ class StartSnapshotCommand extends smithyClient.Command
     .classBuilder()
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
-    return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
-        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
-    ];
+    return [middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
 })
     .s("Ebs", "StartSnapshot", {})
     .n("EBSClient", "StartSnapshotCommand")
-    .f(StartSnapshotRequestFilterSensitiveLog, StartSnapshotResponseFilterSensitiveLog)
-    .ser(se_StartSnapshotCommand)
-    .de(de_StartSnapshotCommand)
+    .sc(StartSnapshot)
     .build() {
 }
 
@@ -821,38 +882,31 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.AccessDeniedExceptionReason = AccessDeniedExceptionReason;
-exports.ChangedBlockFilterSensitiveLog = ChangedBlockFilterSensitiveLog;
 exports.ChecksumAggregationMethod = ChecksumAggregationMethod;
 exports.ChecksumAlgorithm = ChecksumAlgorithm;
 exports.CompleteSnapshotCommand = CompleteSnapshotCommand;
-exports.ConcurrentLimitExceededException = ConcurrentLimitExceededException;
-exports.ConflictException = ConflictException;
+exports.ConcurrentLimitExceededException = ConcurrentLimitExceededException$1;
+exports.ConflictException = ConflictException$1;
 exports.EBS = EBS;
 exports.EBSClient = EBSClient;
-exports.EBSServiceException = EBSServiceException;
+exports.EBSServiceException = EBSServiceException$1;
 exports.GetSnapshotBlockCommand = GetSnapshotBlockCommand;
-exports.GetSnapshotBlockResponseFilterSensitiveLog = GetSnapshotBlockResponseFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.ListChangedBlocksCommand = ListChangedBlocksCommand;
-exports.ListChangedBlocksResponseFilterSensitiveLog = ListChangedBlocksResponseFilterSensitiveLog;
 exports.ListSnapshotBlocksCommand = ListSnapshotBlocksCommand;
-exports.ListSnapshotBlocksResponseFilterSensitiveLog = ListSnapshotBlocksResponseFilterSensitiveLog;
 exports.PutSnapshotBlockCommand = PutSnapshotBlockCommand;
-exports.PutSnapshotBlockRequestFilterSensitiveLog = PutSnapshotBlockRequestFilterSensitiveLog;
-exports.RequestThrottledException = RequestThrottledException;
+exports.RequestThrottledException = RequestThrottledException$1;
 exports.RequestThrottledExceptionReason = RequestThrottledExceptionReason;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResourceNotFoundExceptionReason = ResourceNotFoundExceptionReason;
 exports.SSEType = SSEType;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.ServiceQuotaExceededExceptionReason = ServiceQuotaExceededExceptionReason;
 exports.StartSnapshotCommand = StartSnapshotCommand;
-exports.StartSnapshotRequestFilterSensitiveLog = StartSnapshotRequestFilterSensitiveLog;
-exports.StartSnapshotResponseFilterSensitiveLog = StartSnapshotResponseFilterSensitiveLog;
 exports.Status = Status;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionReason = ValidationExceptionReason;
 exports.paginateListChangedBlocks = paginateListChangedBlocks;
 exports.paginateListSnapshotBlocks = paginateListSnapshotBlocks;