@aws-sdk/client-timestream-write 3.926.0 → 3.928.0

package/dist-cjs/index.js

@@ -6,18 +6,16 @@ var middlewareLogger = require('@aws-sdk/middleware-logger');
 var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
 var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
 var configResolver = require('@smithy/config-resolver');
-var core$1 = require('@smithy/core');
+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');
 var smithyClient = require('@smithy/smithy-client');
 var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
-var middlewareSerde = require('@smithy/middleware-serde');
-var core = require('@aws-sdk/core');
-var protocolHttp = require('@smithy/protocol-http');
-var uuid = require('@smithy/uuid');
 var runtimeConfig = require('./runtimeConfig');
 var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -33,14 +31,14 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
-class TimestreamWriteServiceException extends smithyClient.ServiceException {
+let TimestreamWriteServiceException$1 = class TimestreamWriteServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, TimestreamWriteServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends TimestreamWriteServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends TimestreamWriteServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -53,7 +51,7 @@ class AccessDeniedException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const BatchLoadDataFormat = {
     CSV: "CSV",
 };
@@ -90,7 +88,7 @@ const S3EncryptionOption = {
     SSE_KMS: "SSE_KMS",
     SSE_S3: "SSE_S3",
 };
-class ConflictException extends TimestreamWriteServiceException {
+let ConflictException$1 = class ConflictException extends TimestreamWriteServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -103,8 +101,8 @@ class ConflictException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalServerException extends TimestreamWriteServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends TimestreamWriteServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -117,8 +115,8 @@ class InternalServerException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidEndpointException extends TimestreamWriteServiceException {
+};
+let InvalidEndpointException$1 = class InvalidEndpointException extends TimestreamWriteServiceException$1 {
     name = "InvalidEndpointException";
     $fault = "client";
     Message;
@@ -131,8 +129,8 @@ class InvalidEndpointException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, InvalidEndpointException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends TimestreamWriteServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends TimestreamWriteServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -145,8 +143,8 @@ class ResourceNotFoundException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
         this.Message = opts.Message;
     }
-}
-class ServiceQuotaExceededException extends TimestreamWriteServiceException {
+};
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends TimestreamWriteServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -159,8 +157,8 @@ class ServiceQuotaExceededException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ThrottlingException extends TimestreamWriteServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends TimestreamWriteServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     Message;
@@ -173,8 +171,8 @@ class ThrottlingException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends TimestreamWriteServiceException {
+};
+let ValidationException$1 = class ValidationException extends TimestreamWriteServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -187,7 +185,7 @@ class ValidationException extends TimestreamWriteServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const PartitionKeyEnforcementLevel = {
     OPTIONAL: "OPTIONAL",
     REQUIRED: "REQUIRED",
@@ -204,7 +202,7 @@ const TableStatus = {
 const DimensionValueType = {
     VARCHAR: "VARCHAR",
 };
-class RejectedRecordsException extends TimestreamWriteServiceException {
+let RejectedRecordsException$1 = class RejectedRecordsException extends TimestreamWriteServiceException$1 {
     name = "RejectedRecordsException";
     $fault = "client";
     Message;
@@ -219,673 +217,648 @@ class RejectedRecordsException extends TimestreamWriteServiceException {
         this.Message = opts.Message;
         this.RejectedRecords = opts.RejectedRecords;
     }
-}
-const CreateBatchLoadTaskRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ClientToken && { ClientToken: smithyClient.SENSITIVE_STRING }),
-});
-
-const se_CreateBatchLoadTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateBatchLoadTask");
-    let body;
-    body = JSON.stringify(se_CreateBatchLoadTaskRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateDatabaseCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateDatabase");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateTableCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateTable");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteDatabaseCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteDatabase");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteTableCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteTable");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeBatchLoadTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeBatchLoadTask");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeDatabaseCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeDatabase");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeEndpointsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeEndpoints");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeTableCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeTable");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListBatchLoadTasksCommand = async (input, context) => {
-    const headers = sharedHeaders("ListBatchLoadTasks");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListDatabasesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListDatabases");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTablesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTables");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListTagsForResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("ListTagsForResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ResumeBatchLoadTaskCommand = async (input, context) => {
-    const headers = sharedHeaders("ResumeBatchLoadTask");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_TagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("TagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UntagResourceCommand = async (input, context) => {
-    const headers = sharedHeaders("UntagResource");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateDatabaseCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateDatabase");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateTableCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateTable");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_WriteRecordsCommand = async (input, context) => {
-    const headers = sharedHeaders("WriteRecords");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CreateBatchLoadTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateDatabaseCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateDatabaseResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_CreateTableCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_CreateTableResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DeleteDatabaseCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DeleteTableCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    await smithyClient.collectBody(output.body, context);
-    const response = {
-        $metadata: deserializeMetadata(output),
-    };
-    return response;
-};
-const de_DescribeBatchLoadTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeBatchLoadTaskResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeDatabaseCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeDatabaseResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeEndpointsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_DescribeTableCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeTableResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListBatchLoadTasksCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListBatchLoadTasksResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListDatabasesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListDatabasesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTablesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListTablesResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ListTagsForResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ResumeBatchLoadTaskCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_TagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UntagResourceCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = smithyClient._json(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateDatabaseCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateDatabaseResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_UpdateTableCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_UpdateTableResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_WriteRecordsCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.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.parseJsonErrorBody(output.body, context),
-    };
-    const errorCode = core.loadRestJsonErrorCode(output, parsedOutput.body);
-    switch (errorCode) {
-        case "AccessDeniedException":
-        case "com.amazonaws.timestreamwrite#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.timestreamwrite#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.timestreamwrite#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "InvalidEndpointException":
-        case "com.amazonaws.timestreamwrite#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.timestreamwrite#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.timestreamwrite#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.timestreamwrite#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.timestreamwrite#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "RejectedRecordsException":
-        case "com.amazonaws.timestreamwrite#RejectedRecordsException":
-            throw await de_RejectedRecordsExceptionRes(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_ConflictExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ConflictException({
-        $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_InvalidEndpointExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new InvalidEndpointException({
-        $metadata: deserializeMetadata(parsedOutput),
-        ...deserialized,
-    });
-    return smithyClient.decorateServiceException(exception, body);
-};
-const de_RejectedRecordsExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new RejectedRecordsException({
-        $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_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new ServiceQuotaExceededException({
-        $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 se_CreateBatchLoadTaskRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        DataModelConfiguration: smithyClient._json,
-        DataSourceConfiguration: smithyClient._json,
-        RecordVersion: [],
-        ReportConfiguration: smithyClient._json,
-        TargetDatabaseName: [],
-        TargetTableName: [],
-    });
-};
-const de_BatchLoadTask = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DatabaseName: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ResumableUntil: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        TableName: smithyClient.expectString,
-        TaskId: smithyClient.expectString,
-        TaskStatus: smithyClient.expectString,
-    });
-};
-const de_BatchLoadTaskDescription = (output, context) => {
-    return smithyClient.take(output, {
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DataModelConfiguration: smithyClient._json,
-        DataSourceConfiguration: smithyClient._json,
-        ErrorMessage: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ProgressReport: smithyClient._json,
-        RecordVersion: smithyClient.expectLong,
-        ReportConfiguration: smithyClient._json,
-        ResumableUntil: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        TargetDatabaseName: smithyClient.expectString,
-        TargetTableName: smithyClient.expectString,
-        TaskId: smithyClient.expectString,
-        TaskStatus: smithyClient.expectString,
-    });
 };
-const de_BatchLoadTaskList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_BatchLoadTask(entry);
-    });
-    return retVal;
-};
-const de_CreateDatabaseResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Database: (_) => de_Database(_),
-    });
-};
-const de_CreateTableResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Table: (_) => de_Table(_),
-    });
-};
-const de_Database = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DatabaseName: smithyClient.expectString,
-        KmsKeyId: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        TableCount: smithyClient.expectLong,
-    });
-};
-const de_DatabaseList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Database(entry);
-    });
-    return retVal;
-};
-const de_DescribeBatchLoadTaskResponse = (output, context) => {
-    return smithyClient.take(output, {
-        BatchLoadTaskDescription: (_) => de_BatchLoadTaskDescription(_),
-    });
-};
-const de_DescribeDatabaseResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Database: (_) => de_Database(_),
-    });
-};
-const de_DescribeTableResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Table: (_) => de_Table(_),
-    });
-};
-const de_ListBatchLoadTasksResponse = (output, context) => {
-    return smithyClient.take(output, {
-        BatchLoadTasks: (_) => de_BatchLoadTaskList(_),
-        NextToken: smithyClient.expectString,
-    });
-};
-const de_ListDatabasesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Databases: (_) => de_DatabaseList(_),
-        NextToken: smithyClient.expectString,
-    });
-};
-const de_ListTablesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        Tables: (_) => de_TableList(_),
-    });
-};
-const de_Table = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        DatabaseName: smithyClient.expectString,
-        LastUpdatedTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        MagneticStoreWriteProperties: smithyClient._json,
-        RetentionProperties: smithyClient._json,
-        Schema: smithyClient._json,
-        TableName: smithyClient.expectString,
-        TableStatus: smithyClient.expectString,
-    });
-};
-const de_TableList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Table(entry);
-    });
-    return retVal;
-};
-const de_UpdateDatabaseResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Database: (_) => de_Database(_),
-    });
-};
-const de_UpdateTableResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Table: (_) => de_Table(_),
-    });
-};
-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(TimestreamWriteServiceException);
-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": `Timestream_20181101.${operation}`,
-    };
-}
+
+const _A = "Arn";
+const _ADE = "AccessDeniedException";
+const _Ad = "Address";
+const _BLPR = "BatchLoadProgressReport";
+const _BLT = "BatchLoadTask";
+const _BLTD = "BatchLoadTaskDescription";
+const _BLTL = "BatchLoadTaskList";
+const _BLTa = "BatchLoadTasks";
+const _BM = "BytesMetered";
+const _BN = "BucketName";
+const _CA = "CommonAttributes";
+const _CBLT = "CreateBatchLoadTask";
+const _CBLTR = "CreateBatchLoadTaskRequest";
+const _CBLTRr = "CreateBatchLoadTaskResponse";
+const _CC = "CsvConfiguration";
+const _CD = "CreateDatabase";
+const _CDR = "CreateDatabaseRequest";
+const _CDRr = "CreateDatabaseResponse";
+const _CE = "ConflictException";
+const _CPIM = "CachePeriodInMinutes";
+const _CPK = "CompositePartitionKey";
+const _CRT = "ClientRequestToken";
+const _CS = "ColumnSeparator";
+const _CT = "CreationTime";
+const _CTR = "CreateTableRequest";
+const _CTRr = "CreateTableResponse";
+const _CTl = "ClientToken";
+const _CTr = "CreateTable";
+const _D = "Database";
+const _DBLT = "DescribeBatchLoadTask";
+const _DBLTR = "DescribeBatchLoadTaskRequest";
+const _DBLTRe = "DescribeBatchLoadTaskResponse";
+const _DC = "DestinationColumn";
+const _DD = "DeleteDatabase";
+const _DDR = "DeleteDatabaseRequest";
+const _DDRe = "DescribeDatabaseRequest";
+const _DDRes = "DescribeDatabaseResponse";
+const _DDe = "DescribeDatabase";
+const _DE = "DescribeEndpoints";
+const _DER = "DescribeEndpointsRequest";
+const _DERe = "DescribeEndpointsResponse";
+const _DF = "DataFormat";
+const _DL = "DatabaseList";
+const _DM = "DataModel";
+const _DMC = "DataModelConfiguration";
+const _DMSC = "DataModelS3Configuration";
+const _DMi = "DimensionMappings";
+const _DMim = "DimensionMapping";
+const _DN = "DatabaseName";
+const _DSC = "DataSourceConfiguration";
+const _DSSC = "DataSourceS3Configuration";
+const _DT = "DeleteTable";
+const _DTR = "DeleteTableRequest";
+const _DTRe = "DescribeTableRequest";
+const _DTRes = "DescribeTableResponse";
+const _DTe = "DescribeTable";
+const _DVT = "DimensionValueType";
+const _Da = "Databases";
+const _Di = "Dimension";
+const _Dim = "Dimensions";
+const _E = "Endpoints";
+const _EC = "EscapeChar";
+const _EIR = "EnforcementInRecord";
+const _EM = "ErrorMessage";
+const _EMSW = "EnableMagneticStoreWrites";
+const _EO = "EncryptionOption";
+const _EV = "ExistingVersion";
+const _En = "Endpoint";
+const _FF = "FileFailures";
+const _IEE = "InvalidEndpointException";
+const _ISE = "InternalServerException";
+const _K = "Key";
+const _KKI = "KmsKeyId";
+const _LBLT = "ListBatchLoadTasks";
+const _LBLTR = "ListBatchLoadTasksRequest";
+const _LBLTRi = "ListBatchLoadTasksResponse";
+const _LD = "ListDatabases";
+const _LDR = "ListDatabasesRequest";
+const _LDRi = "ListDatabasesResponse";
+const _LT = "ListTables";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LTR = "ListTablesRequest";
+const _LTRi = "ListTablesResponse";
+const _LUT = "LastUpdatedTime";
+const _M = "Message";
+const _MMAM = "MultiMeasureAttributeMappings";
+const _MMAML = "MultiMeasureAttributeMappingList";
+const _MMAMu = "MultiMeasureAttributeMapping";
+const _MMM = "MultiMeasureMappings";
+const _MMML = "MixedMeasureMappingList";
+const _MMMi = "MixedMeasureMappings";
+const _MMMix = "MixedMeasureMapping";
+const _MN = "MeasureName";
+const _MNC = "MeasureNameColumn";
+const _MR = "MaxResults";
+const _MS = "MemoryStore";
+const _MSRDL = "MagneticStoreRejectedDataLocation";
+const _MSRPID = "MagneticStoreRetentionPeriodInDays";
+const _MSRPIH = "MemoryStoreRetentionPeriodInHours";
+const _MSWP = "MagneticStoreWriteProperties";
+const _MSa = "MagneticStore";
+const _MV = "MeasureValue";
+const _MVT = "MeasureValueType";
+const _MVe = "MeasureValues";
+const _N = "Name";
+const _NT = "NextToken";
+const _NV = "NullValue";
+const _OK = "ObjectKey";
+const _OKP = "ObjectKeyPrefix";
+const _PF = "ParseFailures";
+const _PK = "PartitionKey";
+const _PKL = "PartitionKeyList";
+const _PR = "ProgressReport";
+const _QC = "QuoteChar";
+const _R = "Record";
+const _RARN = "ResourceARN";
+const _RBLT = "ResumeBatchLoadTask";
+const _RBLTR = "ResumeBatchLoadTaskRequest";
+const _RBLTRe = "ResumeBatchLoadTaskResponse";
+const _RC = "ReportConfiguration";
+const _RI = "RecordsIngested";
+const _RIF = "RecordIngestionFailures";
+const _RIe = "RecordIndex";
+const _RNFE = "ResourceNotFoundException";
+const _RP = "RecordsProcessed";
+const _RPe = "RetentionProperties";
+const _RR = "RejectedRecord";
+const _RRE = "RejectedRecordsException";
+const _RRe = "RejectedRecords";
+const _RSC = "ReportS3Configuration";
+const _RU = "ResumableUntil";
+const _RV = "RecordVersion";
+const _Re = "Reason";
+const _Rec = "Records";
+const _S = "Schema";
+const _SC = "SourceColumn";
+const _SCo = "S3Configuration";
+const _SQEE = "ServiceQuotaExceededException";
+const _T = "Tags";
+const _TC = "TableCount";
+const _TCi = "TimeColumn";
+const _TDN = "TargetDatabaseName";
+const _TE = "ThrottlingException";
+const _TI = "TaskId";
+const _TK = "TagKeys";
+const _TL = "TableList";
+const _TLa = "TagList";
+const _TMMAN = "TargetMultiMeasureAttributeName";
+const _TMMN = "TargetMultiMeasureName";
+const _TMN = "TargetMeasureName";
+const _TN = "TableName";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TS = "TaskStatus";
+const _TSa = "TableStatus";
+const _TTN = "TargetTableName";
+const _TU = "TimeUnit";
+const _TWS = "TrimWhiteSpace";
+const _Ta = "Table";
+const _Tab = "Tables";
+const _Tag = "Tag";
+const _Ti = "Time";
+const _To = "Total";
+const _Ty = "Type";
+const _UD = "UpdateDatabase";
+const _UDR = "UpdateDatabaseRequest";
+const _UDRp = "UpdateDatabaseResponse";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _UT = "UpdateTable";
+const _UTR = "UpdateTableRequest";
+const _UTRp = "UpdateTableResponse";
+const _V = "Value";
+const _VE = "ValidationException";
+const _Ve = "Version";
+const _WR = "WriteRecords";
+const _WRR = "WriteRecordsRequest";
+const _WRRr = "WriteRecordsResponse";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.timestreamwrite";
+const n0 = "com.amazonaws.timestreamwrite";
+var ClientRequestToken = [0, n0, _CRT, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var BatchLoadProgressReport = [
+    3,
+    n0,
+    _BLPR,
+    0,
+    [_RP, _RI, _PF, _RIF, _FF, _BM],
+    [1, 1, 1, 1, 1, 1],
+];
+var BatchLoadTask = [
+    3,
+    n0,
+    _BLT,
+    0,
+    [_TI, _TS, _DN, _TN, _CT, _LUT, _RU],
+    [0, 0, 0, 0, 4, 4, 4],
+];
+var BatchLoadTaskDescription = [
+    3,
+    n0,
+    _BLTD,
+    0,
+    [_TI, _EM, _DSC, _PR, _RC, _DMC, _TDN, _TTN, _TS, _RV, _CT, _LUT, _RU],
+    [
+        0,
+        0,
+        () => DataSourceConfiguration,
+        () => BatchLoadProgressReport,
+        () => ReportConfiguration,
+        () => DataModelConfiguration,
+        0,
+        0,
+        0,
+        1,
+        4,
+        4,
+        4,
+    ],
+];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateBatchLoadTaskRequest = [
+    3,
+    n0,
+    _CBLTR,
+    0,
+    [_CTl, _DMC, _DSC, _RC, _TDN, _TTN, _RV],
+    [
+        [() => ClientRequestToken, 4],
+        () => DataModelConfiguration,
+        () => DataSourceConfiguration,
+        () => ReportConfiguration,
+        0,
+        0,
+        1,
+    ],
+];
+var CreateBatchLoadTaskResponse = [3, n0, _CBLTRr, 0, [_TI], [0]];
+var CreateDatabaseRequest = [3, n0, _CDR, 0, [_DN, _KKI, _T], [0, 0, () => TagList]];
+var CreateDatabaseResponse = [3, n0, _CDRr, 0, [_D], [() => Database]];
+var CreateTableRequest = [
+    3,
+    n0,
+    _CTR,
+    0,
+    [_DN, _TN, _RPe, _T, _MSWP, _S],
+    [0, 0, () => RetentionProperties, () => TagList, () => MagneticStoreWriteProperties, () => Schema],
+];
+var CreateTableResponse = [3, n0, _CTRr, 0, [_Ta], [() => Table]];
+var CsvConfiguration = [3, n0, _CC, 0, [_CS, _EC, _QC, _NV, _TWS], [0, 0, 0, 0, 2]];
+var Database = [3, n0, _D, 0, [_A, _DN, _TC, _KKI, _CT, _LUT], [0, 0, 1, 0, 4, 4]];
+var DataModel = [
+    3,
+    n0,
+    _DM,
+    0,
+    [_TCi, _TU, _DMi, _MMM, _MMMi, _MNC],
+    [0, 0, () => DimensionMappings, () => MultiMeasureMappings, () => MixedMeasureMappingList, 0],
+];
+var DataModelConfiguration = [
+    3,
+    n0,
+    _DMC,
+    0,
+    [_DM, _DMSC],
+    [() => DataModel, () => DataModelS3Configuration],
+];
+var DataModelS3Configuration = [3, n0, _DMSC, 0, [_BN, _OK], [0, 0]];
+var DataSourceConfiguration = [
+    3,
+    n0,
+    _DSC,
+    0,
+    [_DSSC, _CC, _DF],
+    [() => DataSourceS3Configuration, () => CsvConfiguration, 0],
+];
+var DataSourceS3Configuration = [3, n0, _DSSC, 0, [_BN, _OKP], [0, 0]];
+var DeleteDatabaseRequest = [3, n0, _DDR, 0, [_DN], [0]];
+var DeleteTableRequest = [3, n0, _DTR, 0, [_DN, _TN], [0, 0]];
+var DescribeBatchLoadTaskRequest = [3, n0, _DBLTR, 0, [_TI], [0]];
+var DescribeBatchLoadTaskResponse = [
+    3,
+    n0,
+    _DBLTRe,
+    0,
+    [_BLTD],
+    [() => BatchLoadTaskDescription],
+];
+var DescribeDatabaseRequest = [3, n0, _DDRe, 0, [_DN], [0]];
+var DescribeDatabaseResponse = [3, n0, _DDRes, 0, [_D], [() => Database]];
+var DescribeEndpointsRequest = [3, n0, _DER, 0, [], []];
+var DescribeEndpointsResponse = [3, n0, _DERe, 0, [_E], [() => Endpoints]];
+var DescribeTableRequest = [3, n0, _DTRe, 0, [_DN, _TN], [0, 0]];
+var DescribeTableResponse = [3, n0, _DTRes, 0, [_Ta], [() => Table]];
+var Dimension = [3, n0, _Di, 0, [_N, _V, _DVT], [0, 0, 0]];
+var DimensionMapping = [3, n0, _DMim, 0, [_SC, _DC], [0, 0]];
+var Endpoint = [3, n0, _En, 0, [_Ad, _CPIM], [0, 1]];
+var InternalServerException = [
+    -3,
+    n0,
+    _ISE,
+    {
+        [_e]: _s,
+        [_hE]: 500,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InternalServerException, InternalServerException$1);
+var InvalidEndpointException = [
+    -3,
+    n0,
+    _IEE,
+    {
+        [_e]: _c,
+        [_hE]: 421,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(InvalidEndpointException, InvalidEndpointException$1);
+var ListBatchLoadTasksRequest = [3, n0, _LBLTR, 0, [_NT, _MR, _TS], [0, 1, 0]];
+var ListBatchLoadTasksResponse = [
+    3,
+    n0,
+    _LBLTRi,
+    0,
+    [_NT, _BLTa],
+    [0, () => BatchLoadTaskList],
+];
+var ListDatabasesRequest = [3, n0, _LDR, 0, [_NT, _MR], [0, 1]];
+var ListDatabasesResponse = [3, n0, _LDRi, 0, [_Da, _NT], [() => DatabaseList, 0]];
+var ListTablesRequest = [3, n0, _LTR, 0, [_DN, _NT, _MR], [0, 0, 1]];
+var ListTablesResponse = [3, n0, _LTRi, 0, [_Tab, _NT], [() => TableList, 0]];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RARN], [0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_T], [() => TagList]];
+var MagneticStoreRejectedDataLocation = [
+    3,
+    n0,
+    _MSRDL,
+    0,
+    [_SCo],
+    [() => S3Configuration],
+];
+var MagneticStoreWriteProperties = [
+    3,
+    n0,
+    _MSWP,
+    0,
+    [_EMSW, _MSRDL],
+    [2, () => MagneticStoreRejectedDataLocation],
+];
+var MeasureValue = [3, n0, _MV, 0, [_N, _V, _Ty], [0, 0, 0]];
+var MixedMeasureMapping = [
+    3,
+    n0,
+    _MMMix,
+    0,
+    [_MN, _SC, _TMN, _MVT, _MMAM],
+    [0, 0, 0, 0, () => MultiMeasureAttributeMappingList],
+];
+var MultiMeasureAttributeMapping = [3, n0, _MMAMu, 0, [_SC, _TMMAN, _MVT], [0, 0, 0]];
+var MultiMeasureMappings = [
+    3,
+    n0,
+    _MMM,
+    0,
+    [_TMMN, _MMAM],
+    [0, () => MultiMeasureAttributeMappingList],
+];
+var PartitionKey = [3, n0, _PK, 0, [_Ty, _N, _EIR], [0, 0, 0]];
+var _Record = [
+    3,
+    n0,
+    _R,
+    0,
+    [_Dim, _MN, _MV, _MVT, _Ti, _TU, _Ve, _MVe],
+    [() => Dimensions, 0, 0, 0, 0, 0, 1, () => MeasureValues],
+];
+var RecordsIngested = [3, n0, _RI, 0, [_To, _MS, _MSa], [1, 1, 1]];
+var RejectedRecord = [3, n0, _RR, 0, [_RIe, _Re, _EV], [1, 0, 1]];
+var RejectedRecordsException = [
+    -3,
+    n0,
+    _RRE,
+    {
+        [_e]: _c,
+        [_hE]: 419,
+    },
+    [_M, _RRe],
+    [0, () => RejectedRecords],
+];
+schema.TypeRegistry.for(n0).registerError(RejectedRecordsException, RejectedRecordsException$1);
+var ReportConfiguration = [3, n0, _RC, 0, [_RSC], [() => ReportS3Configuration]];
+var ReportS3Configuration = [3, n0, _RSC, 0, [_BN, _OKP, _EO, _KKI], [0, 0, 0, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var ResumeBatchLoadTaskRequest = [3, n0, _RBLTR, 0, [_TI], [0]];
+var ResumeBatchLoadTaskResponse = [3, n0, _RBLTRe, 0, [], []];
+var RetentionProperties = [3, n0, _RPe, 0, [_MSRPIH, _MSRPID], [1, 1]];
+var S3Configuration = [3, n0, _SCo, 0, [_BN, _OKP, _EO, _KKI], [0, 0, 0, 0]];
+var Schema = [3, n0, _S, 0, [_CPK], [() => PartitionKeyList]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var Table = [
+    3,
+    n0,
+    _Ta,
+    0,
+    [_A, _TN, _DN, _TSa, _RPe, _CT, _LUT, _MSWP, _S],
+    [0, 0, 0, 0, () => RetentionProperties, 4, 4, () => MagneticStoreWriteProperties, () => Schema],
+];
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RARN, _T], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var UntagResourceRequest = [3, n0, _URR, 0, [_RARN, _TK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateDatabaseRequest = [3, n0, _UDR, 0, [_DN, _KKI], [0, 0]];
+var UpdateDatabaseResponse = [3, n0, _UDRp, 0, [_D], [() => Database]];
+var UpdateTableRequest = [
+    3,
+    n0,
+    _UTR,
+    0,
+    [_DN, _TN, _RPe, _MSWP, _S],
+    [0, 0, () => RetentionProperties, () => MagneticStoreWriteProperties, () => Schema],
+];
+var UpdateTableResponse = [3, n0, _UTRp, 0, [_Ta], [() => Table]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var WriteRecordsRequest = [
+    3,
+    n0,
+    _WRR,
+    0,
+    [_DN, _TN, _CA, _Rec],
+    [0, 0, () => _Record, () => Records],
+];
+var WriteRecordsResponse = [3, n0, _WRRr, 0, [_RI], [() => RecordsIngested]];
+var __Unit = "unit";
+var TimestreamWriteServiceException = [-3, _sm, "TimestreamWriteServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(TimestreamWriteServiceException, TimestreamWriteServiceException$1);
+var BatchLoadTaskList = [1, n0, _BLTL, 0, () => BatchLoadTask];
+var DatabaseList = [1, n0, _DL, 0, () => Database];
+var DimensionMappings = [1, n0, _DMi, 0, () => DimensionMapping];
+var Dimensions = [1, n0, _Dim, 0, () => Dimension];
+var Endpoints = [1, n0, _E, 0, () => Endpoint];
+var MeasureValues = [1, n0, _MVe, 0, () => MeasureValue];
+var MixedMeasureMappingList = [1, n0, _MMML, 0, () => MixedMeasureMapping];
+var MultiMeasureAttributeMappingList = [1, n0, _MMAML, 0, () => MultiMeasureAttributeMapping];
+var PartitionKeyList = [1, n0, _PKL, 0, () => PartitionKey];
+var Records = [1, n0, _Rec, 0, () => _Record];
+var RejectedRecords = [1, n0, _RRe, 0, () => RejectedRecord];
+var TableList = [1, n0, _TL, 0, () => Table];
+var TagList = [1, n0, _TLa, 0, () => Tag];
+var CreateBatchLoadTask = [
+    9,
+    n0,
+    _CBLT,
+    0,
+    () => CreateBatchLoadTaskRequest,
+    () => CreateBatchLoadTaskResponse,
+];
+var CreateDatabase = [
+    9,
+    n0,
+    _CD,
+    0,
+    () => CreateDatabaseRequest,
+    () => CreateDatabaseResponse,
+];
+var CreateTable = [9, n0, _CTr, 0, () => CreateTableRequest, () => CreateTableResponse];
+var DeleteDatabase = [9, n0, _DD, 0, () => DeleteDatabaseRequest, () => __Unit];
+var DeleteTable = [9, n0, _DT, 0, () => DeleteTableRequest, () => __Unit];
+var DescribeBatchLoadTask = [
+    9,
+    n0,
+    _DBLT,
+    0,
+    () => DescribeBatchLoadTaskRequest,
+    () => DescribeBatchLoadTaskResponse,
+];
+var DescribeDatabase = [
+    9,
+    n0,
+    _DDe,
+    0,
+    () => DescribeDatabaseRequest,
+    () => DescribeDatabaseResponse,
+];
+var DescribeEndpoints = [
+    9,
+    n0,
+    _DE,
+    0,
+    () => DescribeEndpointsRequest,
+    () => DescribeEndpointsResponse,
+];
+var DescribeTable = [
+    9,
+    n0,
+    _DTe,
+    0,
+    () => DescribeTableRequest,
+    () => DescribeTableResponse,
+];
+var ListBatchLoadTasks = [
+    9,
+    n0,
+    _LBLT,
+    0,
+    () => ListBatchLoadTasksRequest,
+    () => ListBatchLoadTasksResponse,
+];
+var ListDatabases = [
+    9,
+    n0,
+    _LD,
+    0,
+    () => ListDatabasesRequest,
+    () => ListDatabasesResponse,
+];
+var ListTables = [9, n0, _LT, 0, () => ListTablesRequest, () => ListTablesResponse];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var ResumeBatchLoadTask = [
+    9,
+    n0,
+    _RBLT,
+    0,
+    () => ResumeBatchLoadTaskRequest,
+    () => ResumeBatchLoadTaskResponse,
+];
+var TagResource = [9, n0, _TR, 0, () => TagResourceRequest, () => TagResourceResponse];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    0,
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateDatabase = [
+    9,
+    n0,
+    _UD,
+    0,
+    () => UpdateDatabaseRequest,
+    () => UpdateDatabaseResponse,
+];
+var UpdateTable = [9, n0, _UT, 0, () => UpdateTableRequest, () => UpdateTableResponse];
+var WriteRecords = [9, n0, _WR, 0, () => WriteRecordsRequest, () => WriteRecordsResponse];
 
 class DescribeEndpointsCommand 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("Timestream_20181101", "DescribeEndpoints", {})
     .n("TimestreamWriteClient", "DescribeEndpointsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeEndpointsCommand)
-    .de(de_DescribeEndpointsCommand)
+    .sc(DescribeEndpoints)
     .build() {
 }
 
@@ -952,19 +925,20 @@ class TimestreamWriteClient extends smithyClient.Client {
         });
         const _config_9 = resolveRuntimeExtensions(_config_8, configuration?.extensions || []);
         this.config = _config_9;
+        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));
         this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
         this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
         this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
-        this.middlewareStack.use(core$1.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
             httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultTimestreamWriteHttpAuthSchemeParametersProvider,
-            identityProviderConfigProvider: async (config) => new core$1.DefaultIdentityProviderConfig({
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
                 "aws.auth#sigv4": config.credentials,
             }),
         }));
-        this.middlewareStack.use(core$1.getHttpSigningPlugin(this.config));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
     destroy() {
         super.destroy();
@@ -976,7 +950,6 @@ class CreateBatchLoadTaskCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -987,9 +960,7 @@ class CreateBatchLoadTaskCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "CreateBatchLoadTask", {})
     .n("TimestreamWriteClient", "CreateBatchLoadTaskCommand")
-    .f(CreateBatchLoadTaskRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateBatchLoadTaskCommand)
-    .de(de_CreateBatchLoadTaskCommand)
+    .sc(CreateBatchLoadTask)
     .build() {
 }
 
@@ -998,7 +969,6 @@ class CreateDatabaseCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1009,9 +979,7 @@ class CreateDatabaseCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "CreateDatabase", {})
     .n("TimestreamWriteClient", "CreateDatabaseCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateDatabaseCommand)
-    .de(de_CreateDatabaseCommand)
+    .sc(CreateDatabase)
     .build() {
 }
 
@@ -1020,7 +988,6 @@ class CreateTableCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1031,9 +998,7 @@ class CreateTableCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "CreateTable", {})
     .n("TimestreamWriteClient", "CreateTableCommand")
-    .f(void 0, void 0)
-    .ser(se_CreateTableCommand)
-    .de(de_CreateTableCommand)
+    .sc(CreateTable)
     .build() {
 }
 
@@ -1042,7 +1007,6 @@ class DeleteDatabaseCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1053,9 +1017,7 @@ class DeleteDatabaseCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DeleteDatabase", {})
     .n("TimestreamWriteClient", "DeleteDatabaseCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteDatabaseCommand)
-    .de(de_DeleteDatabaseCommand)
+    .sc(DeleteDatabase)
     .build() {
 }
 
@@ -1064,7 +1026,6 @@ class DeleteTableCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1075,9 +1036,7 @@ class DeleteTableCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DeleteTable", {})
     .n("TimestreamWriteClient", "DeleteTableCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteTableCommand)
-    .de(de_DeleteTableCommand)
+    .sc(DeleteTable)
     .build() {
 }
 
@@ -1086,7 +1045,6 @@ class DescribeBatchLoadTaskCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1097,9 +1055,7 @@ class DescribeBatchLoadTaskCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DescribeBatchLoadTask", {})
     .n("TimestreamWriteClient", "DescribeBatchLoadTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeBatchLoadTaskCommand)
-    .de(de_DescribeBatchLoadTaskCommand)
+    .sc(DescribeBatchLoadTask)
     .build() {
 }
 
@@ -1108,7 +1064,6 @@ class DescribeDatabaseCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1119,9 +1074,7 @@ class DescribeDatabaseCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DescribeDatabase", {})
     .n("TimestreamWriteClient", "DescribeDatabaseCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeDatabaseCommand)
-    .de(de_DescribeDatabaseCommand)
+    .sc(DescribeDatabase)
     .build() {
 }
 
@@ -1130,7 +1083,6 @@ class DescribeTableCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1141,9 +1093,7 @@ class DescribeTableCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DescribeTable", {})
     .n("TimestreamWriteClient", "DescribeTableCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeTableCommand)
-    .de(de_DescribeTableCommand)
+    .sc(DescribeTable)
     .build() {
 }
 
@@ -1152,7 +1102,6 @@ class ListBatchLoadTasksCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1163,9 +1112,7 @@ class ListBatchLoadTasksCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListBatchLoadTasks", {})
     .n("TimestreamWriteClient", "ListBatchLoadTasksCommand")
-    .f(void 0, void 0)
-    .ser(se_ListBatchLoadTasksCommand)
-    .de(de_ListBatchLoadTasksCommand)
+    .sc(ListBatchLoadTasks)
     .build() {
 }
 
@@ -1174,7 +1121,6 @@ class ListDatabasesCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1185,9 +1131,7 @@ class ListDatabasesCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListDatabases", {})
     .n("TimestreamWriteClient", "ListDatabasesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListDatabasesCommand)
-    .de(de_ListDatabasesCommand)
+    .sc(ListDatabases)
     .build() {
 }
 
@@ -1196,7 +1140,6 @@ class ListTablesCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1207,9 +1150,7 @@ class ListTablesCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListTables", {})
     .n("TimestreamWriteClient", "ListTablesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTablesCommand)
-    .de(de_ListTablesCommand)
+    .sc(ListTables)
     .build() {
 }
 
@@ -1218,7 +1159,6 @@ class ListTagsForResourceCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1229,9 +1169,7 @@ class ListTagsForResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListTagsForResource", {})
     .n("TimestreamWriteClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1240,7 +1178,6 @@ class ResumeBatchLoadTaskCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1251,9 +1188,7 @@ class ResumeBatchLoadTaskCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ResumeBatchLoadTask", {})
     .n("TimestreamWriteClient", "ResumeBatchLoadTaskCommand")
-    .f(void 0, void 0)
-    .ser(se_ResumeBatchLoadTaskCommand)
-    .de(de_ResumeBatchLoadTaskCommand)
+    .sc(ResumeBatchLoadTask)
     .build() {
 }
 
@@ -1262,7 +1197,6 @@ class TagResourceCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1273,9 +1207,7 @@ class TagResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "TagResource", {})
     .n("TimestreamWriteClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1284,7 +1216,6 @@ class UntagResourceCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1295,9 +1226,7 @@ class UntagResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UntagResource", {})
     .n("TimestreamWriteClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1306,7 +1235,6 @@ class UpdateDatabaseCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1317,9 +1245,7 @@ class UpdateDatabaseCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UpdateDatabase", {})
     .n("TimestreamWriteClient", "UpdateDatabaseCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateDatabaseCommand)
-    .de(de_UpdateDatabaseCommand)
+    .sc(UpdateDatabase)
     .build() {
 }
 
@@ -1328,7 +1254,6 @@ class UpdateTableCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1339,9 +1264,7 @@ class UpdateTableCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UpdateTable", {})
     .n("TimestreamWriteClient", "UpdateTableCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateTableCommand)
-    .de(de_UpdateTableCommand)
+    .sc(UpdateTable)
     .build() {
 }
 
@@ -1350,7 +1273,6 @@ class WriteRecordsCommand extends smithyClient.Command
     .ep(commonParams)
     .m(function (Command, cs, config, o) {
     return [
-        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
         middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
         middlewareEndpointDiscovery.getEndpointDiscoveryPlugin(config, {
             clientStack: cs,
@@ -1361,9 +1283,7 @@ class WriteRecordsCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "WriteRecords", {})
     .n("TimestreamWriteClient", "WriteRecordsCommand")
-    .f(void 0, void 0)
-    .ser(se_WriteRecordsCommand)
-    .de(de_WriteRecordsCommand)
+    .sc(WriteRecords)
     .build() {
 }
 
@@ -1392,11 +1312,11 @@ class TimestreamWrite extends TimestreamWriteClient {
 }
 smithyClient.createAggregatedClient(commands, TimestreamWrite);
 
-const paginateListBatchLoadTasks = core$1.createPaginator(TimestreamWriteClient, ListBatchLoadTasksCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListBatchLoadTasks = core.createPaginator(TimestreamWriteClient, ListBatchLoadTasksCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListDatabases = core$1.createPaginator(TimestreamWriteClient, ListDatabasesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListDatabases = core.createPaginator(TimestreamWriteClient, ListDatabasesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTables = core$1.createPaginator(TimestreamWriteClient, ListTablesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTables = core.createPaginator(TimestreamWriteClient, ListTablesCommand, "NextToken", "NextToken", "MaxResults");
 
 Object.defineProperty(exports, "$Command", {
     enumerable: true,
@@ -1406,12 +1326,11 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.BatchLoadDataFormat = BatchLoadDataFormat;
 exports.BatchLoadStatus = BatchLoadStatus;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateBatchLoadTaskCommand = CreateBatchLoadTaskCommand;
-exports.CreateBatchLoadTaskRequestFilterSensitiveLog = CreateBatchLoadTaskRequestFilterSensitiveLog;
 exports.CreateDatabaseCommand = CreateDatabaseCommand;
 exports.CreateTableCommand = CreateTableCommand;
 exports.DeleteDatabaseCommand = DeleteDatabaseCommand;
@@ -1421,8 +1340,8 @@ exports.DescribeDatabaseCommand = DescribeDatabaseCommand;
 exports.DescribeEndpointsCommand = DescribeEndpointsCommand;
 exports.DescribeTableCommand = DescribeTableCommand;
 exports.DimensionValueType = DimensionValueType;
-exports.InternalServerException = InternalServerException;
-exports.InvalidEndpointException = InvalidEndpointException;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidEndpointException = InvalidEndpointException$1;
 exports.ListBatchLoadTasksCommand = ListBatchLoadTasksCommand;
 exports.ListDatabasesCommand = ListDatabasesCommand;
 exports.ListTablesCommand = ListTablesCommand;
@@ -1430,23 +1349,23 @@ exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.MeasureValueType = MeasureValueType;
 exports.PartitionKeyEnforcementLevel = PartitionKeyEnforcementLevel;
 exports.PartitionKeyType = PartitionKeyType;
-exports.RejectedRecordsException = RejectedRecordsException;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.RejectedRecordsException = RejectedRecordsException$1;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.ResumeBatchLoadTaskCommand = ResumeBatchLoadTaskCommand;
 exports.S3EncryptionOption = S3EncryptionOption;
 exports.ScalarMeasureValueType = ScalarMeasureValueType;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.TableStatus = TableStatus;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TimeUnit = TimeUnit;
 exports.TimestreamWrite = TimestreamWrite;
 exports.TimestreamWriteClient = TimestreamWriteClient;
-exports.TimestreamWriteServiceException = TimestreamWriteServiceException;
+exports.TimestreamWriteServiceException = TimestreamWriteServiceException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateDatabaseCommand = UpdateDatabaseCommand;
 exports.UpdateTableCommand = UpdateTableCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.WriteRecordsCommand = WriteRecordsCommand;
 exports.paginateListBatchLoadTasks = paginateListBatchLoadTasks;
 exports.paginateListDatabases = paginateListDatabases;