@aws-sdk/client-keyspacesstreams 3.927.0 → 3.928.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,8 +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');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -89,6 +88,7 @@ class KeyspacesStreamsClient 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));
@@ -108,14 +108,14 @@ class KeyspacesStreamsClient extends smithyClient.Client {
     }
 }
 
-class KeyspacesStreamsServiceException extends smithyClient.ServiceException {
+let KeyspacesStreamsServiceException$1 = class KeyspacesStreamsServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, KeyspacesStreamsServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends KeyspacesStreamsServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends KeyspacesStreamsServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     constructor(opts) {
@@ -126,13 +126,13 @@ class AccessDeniedException extends KeyspacesStreamsServiceException {
         });
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
     }
-}
+};
 const OriginType = {
     REPLICATION: "REPLICATION",
     TTL: "TTL",
     USER: "USER",
 };
-class InternalServerException extends KeyspacesStreamsServiceException {
+let InternalServerException$1 = class InternalServerException extends KeyspacesStreamsServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     constructor(opts) {
@@ -143,8 +143,8 @@ class InternalServerException extends KeyspacesStreamsServiceException {
         });
         Object.setPrototypeOf(this, InternalServerException.prototype);
     }
-}
-class ResourceNotFoundException extends KeyspacesStreamsServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends KeyspacesStreamsServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -155,8 +155,8 @@ class ResourceNotFoundException extends KeyspacesStreamsServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ThrottlingException extends KeyspacesStreamsServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends KeyspacesStreamsServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     constructor(opts) {
@@ -167,14 +167,14 @@ class ThrottlingException extends KeyspacesStreamsServiceException {
         });
         Object.setPrototypeOf(this, ThrottlingException.prototype);
     }
-}
+};
 const ValidationExceptionType = {
     ExpiredIterator: "ExpiredIterator",
     ExpiredNextToken: "ExpiredNextToken",
     InvalidFormat: "InvalidFormat",
     TrimmedDataAccess: "TrimmedDataAccess",
 };
-class ValidationException extends KeyspacesStreamsServiceException {
+let ValidationException$1 = class ValidationException extends KeyspacesStreamsServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     errorCode;
@@ -187,7 +187,7 @@ class ValidationException extends KeyspacesStreamsServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.errorCode = opts.errorCode;
     }
-}
+};
 const ShardIteratorType = {
     AFTER_SEQUENCE_NUMBER: "AFTER_SEQUENCE_NUMBER",
     AT_SEQUENCE_NUMBER: "AT_SEQUENCE_NUMBER",
@@ -266,393 +266,328 @@ exports.KeyspacesCellValue = void 0;
     };
 })(exports.KeyspacesCellValue || (exports.KeyspacesCellValue = {}));
 
-const se_GetRecordsCommand = async (input, context) => {
-    const headers = sharedHeaders("GetRecords");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetShardIteratorCommand = async (input, context) => {
-    const headers = sharedHeaders("GetShardIterator");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_GetStreamCommand = async (input, context) => {
-    const headers = sharedHeaders("GetStream");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListStreamsCommand = async (input, context) => {
-    const headers = sharedHeaders("ListStreams");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_GetRecordsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetRecordsOutput(data, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetShardIteratorCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_GetStreamCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_GetStreamOutput(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListStreamsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core$1.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-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.keyspacesstreams#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.keyspacesstreams#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.keyspacesstreams#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.keyspacesstreams#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.keyspacesstreams#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new AccessDeniedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_InternalServerExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InternalServerException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ThrottlingException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_ValidationExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ValidationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_GetRecordsOutput = (output, context) => {
-    return smithyClient.take(output, {
-        changeRecords: (_) => de_RecordList(_, context),
-        nextShardIterator: smithyClient.expectString,
-    });
-};
-const de_GetStreamOutput = (output, context) => {
-    return smithyClient.take(output, {
-        creationRequestDateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        keyspaceName: smithyClient.expectString,
-        nextToken: smithyClient.expectString,
-        shards: smithyClient._json,
-        streamArn: smithyClient.expectString,
-        streamLabel: smithyClient.expectString,
-        streamStatus: smithyClient.expectString,
-        streamViewType: smithyClient.expectString,
-        tableName: smithyClient.expectString,
-    });
-};
-const de_KeyspacesCell = (output, context) => {
-    return smithyClient.take(output, {
-        metadata: smithyClient._json,
-        value: (_) => de_KeyspacesCellValue(core$1.awsExpectUnion(_), context),
-    });
-};
-const de_KeyspacesCellList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_KeyspacesCell(entry, context);
-    });
-    return retVal;
-};
-const de_KeyspacesCellMap = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_KeyspacesCellMapDefinition(entry, context);
-    });
-    return retVal;
-};
-const de_KeyspacesCellMapDefinition = (output, context) => {
-    return smithyClient.take(output, {
-        key: (_) => de_KeyspacesCellValue(core$1.awsExpectUnion(_), context),
-        metadata: smithyClient._json,
-        value: (_) => de_KeyspacesCellValue(core$1.awsExpectUnion(_), context),
-    });
-};
-const de_KeyspacesCells = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_KeyspacesCell(value, context);
-        return acc;
-    }, {});
-};
-const de_KeyspacesCellValue = (output, context) => {
-    if (smithyClient.expectString(output.asciiT) !== undefined) {
-        return { asciiT: smithyClient.expectString(output.asciiT) };
-    }
-    if (smithyClient.expectString(output.bigintT) !== undefined) {
-        return { bigintT: smithyClient.expectString(output.bigintT) };
-    }
-    if (output.blobT != null) {
-        return {
-            blobT: context.base64Decoder(output.blobT),
-        };
-    }
-    if (smithyClient.expectBoolean(output.boolT) !== undefined) {
-        return { boolT: smithyClient.expectBoolean(output.boolT) };
-    }
-    if (smithyClient.expectString(output.counterT) !== undefined) {
-        return { counterT: smithyClient.expectString(output.counterT) };
-    }
-    if (smithyClient.expectString(output.dateT) !== undefined) {
-        return { dateT: smithyClient.expectString(output.dateT) };
-    }
-    if (smithyClient.expectString(output.decimalT) !== undefined) {
-        return { decimalT: smithyClient.expectString(output.decimalT) };
-    }
-    if (smithyClient.expectString(output.doubleT) !== undefined) {
-        return { doubleT: smithyClient.expectString(output.doubleT) };
-    }
-    if (smithyClient.expectString(output.floatT) !== undefined) {
-        return { floatT: smithyClient.expectString(output.floatT) };
-    }
-    if (smithyClient.expectString(output.inetT) !== undefined) {
-        return { inetT: smithyClient.expectString(output.inetT) };
-    }
-    if (smithyClient.expectString(output.intT) !== undefined) {
-        return { intT: smithyClient.expectString(output.intT) };
-    }
-    if (output.listT != null) {
-        return {
-            listT: de_KeyspacesCellList(output.listT, context),
-        };
-    }
-    if (output.mapT != null) {
-        return {
-            mapT: de_KeyspacesCellMap(output.mapT, context),
-        };
-    }
-    if (output.setT != null) {
-        return {
-            setT: de_KeyspacesCellList(output.setT, context),
-        };
-    }
-    if (smithyClient.expectString(output.smallintT) !== undefined) {
-        return { smallintT: smithyClient.expectString(output.smallintT) };
-    }
-    if (smithyClient.expectString(output.textT) !== undefined) {
-        return { textT: smithyClient.expectString(output.textT) };
-    }
-    if (smithyClient.expectString(output.timeT) !== undefined) {
-        return { timeT: smithyClient.expectString(output.timeT) };
-    }
-    if (smithyClient.expectString(output.timestampT) !== undefined) {
-        return { timestampT: smithyClient.expectString(output.timestampT) };
-    }
-    if (smithyClient.expectString(output.timeuuidT) !== undefined) {
-        return { timeuuidT: smithyClient.expectString(output.timeuuidT) };
-    }
-    if (smithyClient.expectString(output.tinyintT) !== undefined) {
-        return { tinyintT: smithyClient.expectString(output.tinyintT) };
-    }
-    if (output.tupleT != null) {
-        return {
-            tupleT: de_KeyspacesCellList(output.tupleT, context),
-        };
-    }
-    if (output.udtT != null) {
-        return {
-            udtT: de_KeyspacesUdtMap(output.udtT, context),
-        };
-    }
-    if (smithyClient.expectString(output.uuidT) !== undefined) {
-        return { uuidT: smithyClient.expectString(output.uuidT) };
-    }
-    if (smithyClient.expectString(output.varcharT) !== undefined) {
-        return { varcharT: smithyClient.expectString(output.varcharT) };
-    }
-    if (smithyClient.expectString(output.varintT) !== undefined) {
-        return { varintT: smithyClient.expectString(output.varintT) };
-    }
-    return { $unknown: Object.entries(output)[0] };
-};
-const de_KeyspacesKeysMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_KeyspacesCellValue(core$1.awsExpectUnion(value), context);
-        return acc;
-    }, {});
-};
-const de_KeyspacesRow = (output, context) => {
-    return smithyClient.take(output, {
-        rowMetadata: smithyClient._json,
-        staticCells: (_) => de_KeyspacesCells(_, context),
-        valueCells: (_) => de_KeyspacesCells(_, context),
-    });
-};
-const de_KeyspacesUdtMap = (output, context) => {
-    return Object.entries(output).reduce((acc, [key, value]) => {
-        if (value === null) {
-            return acc;
-        }
-        acc[key] = de_KeyspacesCell(value, context);
-        return acc;
-    }, {});
-};
-const de__Record = (output, context) => {
-    return smithyClient.take(output, {
-        clusteringKeys: (_) => de_KeyspacesKeysMap(_, context),
-        createdAt: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        eventVersion: smithyClient.expectString,
-        newImage: (_) => de_KeyspacesRow(_, context),
-        oldImage: (_) => de_KeyspacesRow(_, context),
-        origin: smithyClient.expectString,
-        partitionKeys: (_) => de_KeyspacesKeysMap(_, context),
-        sequenceNumber: smithyClient.expectString,
-    });
-};
-const de_RecordList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de__Record(entry, context);
-    });
-    return retVal;
-};
-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 throwDefaultError = smithyClient.withBaseException(KeyspacesStreamsServiceException);
-const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
-    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-    const contents = {
-        protocol,
-        hostname,
-        port,
-        method: "POST",
-        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-        headers,
-    };
-    if (body !== undefined) {
-        contents.body = body;
-    }
-    return new protocolHttp.HttpRequest(contents);
-};
-function sharedHeaders(operation) {
-    return {
-        "content-type": "application/x-amz-json-1.0",
-        "x-amz-target": `KeyspacesStreams.${operation}`,
-    };
-}
+const _ADE = "AccessDeniedException";
+const _GR = "GetRecords";
+const _GRI = "GetRecordsInput";
+const _GRO = "GetRecordsOutput";
+const _GS = "GetStream";
+const _GSI = "GetStreamInput";
+const _GSII = "GetShardIteratorInput";
+const _GSIO = "GetShardIteratorOutput";
+const _GSIe = "GetShardIterator";
+const _GSO = "GetStreamOutput";
+const _ISE = "InternalServerException";
+const _KC = "KeyspacesCell";
+const _KCL = "KeyspacesCellList";
+const _KCM = "KeyspacesCellMap";
+const _KCMD = "KeyspacesCellMapDefinition";
+const _KCV = "KeyspacesCellValue";
+const _KCe = "KeyspacesCells";
+const _KKM = "KeyspacesKeysMap";
+const _KM = "KeyspacesMetadata";
+const _KR = "KeyspacesRow";
+const _KUM = "KeyspacesUdtMap";
+const _LS = "ListStreams";
+const _LSI = "ListStreamsInput";
+const _LSO = "ListStreamsOutput";
+const _R = "Record";
+const _RL = "RecordList";
+const _RNFE = "ResourceNotFoundException";
+const _S = "Shard";
+const _SDL = "ShardDescriptionList";
+const _SF = "ShardFilter";
+const _SL = "StreamList";
+const _SNR = "SequenceNumberRange";
+const _St = "Stream";
+const _TE = "ThrottlingException";
+const _VE = "ValidationException";
+const _aQE = "awsQueryError";
+const _aT = "asciiT";
+const _bT = "bigintT";
+const _bTl = "blobT";
+const _bTo = "boolT";
+const _c = "client";
+const _cA = "createdAt";
+const _cK = "clusteringKeys";
+const _cR = "changeRecords";
+const _cRDT = "creationRequestDateTime";
+const _cT = "counterT";
+const _dT = "dateT";
+const _dTe = "decimalT";
+const _dTo = "doubleT";
+const _e = "error";
+const _eC = "errorCode";
+const _eSN = "endingSequenceNumber";
+const _eT = "expirationTime";
+const _eV = "eventVersion";
+const _fT = "floatT";
+const _hE = "httpError";
+const _iT = "inetT";
+const _iTn = "intT";
+const _k = "key";
+const _kN = "keyspaceName";
+const _lT = "listT";
+const _m = "message";
+const _mR = "maxResults";
+const _mT = "mapT";
+const _me = "metadata";
+const _nI = "newImage";
+const _nSI = "nextShardIterator";
+const _nT = "nextToken";
+const _o = "origin";
+const _oI = "oldImage";
+const _pK = "partitionKeys";
+const _pSI = "parentShardIds";
+const _rM = "rowMetadata";
+const _s = "shards";
+const _sA = "streamArn";
+const _sC = "staticCells";
+const _sF = "shardFilter";
+const _sI = "shardIterator";
+const _sIT = "shardIteratorType";
+const _sIh = "shardId";
+const _sL = "streamLabel";
+const _sN = "sequenceNumber";
+const _sNR = "sequenceNumberRange";
+const _sS = "streamStatus";
+const _sSN = "startingSequenceNumber";
+const _sT = "setT";
+const _sTm = "smallintT";
+const _sVT = "streamViewType";
+const _se = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.keyspacesstreams";
+const _st = "streams";
+const _t = "type";
+const _tN = "tableName";
+const _tT = "textT";
+const _tTi = "timeT";
+const _tTim = "timestampT";
+const _tTime = "timeuuidT";
+const _tTin = "tinyintT";
+const _tTu = "tupleT";
+const _uT = "uuidT";
+const _uTd = "udtT";
+const _v = "value";
+const _vC = "valueCells";
+const _vT = "varcharT";
+const _vTa = "varintT";
+const _wT = "writeTime";
+const n0 = "com.amazonaws.keyspacesstreams";
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`AccessDeniedException`, 403],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var GetRecordsInput = [3, n0, _GRI, 0, [_sI, _mR], [0, 1]];
+var GetRecordsOutput = [3, n0, _GRO, 0, [_cR, _nSI], [() => RecordList, 0]];
+var GetShardIteratorInput = [3, n0, _GSII, 0, [_sA, _sIh, _sIT, _sN], [0, 0, 0, 0]];
+var GetShardIteratorOutput = [3, n0, _GSIO, 0, [_sI], [0]];
+var GetStreamInput = [3, n0, _GSI, 0, [_sA, _mR, _sF, _nT], [0, 1, () => ShardFilter, 0]];
+var GetStreamOutput = [
+    3,
+    n0,
+    _GSO,
+    0,
+    [_sA, _sL, _sS, _sVT, _cRDT, _kN, _tN, _s, _nT],
+    [0, 0, 0, 0, 4, 0, 0, () => ShardDescriptionList, 0],
+];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _se,
+        [_hE]: 500,
+        [_aQE]: [`InternalServerException`, 500],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var KeyspacesCell = [
+    3,
+    n0,
+    _KC,
+    0,
+    [_v, _me],
+    [() => KeyspacesCellValue, () => KeyspacesMetadata],
+];
+var KeyspacesCellMapDefinition = [
+    3,
+    n0,
+    _KCMD,
+    0,
+    [_k, _v, _me],
+    [() => KeyspacesCellValue, () => KeyspacesCellValue, () => KeyspacesMetadata],
+];
+var KeyspacesMetadata = [3, n0, _KM, 0, [_eT, _wT], [0, 0]];
+var KeyspacesRow = [
+    3,
+    n0,
+    _KR,
+    0,
+    [_vC, _sC, _rM],
+    [() => KeyspacesCells, () => KeyspacesCells, () => KeyspacesMetadata],
+];
+var ListStreamsInput = [3, n0, _LSI, 0, [_kN, _tN, _mR, _nT], [0, 0, 1, 0]];
+var ListStreamsOutput = [3, n0, _LSO, 0, [_st, _nT], [() => StreamList, 0]];
+var _Record = [
+    3,
+    n0,
+    _R,
+    0,
+    [_eV, _cA, _o, _pK, _cK, _nI, _oI, _sN],
+    [0, 4, 0, () => KeyspacesKeysMap, () => KeyspacesKeysMap, () => KeyspacesRow, () => KeyspacesRow, 0],
+];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+        [_aQE]: [`ResourceNotFoundException`, 404],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SequenceNumberRange = [3, n0, _SNR, 0, [_sSN, _eSN], [0, 0]];
+var Shard = [3, n0, _S, 0, [_sIh, _sNR, _pSI], [0, () => SequenceNumberRange, 64 | 0]];
+var ShardFilter = [3, n0, _SF, 0, [_t, _sIh], [0, 0]];
+var _Stream = [3, n0, _St, 0, [_sA, _kN, _tN, _sL], [0, 0, 0, 0]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+        [_aQE]: [`ThrottlingException`, 429],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ValidationException`, 400],
+    },
+    [_m, _eC],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var KeyspacesStreamsServiceException = [
+    -3,
+    _sm,
+    "KeyspacesStreamsServiceException",
+    0,
+    [],
+    [],
+];
+schema.TypeRegistry.for(_sm).registerError(KeyspacesStreamsServiceException, KeyspacesStreamsServiceException$1);
+var KeyspacesCellList = [1, n0, _KCL, 0, () => KeyspacesCell];
+var KeyspacesCellMap = [1, n0, _KCM, 0, () => KeyspacesCellMapDefinition];
+var RecordList = [1, n0, _RL, 0, () => _Record];
+var ShardDescriptionList = [1, n0, _SDL, 0, () => Shard];
+var StreamList = [1, n0, _SL, 0, () => _Stream];
+var KeyspacesCells = [2, n0, _KCe, 0, 0, () => KeyspacesCell];
+var KeyspacesKeysMap = [2, n0, _KKM, 0, 0, () => KeyspacesCellValue];
+var KeyspacesUdtMap = [2, n0, _KUM, 0, 0, () => KeyspacesCell];
+var KeyspacesCellValue = [
+    3,
+    n0,
+    _KCV,
+    0,
+    [
+        _aT,
+        _bT,
+        _bTl,
+        _bTo,
+        _cT,
+        _dT,
+        _dTe,
+        _dTo,
+        _fT,
+        _iT,
+        _iTn,
+        _lT,
+        _mT,
+        _sT,
+        _sTm,
+        _tT,
+        _tTi,
+        _tTim,
+        _tTime,
+        _tTin,
+        _tTu,
+        _uT,
+        _vT,
+        _vTa,
+        _uTd,
+    ],
+    [
+        0,
+        0,
+        21,
+        2,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => KeyspacesCellList,
+        () => KeyspacesCellMap,
+        () => KeyspacesCellList,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        () => KeyspacesCellList,
+        0,
+        0,
+        0,
+        () => KeyspacesUdtMap,
+    ],
+];
+var GetRecords = [9, n0, _GR, 0, () => GetRecordsInput, () => GetRecordsOutput];
+var GetShardIterator = [
+    9,
+    n0,
+    _GSIe,
+    0,
+    () => GetShardIteratorInput,
+    () => GetShardIteratorOutput,
+];
+var GetStream = [9, n0, _GS, 0, () => GetStreamInput, () => GetStreamOutput];
+var ListStreams = [9, n0, _LS, 0, () => ListStreamsInput, () => ListStreamsOutput];
 
 class GetRecordsCommand 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("KeyspacesStreams", "GetRecords", {})
     .n("KeyspacesStreamsClient", "GetRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetRecordsCommand)
-    .de(de_GetRecordsCommand)
+    .sc(GetRecords)
     .build() {
 }
 
@@ -660,16 +595,11 @@ class GetShardIteratorCommand 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("KeyspacesStreams", "GetShardIterator", {})
     .n("KeyspacesStreamsClient", "GetShardIteratorCommand")
-    .f(void 0, void 0)
-    .ser(se_GetShardIteratorCommand)
-    .de(de_GetShardIteratorCommand)
+    .sc(GetShardIterator)
     .build() {
 }
 
@@ -677,16 +607,11 @@ class GetStreamCommand 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("KeyspacesStreams", "GetStream", {})
     .n("KeyspacesStreamsClient", "GetStreamCommand")
-    .f(void 0, void 0)
-    .ser(se_GetStreamCommand)
-    .de(de_GetStreamCommand)
+    .sc(GetStream)
     .build() {
 }
 
@@ -694,16 +619,11 @@ class ListStreamsCommand 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("KeyspacesStreams", "ListStreams", {})
     .n("KeyspacesStreamsClient", "ListStreamsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListStreamsCommand)
-    .de(de_ListStreamsCommand)
+    .sc(ListStreams)
     .build() {
 }
 
@@ -729,23 +649,23 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.GetRecordsCommand = GetRecordsCommand;
 exports.GetShardIteratorCommand = GetShardIteratorCommand;
 exports.GetStreamCommand = GetStreamCommand;
-exports.InternalServerException = InternalServerException;
+exports.InternalServerException = InternalServerException$1;
 exports.KeyspacesStreams = KeyspacesStreams;
 exports.KeyspacesStreamsClient = KeyspacesStreamsClient;
-exports.KeyspacesStreamsServiceException = KeyspacesStreamsServiceException;
+exports.KeyspacesStreamsServiceException = KeyspacesStreamsServiceException$1;
 exports.ListStreamsCommand = ListStreamsCommand;
 exports.OriginType = OriginType;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ShardFilterType = ShardFilterType;
 exports.ShardIteratorType = ShardIteratorType;
 exports.StreamStatus = StreamStatus;
 exports.StreamViewType = StreamViewType;
-exports.ThrottlingException = ThrottlingException;
-exports.ValidationException = ValidationException;
+exports.ThrottlingException = ThrottlingException$1;
+exports.ValidationException = ValidationException$1;
 exports.ValidationExceptionType = ValidationExceptionType;
 exports.paginateGetStream = paginateGetStream;
 exports.paginateListStreams = paginateListStreams;