@aws-sdk/client-cognito-sync 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,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, {
@@ -91,6 +90,7 @@ class CognitoSyncClient 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));
@@ -110,14 +110,14 @@ class CognitoSyncClient extends smithyClient.Client {
     }
 }
 
-class CognitoSyncServiceException extends smithyClient.ServiceException {
+let CognitoSyncServiceException$1 = class CognitoSyncServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, CognitoSyncServiceException.prototype);
     }
-}
+};
 
-class AlreadyStreamedException extends CognitoSyncServiceException {
+let AlreadyStreamedException$1 = class AlreadyStreamedException extends CognitoSyncServiceException$1 {
     name = "AlreadyStreamedException";
     $fault = "client";
     constructor(opts) {
@@ -128,8 +128,8 @@ class AlreadyStreamedException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, AlreadyStreamedException.prototype);
     }
-}
-class DuplicateRequestException extends CognitoSyncServiceException {
+};
+let DuplicateRequestException$1 = class DuplicateRequestException extends CognitoSyncServiceException$1 {
     name = "DuplicateRequestException";
     $fault = "client";
     constructor(opts) {
@@ -140,8 +140,8 @@ class DuplicateRequestException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, DuplicateRequestException.prototype);
     }
-}
-class InternalErrorException extends CognitoSyncServiceException {
+};
+let InternalErrorException$1 = class InternalErrorException extends CognitoSyncServiceException$1 {
     name = "InternalErrorException";
     $fault = "server";
     constructor(opts) {
@@ -152,8 +152,8 @@ class InternalErrorException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, InternalErrorException.prototype);
     }
-}
-class InvalidParameterException extends CognitoSyncServiceException {
+};
+let InvalidParameterException$1 = class InvalidParameterException extends CognitoSyncServiceException$1 {
     name = "InvalidParameterException";
     $fault = "client";
     constructor(opts) {
@@ -164,8 +164,8 @@ class InvalidParameterException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, InvalidParameterException.prototype);
     }
-}
-class NotAuthorizedException extends CognitoSyncServiceException {
+};
+let NotAuthorizedException$1 = class NotAuthorizedException extends CognitoSyncServiceException$1 {
     name = "NotAuthorizedException";
     $fault = "client";
     constructor(opts) {
@@ -176,8 +176,8 @@ class NotAuthorizedException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, NotAuthorizedException.prototype);
     }
-}
-class ResourceNotFoundException extends CognitoSyncServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends CognitoSyncServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     constructor(opts) {
@@ -188,8 +188,8 @@ class ResourceNotFoundException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
     }
-}
-class ResourceConflictException extends CognitoSyncServiceException {
+};
+let ResourceConflictException$1 = class ResourceConflictException extends CognitoSyncServiceException$1 {
     name = "ResourceConflictException";
     $fault = "client";
     constructor(opts) {
@@ -200,8 +200,8 @@ class ResourceConflictException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, ResourceConflictException.prototype);
     }
-}
-class TooManyRequestsException extends CognitoSyncServiceException {
+};
+let TooManyRequestsException$1 = class TooManyRequestsException extends CognitoSyncServiceException$1 {
     name = "TooManyRequestsException";
     $fault = "client";
     constructor(opts) {
@@ -212,7 +212,7 @@ class TooManyRequestsException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, TooManyRequestsException.prototype);
     }
-}
+};
 const BulkPublishStatus = {
     FAILED: "FAILED",
     IN_PROGRESS: "IN_PROGRESS",
@@ -223,7 +223,7 @@ const StreamingStatus = {
     DISABLED: "DISABLED",
     ENABLED: "ENABLED",
 };
-class InvalidConfigurationException extends CognitoSyncServiceException {
+let InvalidConfigurationException$1 = class InvalidConfigurationException extends CognitoSyncServiceException$1 {
     name = "InvalidConfigurationException";
     $fault = "client";
     constructor(opts) {
@@ -234,14 +234,14 @@ class InvalidConfigurationException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, InvalidConfigurationException.prototype);
     }
-}
+};
 const Platform = {
     ADM: "ADM",
     APNS: "APNS",
     APNS_SANDBOX: "APNS_SANDBOX",
     GCM: "GCM",
 };
-class ConcurrentModificationException extends CognitoSyncServiceException {
+let ConcurrentModificationException$1 = class ConcurrentModificationException extends CognitoSyncServiceException$1 {
     name = "ConcurrentModificationException";
     $fault = "client";
     constructor(opts) {
@@ -252,8 +252,8 @@ class ConcurrentModificationException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
     }
-}
-class InvalidLambdaFunctionOutputException extends CognitoSyncServiceException {
+};
+let InvalidLambdaFunctionOutputException$1 = class InvalidLambdaFunctionOutputException extends CognitoSyncServiceException$1 {
     name = "InvalidLambdaFunctionOutputException";
     $fault = "client";
     constructor(opts) {
@@ -264,8 +264,8 @@ class InvalidLambdaFunctionOutputException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, InvalidLambdaFunctionOutputException.prototype);
     }
-}
-class LambdaThrottledException extends CognitoSyncServiceException {
+};
+let LambdaThrottledException$1 = class LambdaThrottledException extends CognitoSyncServiceException$1 {
     name = "LambdaThrottledException";
     $fault = "client";
     constructor(opts) {
@@ -276,8 +276,8 @@ class LambdaThrottledException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, LambdaThrottledException.prototype);
     }
-}
-class LimitExceededException extends CognitoSyncServiceException {
+};
+let LimitExceededException$1 = class LimitExceededException extends CognitoSyncServiceException$1 {
     name = "LimitExceededException";
     $fault = "client";
     constructor(opts) {
@@ -288,801 +288,756 @@ class LimitExceededException extends CognitoSyncServiceException {
         });
         Object.setPrototypeOf(this, LimitExceededException.prototype);
     }
-}
+};
 const Operation = {
     remove: "remove",
     replace: "replace",
 };
 
-const se_BulkPublishCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/bulkpublish");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_DeleteDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeIdentityPoolUsageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_DescribeIdentityUsageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetBulkPublishDetailsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/getBulkPublishDetails");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_GetCognitoEventsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/events");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_GetIdentityPoolConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/configuration");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    b.m("GET").h(headers).b(body);
-    return b.build();
-};
-const se_ListDatasetsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    const query = smithyClient.map({
-        [_nT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListIdentityPoolUsageCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools");
-    const query = smithyClient.map({
-        [_nT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_ListRecordsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/records");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    const query = smithyClient.map({
-        [_lSC]: [() => input.LastSyncCount !== void 0, () => input[_LSC].toString()],
-        [_nT]: [, input[_NT]],
-        [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
-        [_sST]: [, input[_SST]],
-    });
-    let body;
-    b.m("GET").h(headers).q(query).b(body);
-    return b.build();
-};
-const se_RegisterDeviceCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/identitypools/{IdentityPoolId}/identity/{IdentityId}/device");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Platform: [],
-        Token: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SetCognitoEventsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/identitypools/{IdentityPoolId}/events");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        Events: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SetIdentityPoolConfigurationCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {
-        "content-type": "application/json",
-    };
-    b.bp("/identitypools/{IdentityPoolId}/configuration");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        CognitoStreams: (_) => smithyClient._json(_),
-        PushSync: (_) => smithyClient._json(_),
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_SubscribeToDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/subscriptions/{DeviceId}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
-    let body;
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const se_UnsubscribeFromDatasetCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = {};
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/subscriptions/{DeviceId}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    b.p("DeviceId", () => input.DeviceId, "{DeviceId}", false);
-    let body;
-    b.m("DELETE").h(headers).b(body);
-    return b.build();
-};
-const se_UpdateRecordsCommand = async (input, context) => {
-    const b = core.requestBuilder(input, context);
-    const headers = smithyClient.map({}, smithyClient.isSerializableHeaderValue, {
-        "content-type": "application/json",
-        [_xacc]: input[_CC],
-    });
-    b.bp("/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}");
-    b.p("IdentityPoolId", () => input.IdentityPoolId, "{IdentityPoolId}", false);
-    b.p("IdentityId", () => input.IdentityId, "{IdentityId}", false);
-    b.p("DatasetName", () => input.DatasetName, "{DatasetName}", false);
-    let body;
-    body = JSON.stringify(smithyClient.take(input, {
-        DeviceId: [],
-        RecordPatches: (_) => se_RecordPatchList(_),
-        SyncSessionToken: [],
-    }));
-    b.m("POST").h(headers).b(body);
-    return b.build();
-};
-const de_BulkPublishCommand = 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, {
-        IdentityPoolId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DeleteDatasetCommand = 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, {
-        Dataset: (_) => de_Dataset(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeDatasetCommand = 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, {
-        Dataset: (_) => de_Dataset(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeIdentityPoolUsageCommand = 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, {
-        IdentityPoolUsage: (_) => de_IdentityPoolUsage(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_DescribeIdentityUsageCommand = 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, {
-        IdentityUsage: (_) => de_IdentityUsage(_),
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetBulkPublishDetailsCommand = 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, {
-        BulkPublishCompleteTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        BulkPublishStartTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        BulkPublishStatus: smithyClient.expectString,
-        FailureMessage: smithyClient.expectString,
-        IdentityPoolId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetCognitoEventsCommand = 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, {
-        Events: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_GetIdentityPoolConfigurationCommand = 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, {
-        CognitoStreams: smithyClient._json,
-        IdentityPoolId: smithyClient.expectString,
-        PushSync: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListDatasetsCommand = 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, {
-        Count: smithyClient.expectInt32,
-        Datasets: (_) => de_DatasetList(_),
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListIdentityPoolUsageCommand = 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, {
-        Count: smithyClient.expectInt32,
-        IdentityPoolUsages: (_) => de_IdentityPoolUsageList(_),
-        MaxResults: smithyClient.expectInt32,
-        NextToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_ListRecordsCommand = 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, {
-        Count: smithyClient.expectInt32,
-        DatasetDeletedAfterRequestedSyncCount: smithyClient.expectBoolean,
-        DatasetExists: smithyClient.expectBoolean,
-        DatasetSyncCount: smithyClient.expectLong,
-        LastModifiedBy: smithyClient.expectString,
-        MergedDatasetNames: smithyClient._json,
-        NextToken: smithyClient.expectString,
-        Records: (_) => de_RecordList(_),
-        SyncSessionToken: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_RegisterDeviceCommand = 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, {
-        DeviceId: smithyClient.expectString,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SetCognitoEventsCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_SetIdentityPoolConfigurationCommand = 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, {
-        CognitoStreams: smithyClient._json,
-        IdentityPoolId: smithyClient.expectString,
-        PushSync: smithyClient._json,
-    });
-    Object.assign(contents, doc);
-    return contents;
-};
-const de_SubscribeToDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UnsubscribeFromDatasetCommand = async (output, context) => {
-    if (output.statusCode !== 200 && output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const contents = smithyClient.map({
-        $metadata: deserializeMetadata(output),
-    });
-    await smithyClient.collectBody(output.body, context);
-    return contents;
-};
-const de_UpdateRecordsCommand = 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, {
-        Records: (_) => de_RecordList(_),
-    });
-    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 "AlreadyStreamedException":
-        case "com.amazonaws.cognitosync#AlreadyStreamedException":
-            throw await de_AlreadyStreamedExceptionRes(parsedOutput);
-        case "DuplicateRequestException":
-        case "com.amazonaws.cognitosync#DuplicateRequestException":
-            throw await de_DuplicateRequestExceptionRes(parsedOutput);
-        case "InternalErrorException":
-        case "com.amazonaws.cognitosync#InternalErrorException":
-            throw await de_InternalErrorExceptionRes(parsedOutput);
-        case "InvalidParameterException":
-        case "com.amazonaws.cognitosync#InvalidParameterException":
-            throw await de_InvalidParameterExceptionRes(parsedOutput);
-        case "NotAuthorizedException":
-        case "com.amazonaws.cognitosync#NotAuthorizedException":
-            throw await de_NotAuthorizedExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.cognitosync#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ResourceConflictException":
-        case "com.amazonaws.cognitosync#ResourceConflictException":
-            throw await de_ResourceConflictExceptionRes(parsedOutput);
-        case "TooManyRequestsException":
-        case "com.amazonaws.cognitosync#TooManyRequestsException":
-            throw await de_TooManyRequestsExceptionRes(parsedOutput);
-        case "InvalidConfigurationException":
-        case "com.amazonaws.cognitosync#InvalidConfigurationException":
-            throw await de_InvalidConfigurationExceptionRes(parsedOutput);
-        case "ConcurrentModificationException":
-        case "com.amazonaws.cognitosync#ConcurrentModificationException":
-            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
-        case "InvalidLambdaFunctionOutputException":
-        case "com.amazonaws.cognitosync#InvalidLambdaFunctionOutputException":
-            throw await de_InvalidLambdaFunctionOutputExceptionRes(parsedOutput);
-        case "LambdaThrottledException":
-        case "com.amazonaws.cognitosync#LambdaThrottledException":
-            throw await de_LambdaThrottledExceptionRes(parsedOutput);
-        case "LimitExceededException":
-        case "com.amazonaws.cognitosync#LimitExceededException":
-            throw await de_LimitExceededExceptionRes(parsedOutput);
-        default:
-            const parsedBody = parsedOutput.body;
-            return throwDefaultError({
-                output,
-                parsedBody,
-                errorCode,
-            });
-    }
-};
-const throwDefaultError = smithyClient.withBaseException(CognitoSyncServiceException);
-const de_AlreadyStreamedExceptionRes = 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 AlreadyStreamedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ConcurrentModificationExceptionRes = 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 ConcurrentModificationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_DuplicateRequestExceptionRes = 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 DuplicateRequestException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InternalErrorExceptionRes = 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 InternalErrorException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidConfigurationExceptionRes = 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 InvalidConfigurationException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidLambdaFunctionOutputExceptionRes = 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 InvalidLambdaFunctionOutputException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_InvalidParameterExceptionRes = 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 InvalidParameterException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_LambdaThrottledExceptionRes = 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 LambdaThrottledException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_LimitExceededExceptionRes = 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 LimitExceededException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_NotAuthorizedExceptionRes = 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 NotAuthorizedException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_ResourceConflictExceptionRes = 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 ResourceConflictException({
-        $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,
-    });
-    Object.assign(contents, doc);
-    const exception = new ResourceNotFoundException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const de_TooManyRequestsExceptionRes = 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 TooManyRequestsException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...contents,
-    });
-    return smithyClient.decorateServiceException(exception, parsedOutput.body);
-};
-const se_RecordPatch = (input, context) => {
-    return smithyClient.take(input, {
-        DeviceLastModifiedDate: (_) => _.getTime() / 1_000,
-        Key: [],
-        Op: [],
-        SyncCount: [],
-        Value: [],
-    });
-};
-const se_RecordPatchList = (input, context) => {
-    return input
-        .filter((e) => e != null)
-        .map((entry) => {
-        return se_RecordPatch(entry);
-    });
-};
-const de_Dataset = (output, context) => {
-    return smithyClient.take(output, {
-        CreationDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DataStorage: smithyClient.expectLong,
-        DatasetName: smithyClient.expectString,
-        IdentityId: smithyClient.expectString,
-        LastModifiedBy: smithyClient.expectString,
-        LastModifiedDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NumRecords: smithyClient.expectLong,
-    });
-};
-const de_DatasetList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Dataset(entry);
-    });
-    return retVal;
-};
-const de_IdentityPoolUsage = (output, context) => {
-    return smithyClient.take(output, {
-        DataStorage: smithyClient.expectLong,
-        IdentityPoolId: smithyClient.expectString,
-        LastModifiedDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SyncSessionsCount: smithyClient.expectLong,
-    });
-};
-const de_IdentityPoolUsageList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_IdentityPoolUsage(entry);
-    });
-    return retVal;
-};
-const de_IdentityUsage = (output, context) => {
-    return smithyClient.take(output, {
-        DataStorage: smithyClient.expectLong,
-        DatasetCount: smithyClient.expectInt32,
-        IdentityId: smithyClient.expectString,
-        IdentityPoolId: smithyClient.expectString,
-        LastModifiedDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de__Record = (output, context) => {
-    return smithyClient.take(output, {
-        DeviceLastModifiedDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        Key: smithyClient.expectString,
-        LastModifiedBy: smithyClient.expectString,
-        LastModifiedDate: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        SyncCount: smithyClient.expectLong,
-        Value: smithyClient.expectString,
-    });
-};
-const de_RecordList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de__Record(entry);
-    });
-    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 _AA = "ApplicationArns";
+const _ASE = "AlreadyStreamedException";
+const _BP = "BulkPublish";
+const _BPCT = "BulkPublishCompleteTime";
+const _BPR = "BulkPublishRequest";
+const _BPRu = "BulkPublishResponse";
+const _BPS = "BulkPublishStatus";
+const _BPST = "BulkPublishStartTime";
+const _C = "Count";
 const _CC = "ClientContext";
+const _CD = "CreationDate";
+const _CME = "ConcurrentModificationException";
+const _CS = "CognitoStreams";
+const _D = "Dataset";
+const _DC = "DatasetCount";
+const _DD = "DeleteDataset";
+const _DDARSC = "DatasetDeletedAfterRequestedSyncCount";
+const _DDR = "DeleteDatasetRequest";
+const _DDRe = "DeleteDatasetResponse";
+const _DDRes = "DescribeDatasetRequest";
+const _DDResc = "DescribeDatasetResponse";
+const _DDe = "DescribeDataset";
+const _DE = "DatasetExists";
+const _DI = "DeviceId";
+const _DIPU = "DescribeIdentityPoolUsage";
+const _DIPUR = "DescribeIdentityPoolUsageRequest";
+const _DIPURe = "DescribeIdentityPoolUsageResponse";
+const _DIU = "DescribeIdentityUsage";
+const _DIUR = "DescribeIdentityUsageRequest";
+const _DIURe = "DescribeIdentityUsageResponse";
+const _DL = "DatasetList";
+const _DLMD = "DeviceLastModifiedDate";
+const _DN = "DatasetName";
+const _DRE = "DuplicateRequestException";
+const _DS = "DataStorage";
+const _DSC = "DatasetSyncCount";
+const _Da = "Datasets";
+const _E = "Events";
+const _FM = "FailureMessage";
+const _GBPD = "GetBulkPublishDetails";
+const _GBPDR = "GetBulkPublishDetailsRequest";
+const _GBPDRe = "GetBulkPublishDetailsResponse";
+const _GCE = "GetCognitoEvents";
+const _GCER = "GetCognitoEventsRequest";
+const _GCERe = "GetCognitoEventsResponse";
+const _GIPC = "GetIdentityPoolConfiguration";
+const _GIPCR = "GetIdentityPoolConfigurationRequest";
+const _GIPCRe = "GetIdentityPoolConfigurationResponse";
+const _ICE = "InvalidConfigurationException";
+const _IEE = "InternalErrorException";
+const _II = "IdentityId";
+const _ILFOE = "InvalidLambdaFunctionOutputException";
+const _IPE = "InvalidParameterException";
+const _IPI = "IdentityPoolId";
+const _IPU = "IdentityPoolUsage";
+const _IPUL = "IdentityPoolUsageList";
+const _IPUd = "IdentityPoolUsages";
+const _IU = "IdentityUsage";
+const _K = "Key";
+const _LD = "ListDatasets";
+const _LDR = "ListDatasetsRequest";
+const _LDRi = "ListDatasetsResponse";
+const _LEE = "LimitExceededException";
+const _LIPU = "ListIdentityPoolUsage";
+const _LIPUR = "ListIdentityPoolUsageRequest";
+const _LIPURi = "ListIdentityPoolUsageResponse";
+const _LMB = "LastModifiedBy";
+const _LMD = "LastModifiedDate";
+const _LR = "ListRecords";
+const _LRR = "ListRecordsRequest";
+const _LRRi = "ListRecordsResponse";
 const _LSC = "LastSyncCount";
+const _LTE = "LambdaThrottledException";
+const _MDN = "MergedDatasetNames";
 const _MR = "MaxResults";
+const _NAE = "NotAuthorizedException";
+const _NR = "NumRecords";
 const _NT = "NextToken";
+const _O = "Op";
+const _P = "Platform";
+const _PS = "PushSync";
+const _R = "Records";
+const _RA = "RoleArn";
+const _RCE = "ResourceConflictException";
+const _RD = "RegisterDevice";
+const _RDR = "RegisterDeviceRequest";
+const _RDRe = "RegisterDeviceResponse";
+const _RL = "RecordList";
+const _RNFE = "ResourceNotFoundException";
+const _RP = "RecordPatch";
+const _RPL = "RecordPatchList";
+const _RPe = "RecordPatches";
+const _Re = "Record";
+const _SC = "SyncCount";
+const _SCE = "SetCognitoEvents";
+const _SCER = "SetCognitoEventsRequest";
+const _SIPC = "SetIdentityPoolConfiguration";
+const _SIPCR = "SetIdentityPoolConfigurationRequest";
+const _SIPCRe = "SetIdentityPoolConfigurationResponse";
+const _SN = "StreamName";
+const _SS = "StreamingStatus";
+const _SSC = "SyncSessionsCount";
 const _SST = "SyncSessionToken";
+const _STD = "SubscribeToDataset";
+const _STDR = "SubscribeToDatasetRequest";
+const _STDRu = "SubscribeToDatasetResponse";
+const _T = "Token";
+const _TMRE = "TooManyRequestsException";
+const _UFD = "UnsubscribeFromDataset";
+const _UFDR = "UnsubscribeFromDatasetRequest";
+const _UFDRn = "UnsubscribeFromDatasetResponse";
+const _UR = "UpdateRecords";
+const _URR = "UpdateRecordsRequest";
+const _URRp = "UpdateRecordsResponse";
+const _V = "Value";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _h = "http";
+const _hE = "httpError";
+const _hH = "httpHeader";
+const _hQ = "httpQuery";
 const _lSC = "lastSyncCount";
+const _m = "message";
 const _mR = "maxResults";
 const _nT = "nextToken";
+const _s = "server";
 const _sST = "syncSessionToken";
-const _xacc = "x-amz-client-context";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.cognitosync";
+const _xaCC = "x-amz-Client-Context";
+const n0 = "com.amazonaws.cognitosync";
+var AlreadyStreamedException = [
+    -3,
+    n0,
+    _ASE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`AlreadyStreamed`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AlreadyStreamedException, AlreadyStreamedException$1);
+var BulkPublishRequest = [3, n0, _BPR, 0, [_IPI], [[0, 1]]];
+var BulkPublishResponse = [3, n0, _BPRu, 0, [_IPI], [0]];
+var CognitoStreams = [3, n0, _CS, 0, [_SN, _RA, _SS], [0, 0, 0]];
+var ConcurrentModificationException = [
+    -3,
+    n0,
+    _CME,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`ConcurrentModification`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConcurrentModificationException, ConcurrentModificationException$1);
+var Dataset = [
+    3,
+    n0,
+    _D,
+    0,
+    [_II, _DN, _CD, _LMD, _LMB, _DS, _NR],
+    [0, 0, 4, 4, 0, 1, 1],
+];
+var DeleteDatasetRequest = [
+    3,
+    n0,
+    _DDR,
+    0,
+    [_IPI, _II, _DN],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DeleteDatasetResponse = [3, n0, _DDRe, 0, [_D], [() => Dataset]];
+var DescribeDatasetRequest = [
+    3,
+    n0,
+    _DDRes,
+    0,
+    [_IPI, _II, _DN],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DescribeDatasetResponse = [3, n0, _DDResc, 0, [_D], [() => Dataset]];
+var DescribeIdentityPoolUsageRequest = [3, n0, _DIPUR, 0, [_IPI], [[0, 1]]];
+var DescribeIdentityPoolUsageResponse = [
+    3,
+    n0,
+    _DIPURe,
+    0,
+    [_IPU],
+    [() => IdentityPoolUsage],
+];
+var DescribeIdentityUsageRequest = [
+    3,
+    n0,
+    _DIUR,
+    0,
+    [_IPI, _II],
+    [
+        [0, 1],
+        [0, 1],
+    ],
+];
+var DescribeIdentityUsageResponse = [3, n0, _DIURe, 0, [_IU], [() => IdentityUsage]];
+var DuplicateRequestException = [
+    -3,
+    n0,
+    _DRE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`DuplicateRequest`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(DuplicateRequestException, DuplicateRequestException$1);
+var GetBulkPublishDetailsRequest = [3, n0, _GBPDR, 0, [_IPI], [[0, 1]]];
+var GetBulkPublishDetailsResponse = [
+    3,
+    n0,
+    _GBPDRe,
+    0,
+    [_IPI, _BPST, _BPCT, _BPS, _FM],
+    [0, 4, 4, 0, 0],
+];
+var GetCognitoEventsRequest = [3, n0, _GCER, 0, [_IPI], [[0, 1]]];
+var GetCognitoEventsResponse = [3, n0, _GCERe, 0, [_E], [128 | 0]];
+var GetIdentityPoolConfigurationRequest = [3, n0, _GIPCR, 0, [_IPI], [[0, 1]]];
+var GetIdentityPoolConfigurationResponse = [
+    3,
+    n0,
+    _GIPCRe,
+    0,
+    [_IPI, _PS, _CS],
+    [0, () => PushSync, () => CognitoStreams],
+];
+var IdentityPoolUsage = [3, n0, _IPU, 0, [_IPI, _SSC, _DS, _LMD], [0, 1, 1, 4]];
+var IdentityUsage = [3, n0, _IU, 0, [_II, _IPI, _LMD, _DC, _DS], [0, 0, 4, 1, 1]];
+var InternalErrorException = [
+    -3,
+    n0,
+    _IEE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+        [_aQE]: [`InternalError`, 500],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalErrorException, InternalErrorException$1);
+var InvalidConfigurationException = [
+    -3,
+    n0,
+    _ICE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidConfiguration`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidConfigurationException, InvalidConfigurationException$1);
+var InvalidLambdaFunctionOutputException = [
+    -3,
+    n0,
+    _ILFOE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidLambdaFunctionOutput`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidLambdaFunctionOutputException, InvalidLambdaFunctionOutputException$1);
+var InvalidParameterException = [
+    -3,
+    n0,
+    _IPE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`InvalidParameter`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidParameterException, InvalidParameterException$1);
+var LambdaThrottledException = [
+    -3,
+    n0,
+    _LTE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+        [_aQE]: [`LambdaThrottled`, 429],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LambdaThrottledException, LambdaThrottledException$1);
+var LimitExceededException = [
+    -3,
+    n0,
+    _LEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+        [_aQE]: [`LimitExceeded`, 400],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(LimitExceededException, LimitExceededException$1);
+var ListDatasetsRequest = [
+    3,
+    n0,
+    _LDR,
+    0,
+    [_IPI, _II, _NT, _MR],
+    [
+        [0, 1],
+        [0, 1],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListDatasetsResponse = [3, n0, _LDRi, 0, [_Da, _C, _NT], [() => DatasetList, 1, 0]];
+var ListIdentityPoolUsageRequest = [
+    3,
+    n0,
+    _LIPUR,
+    0,
+    [_NT, _MR],
+    [
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+    ],
+];
+var ListIdentityPoolUsageResponse = [
+    3,
+    n0,
+    _LIPURi,
+    0,
+    [_IPUd, _MR, _C, _NT],
+    [() => IdentityPoolUsageList, 1, 1, 0],
+];
+var ListRecordsRequest = [
+    3,
+    n0,
+    _LRR,
+    0,
+    [_IPI, _II, _DN, _LSC, _NT, _MR, _SST],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [
+            1,
+            {
+                [_hQ]: _lSC,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _nT,
+            },
+        ],
+        [
+            1,
+            {
+                [_hQ]: _mR,
+            },
+        ],
+        [
+            0,
+            {
+                [_hQ]: _sST,
+            },
+        ],
+    ],
+];
+var ListRecordsResponse = [
+    3,
+    n0,
+    _LRRi,
+    0,
+    [_R, _NT, _C, _DSC, _LMB, _MDN, _DE, _DDARSC, _SST],
+    [() => RecordList, 0, 1, 1, 0, 64 | 0, 2, 2, 0],
+];
+var NotAuthorizedException = [
+    -3,
+    n0,
+    _NAE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`NotAuthorizedError`, 403],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(NotAuthorizedException, NotAuthorizedException$1);
+var PushSync = [3, n0, _PS, 0, [_AA, _RA], [64 | 0, 0]];
+var _Record = [3, n0, _Re, 0, [_K, _V, _SC, _LMD, _LMB, _DLMD], [0, 0, 1, 4, 0, 4]];
+var RecordPatch = [3, n0, _RP, 0, [_O, _K, _V, _SC, _DLMD], [0, 0, 0, 1, 4]];
+var RegisterDeviceRequest = [3, n0, _RDR, 0, [_IPI, _II, _P, _T], [[0, 1], [0, 1], 0, 0]];
+var RegisterDeviceResponse = [3, n0, _RDRe, 0, [_DI], [0]];
+var ResourceConflictException = [
+    -3,
+    n0,
+    _RCE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+        [_aQE]: [`ResourceConflict`, 409],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceConflictException, ResourceConflictException$1);
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+        [_aQE]: [`ResourceNotFound`, 404],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var SetCognitoEventsRequest = [3, n0, _SCER, 0, [_IPI, _E], [[0, 1], 128 | 0]];
+var SetIdentityPoolConfigurationRequest = [
+    3,
+    n0,
+    _SIPCR,
+    0,
+    [_IPI, _PS, _CS],
+    [[0, 1], () => PushSync, () => CognitoStreams],
+];
+var SetIdentityPoolConfigurationResponse = [
+    3,
+    n0,
+    _SIPCRe,
+    0,
+    [_IPI, _PS, _CS],
+    [0, () => PushSync, () => CognitoStreams],
+];
+var SubscribeToDatasetRequest = [
+    3,
+    n0,
+    _STDR,
+    0,
+    [_IPI, _II, _DN, _DI],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var SubscribeToDatasetResponse = [3, n0, _STDRu, 0, [], []];
+var TooManyRequestsException = [
+    -3,
+    n0,
+    _TMRE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+        [_aQE]: [`TooManyRequests`, 429],
+    },
+    [_m],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(TooManyRequestsException, TooManyRequestsException$1);
+var UnsubscribeFromDatasetRequest = [
+    3,
+    n0,
+    _UFDR,
+    0,
+    [_IPI, _II, _DN, _DI],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ],
+];
+var UnsubscribeFromDatasetResponse = [3, n0, _UFDRn, 0, [], []];
+var UpdateRecordsRequest = [
+    3,
+    n0,
+    _URR,
+    0,
+    [_IPI, _II, _DN, _DI, _RPe, _SST, _CC],
+    [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        0,
+        () => RecordPatchList,
+        0,
+        [
+            0,
+            {
+                [_hH]: _xaCC,
+            },
+        ],
+    ],
+];
+var UpdateRecordsResponse = [3, n0, _URRp, 0, [_R], [() => RecordList]];
+var __Unit = "unit";
+var CognitoSyncServiceException = [-3, _sm, "CognitoSyncServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(CognitoSyncServiceException, CognitoSyncServiceException$1);
+var DatasetList = [1, n0, _DL, 0, () => Dataset];
+var IdentityPoolUsageList = [1, n0, _IPUL, 0, () => IdentityPoolUsage];
+var RecordList = [1, n0, _RL, 0, () => _Record];
+var RecordPatchList = [1, n0, _RPL, 0, () => RecordPatch];
+var BulkPublish = [
+    9,
+    n0,
+    _BP,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/bulkpublish", 200],
+    },
+    () => BulkPublishRequest,
+    () => BulkPublishResponse,
+];
+var DeleteDataset = [
+    9,
+    n0,
+    _DD,
+    {
+        [_h]: ["DELETE", "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}", 200],
+    },
+    () => DeleteDatasetRequest,
+    () => DeleteDatasetResponse,
+];
+var DescribeDataset = [
+    9,
+    n0,
+    _DDe,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}", 200],
+    },
+    () => DescribeDatasetRequest,
+    () => DescribeDatasetResponse,
+];
+var DescribeIdentityPoolUsage = [
+    9,
+    n0,
+    _DIPU,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}", 200],
+    },
+    () => DescribeIdentityPoolUsageRequest,
+    () => DescribeIdentityPoolUsageResponse,
+];
+var DescribeIdentityUsage = [
+    9,
+    n0,
+    _DIU,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/identities/{IdentityId}", 200],
+    },
+    () => DescribeIdentityUsageRequest,
+    () => DescribeIdentityUsageResponse,
+];
+var GetBulkPublishDetails = [
+    9,
+    n0,
+    _GBPD,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/getBulkPublishDetails", 200],
+    },
+    () => GetBulkPublishDetailsRequest,
+    () => GetBulkPublishDetailsResponse,
+];
+var GetCognitoEvents = [
+    9,
+    n0,
+    _GCE,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/events", 200],
+    },
+    () => GetCognitoEventsRequest,
+    () => GetCognitoEventsResponse,
+];
+var GetIdentityPoolConfiguration = [
+    9,
+    n0,
+    _GIPC,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/configuration", 200],
+    },
+    () => GetIdentityPoolConfigurationRequest,
+    () => GetIdentityPoolConfigurationResponse,
+];
+var ListDatasets = [
+    9,
+    n0,
+    _LD,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets", 200],
+    },
+    () => ListDatasetsRequest,
+    () => ListDatasetsResponse,
+];
+var ListIdentityPoolUsage = [
+    9,
+    n0,
+    _LIPU,
+    {
+        [_h]: ["GET", "/identitypools", 200],
+    },
+    () => ListIdentityPoolUsageRequest,
+    () => ListIdentityPoolUsageResponse,
+];
+var ListRecords = [
+    9,
+    n0,
+    _LR,
+    {
+        [_h]: ["GET", "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/records", 200],
+    },
+    () => ListRecordsRequest,
+    () => ListRecordsResponse,
+];
+var RegisterDevice = [
+    9,
+    n0,
+    _RD,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/identity/{IdentityId}/device", 200],
+    },
+    () => RegisterDeviceRequest,
+    () => RegisterDeviceResponse,
+];
+var SetCognitoEvents = [
+    9,
+    n0,
+    _SCE,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/events", 200],
+    },
+    () => SetCognitoEventsRequest,
+    () => __Unit,
+];
+var SetIdentityPoolConfiguration = [
+    9,
+    n0,
+    _SIPC,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/configuration", 200],
+    },
+    () => SetIdentityPoolConfigurationRequest,
+    () => SetIdentityPoolConfigurationResponse,
+];
+var SubscribeToDataset = [
+    9,
+    n0,
+    _STD,
+    {
+        [_h]: [
+            "POST",
+            "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/subscriptions/{DeviceId}",
+            200,
+        ],
+    },
+    () => SubscribeToDatasetRequest,
+    () => SubscribeToDatasetResponse,
+];
+var UnsubscribeFromDataset = [
+    9,
+    n0,
+    _UFD,
+    {
+        [_h]: [
+            "DELETE",
+            "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}/subscriptions/{DeviceId}",
+            200,
+        ],
+    },
+    () => UnsubscribeFromDatasetRequest,
+    () => UnsubscribeFromDatasetResponse,
+];
+var UpdateRecords = [
+    9,
+    n0,
+    _UR,
+    {
+        [_h]: ["POST", "/identitypools/{IdentityPoolId}/identities/{IdentityId}/datasets/{DatasetName}", 200],
+    },
+    () => UpdateRecordsRequest,
+    () => UpdateRecordsResponse,
+];
 
 class BulkPublishCommand 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("AWSCognitoSyncService", "BulkPublish", {})
     .n("CognitoSyncClient", "BulkPublishCommand")
-    .f(void 0, void 0)
-    .ser(se_BulkPublishCommand)
-    .de(de_BulkPublishCommand)
+    .sc(BulkPublish)
     .build() {
 }
 
@@ -1090,16 +1045,11 @@ class DeleteDatasetCommand 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("AWSCognitoSyncService", "DeleteDataset", {})
     .n("CognitoSyncClient", "DeleteDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDatasetCommand)
-    .de(de_DeleteDatasetCommand)
+    .sc(DeleteDataset)
     .build() {
 }
 
@@ -1107,16 +1057,11 @@ class DescribeDatasetCommand 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("AWSCognitoSyncService", "DescribeDataset", {})
     .n("CognitoSyncClient", "DescribeDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDatasetCommand)
-    .de(de_DescribeDatasetCommand)
+    .sc(DescribeDataset)
     .build() {
 }
 
@@ -1124,16 +1069,11 @@ class DescribeIdentityPoolUsageCommand 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("AWSCognitoSyncService", "DescribeIdentityPoolUsage", {})
     .n("CognitoSyncClient", "DescribeIdentityPoolUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeIdentityPoolUsageCommand)
-    .de(de_DescribeIdentityPoolUsageCommand)
+    .sc(DescribeIdentityPoolUsage)
     .build() {
 }
 
@@ -1141,16 +1081,11 @@ class DescribeIdentityUsageCommand 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("AWSCognitoSyncService", "DescribeIdentityUsage", {})
     .n("CognitoSyncClient", "DescribeIdentityUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeIdentityUsageCommand)
-    .de(de_DescribeIdentityUsageCommand)
+    .sc(DescribeIdentityUsage)
     .build() {
 }
 
@@ -1158,16 +1093,11 @@ class GetBulkPublishDetailsCommand 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("AWSCognitoSyncService", "GetBulkPublishDetails", {})
     .n("CognitoSyncClient", "GetBulkPublishDetailsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetBulkPublishDetailsCommand)
-    .de(de_GetBulkPublishDetailsCommand)
+    .sc(GetBulkPublishDetails)
     .build() {
 }
 
@@ -1175,16 +1105,11 @@ class GetCognitoEventsCommand 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("AWSCognitoSyncService", "GetCognitoEvents", {})
     .n("CognitoSyncClient", "GetCognitoEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_GetCognitoEventsCommand)
-    .de(de_GetCognitoEventsCommand)
+    .sc(GetCognitoEvents)
     .build() {
 }
 
@@ -1192,16 +1117,11 @@ class GetIdentityPoolConfigurationCommand 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("AWSCognitoSyncService", "GetIdentityPoolConfiguration", {})
     .n("CognitoSyncClient", "GetIdentityPoolConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_GetIdentityPoolConfigurationCommand)
-    .de(de_GetIdentityPoolConfigurationCommand)
+    .sc(GetIdentityPoolConfiguration)
     .build() {
 }
 
@@ -1209,16 +1129,11 @@ class ListDatasetsCommand 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("AWSCognitoSyncService", "ListDatasets", {})
     .n("CognitoSyncClient", "ListDatasetsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDatasetsCommand)
-    .de(de_ListDatasetsCommand)
+    .sc(ListDatasets)
     .build() {
 }
 
@@ -1226,16 +1141,11 @@ class ListIdentityPoolUsageCommand 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("AWSCognitoSyncService", "ListIdentityPoolUsage", {})
     .n("CognitoSyncClient", "ListIdentityPoolUsageCommand")
-    .f(void 0, void 0)
-    .ser(se_ListIdentityPoolUsageCommand)
-    .de(de_ListIdentityPoolUsageCommand)
+    .sc(ListIdentityPoolUsage)
     .build() {
 }
 
@@ -1243,16 +1153,11 @@ class ListRecordsCommand 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("AWSCognitoSyncService", "ListRecords", {})
     .n("CognitoSyncClient", "ListRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_ListRecordsCommand)
-    .de(de_ListRecordsCommand)
+    .sc(ListRecords)
     .build() {
 }
 
@@ -1260,16 +1165,11 @@ class RegisterDeviceCommand 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("AWSCognitoSyncService", "RegisterDevice", {})
     .n("CognitoSyncClient", "RegisterDeviceCommand")
-    .f(void 0, void 0)
-    .ser(se_RegisterDeviceCommand)
-    .de(de_RegisterDeviceCommand)
+    .sc(RegisterDevice)
     .build() {
 }
 
@@ -1277,16 +1177,11 @@ class SetCognitoEventsCommand 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("AWSCognitoSyncService", "SetCognitoEvents", {})
     .n("CognitoSyncClient", "SetCognitoEventsCommand")
-    .f(void 0, void 0)
-    .ser(se_SetCognitoEventsCommand)
-    .de(de_SetCognitoEventsCommand)
+    .sc(SetCognitoEvents)
     .build() {
 }
 
@@ -1294,16 +1189,11 @@ class SetIdentityPoolConfigurationCommand 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("AWSCognitoSyncService", "SetIdentityPoolConfiguration", {})
     .n("CognitoSyncClient", "SetIdentityPoolConfigurationCommand")
-    .f(void 0, void 0)
-    .ser(se_SetIdentityPoolConfigurationCommand)
-    .de(de_SetIdentityPoolConfigurationCommand)
+    .sc(SetIdentityPoolConfiguration)
     .build() {
 }
 
@@ -1311,16 +1201,11 @@ class SubscribeToDatasetCommand 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("AWSCognitoSyncService", "SubscribeToDataset", {})
     .n("CognitoSyncClient", "SubscribeToDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_SubscribeToDatasetCommand)
-    .de(de_SubscribeToDatasetCommand)
+    .sc(SubscribeToDataset)
     .build() {
 }
 
@@ -1328,16 +1213,11 @@ class UnsubscribeFromDatasetCommand 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("AWSCognitoSyncService", "UnsubscribeFromDataset", {})
     .n("CognitoSyncClient", "UnsubscribeFromDatasetCommand")
-    .f(void 0, void 0)
-    .ser(se_UnsubscribeFromDatasetCommand)
-    .de(de_UnsubscribeFromDatasetCommand)
+    .sc(UnsubscribeFromDataset)
     .build() {
 }
 
@@ -1345,16 +1225,11 @@ class UpdateRecordsCommand 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("AWSCognitoSyncService", "UpdateRecords", {})
     .n("CognitoSyncClient", "UpdateRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateRecordsCommand)
-    .de(de_UpdateRecordsCommand)
+    .sc(UpdateRecords)
     .build() {
 }
 
@@ -1389,40 +1264,40 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AlreadyStreamedException = AlreadyStreamedException;
+exports.AlreadyStreamedException = AlreadyStreamedException$1;
 exports.BulkPublishCommand = BulkPublishCommand;
 exports.BulkPublishStatus = BulkPublishStatus;
 exports.CognitoSync = CognitoSync;
 exports.CognitoSyncClient = CognitoSyncClient;
-exports.CognitoSyncServiceException = CognitoSyncServiceException;
-exports.ConcurrentModificationException = ConcurrentModificationException;
+exports.CognitoSyncServiceException = CognitoSyncServiceException$1;
+exports.ConcurrentModificationException = ConcurrentModificationException$1;
 exports.DeleteDatasetCommand = DeleteDatasetCommand;
 exports.DescribeDatasetCommand = DescribeDatasetCommand;
 exports.DescribeIdentityPoolUsageCommand = DescribeIdentityPoolUsageCommand;
 exports.DescribeIdentityUsageCommand = DescribeIdentityUsageCommand;
-exports.DuplicateRequestException = DuplicateRequestException;
+exports.DuplicateRequestException = DuplicateRequestException$1;
 exports.GetBulkPublishDetailsCommand = GetBulkPublishDetailsCommand;
 exports.GetCognitoEventsCommand = GetCognitoEventsCommand;
 exports.GetIdentityPoolConfigurationCommand = GetIdentityPoolConfigurationCommand;
-exports.InternalErrorException = InternalErrorException;
-exports.InvalidConfigurationException = InvalidConfigurationException;
-exports.InvalidLambdaFunctionOutputException = InvalidLambdaFunctionOutputException;
-exports.InvalidParameterException = InvalidParameterException;
-exports.LambdaThrottledException = LambdaThrottledException;
-exports.LimitExceededException = LimitExceededException;
+exports.InternalErrorException = InternalErrorException$1;
+exports.InvalidConfigurationException = InvalidConfigurationException$1;
+exports.InvalidLambdaFunctionOutputException = InvalidLambdaFunctionOutputException$1;
+exports.InvalidParameterException = InvalidParameterException$1;
+exports.LambdaThrottledException = LambdaThrottledException$1;
+exports.LimitExceededException = LimitExceededException$1;
 exports.ListDatasetsCommand = ListDatasetsCommand;
 exports.ListIdentityPoolUsageCommand = ListIdentityPoolUsageCommand;
 exports.ListRecordsCommand = ListRecordsCommand;
-exports.NotAuthorizedException = NotAuthorizedException;
+exports.NotAuthorizedException = NotAuthorizedException$1;
 exports.Operation = Operation;
 exports.Platform = Platform;
 exports.RegisterDeviceCommand = RegisterDeviceCommand;
-exports.ResourceConflictException = ResourceConflictException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceConflictException = ResourceConflictException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.SetCognitoEventsCommand = SetCognitoEventsCommand;
 exports.SetIdentityPoolConfigurationCommand = SetIdentityPoolConfigurationCommand;
 exports.StreamingStatus = StreamingStatus;
 exports.SubscribeToDatasetCommand = SubscribeToDatasetCommand;
-exports.TooManyRequestsException = TooManyRequestsException;
+exports.TooManyRequestsException = TooManyRequestsException$1;
 exports.UnsubscribeFromDatasetCommand = UnsubscribeFromDatasetCommand;
 exports.UpdateRecordsCommand = UpdateRecordsCommand;