@aws-sdk/client-timestream-query 3.927.0 → 3.929.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 TimestreamQueryServiceException extends smithyClient.ServiceException {
+let TimestreamQueryServiceException$1 = class TimestreamQueryServiceException extends smithyClient.ServiceException {
     constructor(options) {
         super(options);
         Object.setPrototypeOf(this, TimestreamQueryServiceException.prototype);
     }
-}
+};
 
-class AccessDeniedException extends TimestreamQueryServiceException {
+let AccessDeniedException$1 = class AccessDeniedException extends TimestreamQueryServiceException$1 {
     name = "AccessDeniedException";
     $fault = "client";
     Message;
@@ -53,8 +51,8 @@ class AccessDeniedException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, AccessDeniedException.prototype);
         this.Message = opts.Message;
     }
-}
-class InternalServerException extends TimestreamQueryServiceException {
+};
+let InternalServerException$1 = class InternalServerException extends TimestreamQueryServiceException$1 {
     name = "InternalServerException";
     $fault = "server";
     Message;
@@ -67,8 +65,8 @@ class InternalServerException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, InternalServerException.prototype);
         this.Message = opts.Message;
     }
-}
-class InvalidEndpointException extends TimestreamQueryServiceException {
+};
+let InvalidEndpointException$1 = class InvalidEndpointException extends TimestreamQueryServiceException$1 {
     name = "InvalidEndpointException";
     $fault = "client";
     Message;
@@ -81,8 +79,8 @@ class InvalidEndpointException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, InvalidEndpointException.prototype);
         this.Message = opts.Message;
     }
-}
-class ThrottlingException extends TimestreamQueryServiceException {
+};
+let ThrottlingException$1 = class ThrottlingException extends TimestreamQueryServiceException$1 {
     name = "ThrottlingException";
     $fault = "client";
     Message;
@@ -95,8 +93,8 @@ class ThrottlingException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, ThrottlingException.prototype);
         this.Message = opts.Message;
     }
-}
-class ValidationException extends TimestreamQueryServiceException {
+};
+let ValidationException$1 = class ValidationException extends TimestreamQueryServiceException$1 {
     name = "ValidationException";
     $fault = "client";
     Message;
@@ -109,7 +107,7 @@ class ValidationException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, ValidationException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const ScalarType = {
     BIGINT: "BIGINT",
     BOOLEAN: "BOOLEAN",
@@ -127,7 +125,7 @@ const ComputeMode = {
     ON_DEMAND: "ON_DEMAND",
     PROVISIONED: "PROVISIONED",
 };
-class ConflictException extends TimestreamQueryServiceException {
+let ConflictException$1 = class ConflictException extends TimestreamQueryServiceException$1 {
     name = "ConflictException";
     $fault = "client";
     Message;
@@ -140,7 +138,7 @@ class ConflictException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, ConflictException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const S3EncryptionOption = {
     SSE_KMS: "SSE_KMS",
     SSE_S3: "SSE_S3",
@@ -162,7 +160,7 @@ const ScalarMeasureValueType = {
     TIMESTAMP: "TIMESTAMP",
     VARCHAR: "VARCHAR",
 };
-class ServiceQuotaExceededException extends TimestreamQueryServiceException {
+let ServiceQuotaExceededException$1 = class ServiceQuotaExceededException extends TimestreamQueryServiceException$1 {
     name = "ServiceQuotaExceededException";
     $fault = "client";
     Message;
@@ -175,8 +173,8 @@ class ServiceQuotaExceededException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
         this.Message = opts.Message;
     }
-}
-class ResourceNotFoundException extends TimestreamQueryServiceException {
+};
+let ResourceNotFoundException$1 = class ResourceNotFoundException extends TimestreamQueryServiceException$1 {
     name = "ResourceNotFoundException";
     $fault = "client";
     Message;
@@ -191,7 +189,7 @@ class ResourceNotFoundException extends TimestreamQueryServiceException {
         this.Message = opts.Message;
         this.ScheduledQueryArn = opts.ScheduledQueryArn;
     }
-}
+};
 const LastUpdateStatus = {
     FAILED: "FAILED",
     PENDING: "PENDING",
@@ -215,7 +213,7 @@ const ScheduledQueryInsightsMode = {
     DISABLED: "DISABLED",
     ENABLED_WITH_RATE_CONTROL: "ENABLED_WITH_RATE_CONTROL",
 };
-class QueryExecutionException extends TimestreamQueryServiceException {
+let QueryExecutionException$1 = class QueryExecutionException extends TimestreamQueryServiceException$1 {
     name = "QueryExecutionException";
     $fault = "client";
     Message;
@@ -228,740 +226,732 @@ class QueryExecutionException extends TimestreamQueryServiceException {
         Object.setPrototypeOf(this, QueryExecutionException.prototype);
         this.Message = opts.Message;
     }
-}
+};
 const QueryInsightsMode = {
     DISABLED: "DISABLED",
     ENABLED_WITH_RATE_CONTROL: "ENABLED_WITH_RATE_CONTROL",
 };
-const CreateScheduledQueryRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryString && { QueryString: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ClientToken && { ClientToken: smithyClient.SENSITIVE_STRING }),
-});
-const ScheduledQueryDescriptionFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryString && { QueryString: smithyClient.SENSITIVE_STRING }),
-});
-const DescribeScheduledQueryResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ScheduledQuery && { ScheduledQuery: ScheduledQueryDescriptionFilterSensitiveLog(obj.ScheduledQuery) }),
-});
-const ExecuteScheduledQueryRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.ClientToken && { ClientToken: smithyClient.SENSITIVE_STRING }),
-});
-const PrepareQueryRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryString && { QueryString: smithyClient.SENSITIVE_STRING }),
-});
-const QueryRequestFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryString && { QueryString: smithyClient.SENSITIVE_STRING }),
-    ...(obj.ClientToken && { ClientToken: smithyClient.SENSITIVE_STRING }),
-});
-const PrepareQueryResponseFilterSensitiveLog = (obj) => ({
-    ...obj,
-    ...(obj.QueryString && { QueryString: smithyClient.SENSITIVE_STRING }),
-});
 
-const se_CancelQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("CancelQuery");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_CreateScheduledQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("CreateScheduledQuery");
-    let body;
-    body = JSON.stringify(se_CreateScheduledQueryRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DeleteScheduledQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("DeleteScheduledQuery");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_DescribeAccountSettingsCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeAccountSettings");
-    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_DescribeScheduledQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("DescribeScheduledQuery");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ExecuteScheduledQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("ExecuteScheduledQuery");
-    let body;
-    body = JSON.stringify(se_ExecuteScheduledQueryRequest(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_ListScheduledQueriesCommand = async (input, context) => {
-    const headers = sharedHeaders("ListScheduledQueries");
-    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_PrepareQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("PrepareQuery");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_QueryCommand = async (input, context) => {
-    const headers = sharedHeaders("Query");
-    let body;
-    body = JSON.stringify(se_QueryRequest(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_UpdateAccountSettingsCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateAccountSettings");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const se_UpdateScheduledQueryCommand = async (input, context) => {
-    const headers = sharedHeaders("UpdateScheduledQuery");
-    let body;
-    body = JSON.stringify(smithyClient._json(input));
-    return buildHttpRpcRequest(context, headers, "/", undefined, body);
-};
-const de_CancelQueryCommand = 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_CreateScheduledQueryCommand = 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_DeleteScheduledQueryCommand = 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_DescribeAccountSettingsCommand = 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_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_DescribeScheduledQueryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_DescribeScheduledQueryResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_ExecuteScheduledQueryCommand = 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_ListScheduledQueriesCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_ListScheduledQueriesResponse(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_PrepareQueryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_PrepareQueryResponse(data);
-    const response = {
-        $metadata: deserializeMetadata(output),
-        ...contents,
-    };
-    return response;
-};
-const de_QueryCommand = async (output, context) => {
-    if (output.statusCode >= 300) {
-        return de_CommandError(output, context);
-    }
-    const data = await core.parseJsonBody(output.body, context);
-    let contents = {};
-    contents = de_QueryResponse(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_UpdateAccountSettingsCommand = 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_UpdateScheduledQueryCommand = 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_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.timestreamquery#AccessDeniedException":
-            throw await de_AccessDeniedExceptionRes(parsedOutput);
-        case "InternalServerException":
-        case "com.amazonaws.timestreamquery#InternalServerException":
-            throw await de_InternalServerExceptionRes(parsedOutput);
-        case "InvalidEndpointException":
-        case "com.amazonaws.timestreamquery#InvalidEndpointException":
-            throw await de_InvalidEndpointExceptionRes(parsedOutput);
-        case "ThrottlingException":
-        case "com.amazonaws.timestreamquery#ThrottlingException":
-            throw await de_ThrottlingExceptionRes(parsedOutput);
-        case "ValidationException":
-        case "com.amazonaws.timestreamquery#ValidationException":
-            throw await de_ValidationExceptionRes(parsedOutput);
-        case "ConflictException":
-        case "com.amazonaws.timestreamquery#ConflictException":
-            throw await de_ConflictExceptionRes(parsedOutput);
-        case "ServiceQuotaExceededException":
-        case "com.amazonaws.timestreamquery#ServiceQuotaExceededException":
-            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
-        case "ResourceNotFoundException":
-        case "com.amazonaws.timestreamquery#ResourceNotFoundException":
-            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
-        case "QueryExecutionException":
-        case "com.amazonaws.timestreamquery#QueryExecutionException":
-            throw await de_QueryExecutionExceptionRes(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_QueryExecutionExceptionRes = async (parsedOutput, context) => {
-    const body = parsedOutput.body;
-    const deserialized = smithyClient._json(body);
-    const exception = new QueryExecutionException({
-        $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_CreateScheduledQueryRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        ErrorReportConfiguration: smithyClient._json,
-        KmsKeyId: [],
-        Name: [],
-        NotificationConfiguration: smithyClient._json,
-        QueryString: [],
-        ScheduleConfiguration: smithyClient._json,
-        ScheduledQueryExecutionRoleArn: [],
-        Tags: smithyClient._json,
-        TargetConfiguration: smithyClient._json,
-    });
-};
-const se_ExecuteScheduledQueryRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        InvocationTime: (_) => _.getTime() / 1_000,
-        QueryInsights: smithyClient._json,
-        ScheduledQueryArn: [],
-    });
-};
-const se_QueryRequest = (input, context) => {
-    return smithyClient.take(input, {
-        ClientToken: [true, (_) => _ ?? uuid.v4()],
-        MaxRows: [],
-        NextToken: [],
-        QueryInsights: smithyClient._json,
-        QueryString: [],
-    });
-};
-const de_ColumnInfo = (output, context) => {
-    return smithyClient.take(output, {
-        Name: smithyClient.expectString,
-        Type: (_) => de_Type(_),
-    });
-};
-const de_ColumnInfoList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ColumnInfo(entry);
-    });
-    return retVal;
-};
-const de_Datum = (output, context) => {
-    return smithyClient.take(output, {
-        ArrayValue: (_) => de_DatumList(_),
-        NullValue: smithyClient.expectBoolean,
-        RowValue: (_) => de_Row(_),
-        ScalarValue: smithyClient.expectString,
-        TimeSeriesValue: (_) => de_TimeSeriesDataPointList(_),
-    });
-};
-const de_DatumList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Datum(entry);
-    });
-    return retVal;
-};
-const de_DescribeScheduledQueryResponse = (output, context) => {
-    return smithyClient.take(output, {
-        ScheduledQuery: (_) => de_ScheduledQueryDescription(_),
-    });
-};
-const de_ListScheduledQueriesResponse = (output, context) => {
-    return smithyClient.take(output, {
-        NextToken: smithyClient.expectString,
-        ScheduledQueries: (_) => de_ScheduledQueryList(_),
-    });
-};
-const de_ParameterMapping = (output, context) => {
-    return smithyClient.take(output, {
-        Name: smithyClient.expectString,
-        Type: (_) => de_Type(_),
-    });
-};
-const de_ParameterMappingList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ParameterMapping(entry);
-    });
-    return retVal;
-};
-const de_PrepareQueryResponse = (output, context) => {
-    return smithyClient.take(output, {
-        Columns: (_) => de_SelectColumnList(_),
-        Parameters: (_) => de_ParameterMappingList(_),
-        QueryString: smithyClient.expectString,
-    });
-};
-const de_QueryInsightsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        OutputBytes: smithyClient.expectLong,
-        OutputRows: smithyClient.expectLong,
-        QuerySpatialCoverage: (_) => de_QuerySpatialCoverage(_),
-        QueryTableCount: smithyClient.expectLong,
-        QueryTemporalRange: smithyClient._json,
-        UnloadPartitionCount: smithyClient.expectLong,
-        UnloadWrittenBytes: smithyClient.expectLong,
-        UnloadWrittenRows: smithyClient.expectLong,
-    });
-};
-const de_QueryResponse = (output, context) => {
-    return smithyClient.take(output, {
-        ColumnInfo: (_) => de_ColumnInfoList(_),
-        NextToken: smithyClient.expectString,
-        QueryId: smithyClient.expectString,
-        QueryInsightsResponse: (_) => de_QueryInsightsResponse(_),
-        QueryStatus: (_) => de_QueryStatus(_),
-        Rows: (_) => de_RowList(_),
-    });
-};
-const de_QuerySpatialCoverage = (output, context) => {
-    return smithyClient.take(output, {
-        Max: (_) => de_QuerySpatialCoverageMax(_),
-    });
-};
-const de_QuerySpatialCoverageMax = (output, context) => {
-    return smithyClient.take(output, {
-        PartitionKey: smithyClient._json,
-        TableArn: smithyClient.expectString,
-        Value: smithyClient.limitedParseDouble,
-    });
-};
-const de_QueryStatus = (output, context) => {
-    return smithyClient.take(output, {
-        CumulativeBytesMetered: smithyClient.expectLong,
-        CumulativeBytesScanned: smithyClient.expectLong,
-        ProgressPercentage: smithyClient.limitedParseDouble,
-    });
-};
-const de_Row = (output, context) => {
-    return smithyClient.take(output, {
-        Data: (_) => de_DatumList(_),
-    });
-};
-const de_RowList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_Row(entry);
-    });
-    return retVal;
-};
-const de_ScheduledQuery = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ErrorReportConfiguration: smithyClient._json,
-        LastRunStatus: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        NextInvocationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        PreviousInvocationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        State: smithyClient.expectString,
-        TargetDestination: smithyClient._json,
-    });
-};
-const de_ScheduledQueryDescription = (output, context) => {
-    return smithyClient.take(output, {
-        Arn: smithyClient.expectString,
-        CreationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        ErrorReportConfiguration: smithyClient._json,
-        KmsKeyId: smithyClient.expectString,
-        LastRunSummary: (_) => de_ScheduledQueryRunSummary(_),
-        Name: smithyClient.expectString,
-        NextInvocationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        NotificationConfiguration: smithyClient._json,
-        PreviousInvocationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        QueryString: smithyClient.expectString,
-        RecentlyFailedRuns: (_) => de_ScheduledQueryRunSummaryList(_),
-        ScheduleConfiguration: smithyClient._json,
-        ScheduledQueryExecutionRoleArn: smithyClient.expectString,
-        State: smithyClient.expectString,
-        TargetConfiguration: smithyClient._json,
-    });
-};
-const de_ScheduledQueryInsightsResponse = (output, context) => {
-    return smithyClient.take(output, {
-        OutputBytes: smithyClient.expectLong,
-        OutputRows: smithyClient.expectLong,
-        QuerySpatialCoverage: (_) => de_QuerySpatialCoverage(_),
-        QueryTableCount: smithyClient.expectLong,
-        QueryTemporalRange: smithyClient._json,
-    });
-};
-const de_ScheduledQueryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScheduledQuery(entry);
-    });
-    return retVal;
-};
-const de_ScheduledQueryRunSummary = (output, context) => {
-    return smithyClient.take(output, {
-        ErrorReportLocation: smithyClient._json,
-        ExecutionStats: smithyClient._json,
-        FailureReason: smithyClient.expectString,
-        InvocationTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-        QueryInsightsResponse: (_) => de_ScheduledQueryInsightsResponse(_),
-        RunStatus: smithyClient.expectString,
-        TriggerTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
-    });
-};
-const de_ScheduledQueryRunSummaryList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_ScheduledQueryRunSummary(entry);
-    });
-    return retVal;
-};
-const de_SelectColumn = (output, context) => {
-    return smithyClient.take(output, {
-        Aliased: smithyClient.expectBoolean,
-        DatabaseName: smithyClient.expectString,
-        Name: smithyClient.expectString,
-        TableName: smithyClient.expectString,
-        Type: (_) => de_Type(_),
-    });
-};
-const de_SelectColumnList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_SelectColumn(entry);
-    });
-    return retVal;
-};
-const de_TimeSeriesDataPoint = (output, context) => {
-    return smithyClient.take(output, {
-        Time: smithyClient.expectString,
-        Value: (_) => de_Datum(_),
-    });
-};
-const de_TimeSeriesDataPointList = (output, context) => {
-    const retVal = (output || [])
-        .filter((e) => e != null)
-        .map((entry) => {
-        return de_TimeSeriesDataPoint(entry);
-    });
-    return retVal;
-};
-const de_Type = (output, context) => {
-    return smithyClient.take(output, {
-        ArrayColumnInfo: (_) => de_ColumnInfo(_),
-        RowColumnInfo: (_) => de_ColumnInfoList(_),
-        ScalarType: smithyClient.expectString,
-        TimeSeriesMeasureValueColumnInfo: (_) => de_ColumnInfo(_),
-    });
-};
-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(TimestreamQueryServiceException);
-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 _ACI = "ArrayColumnInfo";
+const _ADE = "AccessDeniedException";
+const _AQTCU = "ActiveQueryTCU";
+const _ASNC = "AccountSettingsNotificationConfiguration";
+const _AV = "ArrayValue";
+const _Ad = "Address";
+const _Al = "Aliased";
+const _BM = "BytesMetered";
+const _BN = "BucketName";
+const _C = "Columns";
+const _CBM = "CumulativeBytesMetered";
+const _CBS = "CumulativeBytesScanned";
+const _CE = "ConflictException";
+const _CI = "ColumnInfo";
+const _CIL = "ColumnInfoList";
+const _CM = "CancellationMessage";
+const _CMo = "ComputeMode";
+const _CPIM = "CachePeriodInMinutes";
+const _CQ = "CancelQuery";
+const _CQR = "CancelQueryRequest";
+const _CQRa = "CancelQueryResponse";
+const _CRT = "ClientRequestToken";
+const _CSQ = "CreateScheduledQuery";
+const _CSQR = "CreateScheduledQueryRequest";
+const _CSQRr = "CreateScheduledQueryResponse";
+const _CT = "ClientToken";
+const _CTr = "CreationTime";
+const _D = "Datum";
+const _DAS = "DescribeAccountSettings";
+const _DASR = "DescribeAccountSettingsRequest";
+const _DASRe = "DescribeAccountSettingsResponse";
+const _DE = "DescribeEndpoints";
+const _DER = "DescribeEndpointsRequest";
+const _DERe = "DescribeEndpointsResponse";
+const _DL = "DatumList";
+const _DM = "DimensionMapping";
+const _DML = "DimensionMappingList";
+const _DMi = "DimensionMappings";
+const _DN = "DatabaseName";
+const _DSQ = "DeleteScheduledQuery";
+const _DSQR = "DeleteScheduledQueryRequest";
+const _DSQRe = "DescribeScheduledQueryRequest";
+const _DSQRes = "DescribeScheduledQueryResponse";
+const _DSQe = "DescribeScheduledQuery";
+const _DVT = "DimensionValueType";
+const _DW = "DataWrites";
+const _Da = "Data";
+const _E = "Endpoints";
+const _EO = "EncryptionOption";
+const _ERC = "ErrorReportConfiguration";
+const _ERL = "ErrorReportLocation";
+const _ES = "ExecutionStats";
+const _ESQ = "ExecuteScheduledQuery";
+const _ESQR = "ExecuteScheduledQueryRequest";
+const _ETIM = "ExecutionTimeInMillis";
+const _En = "Endpoint";
+const _FR = "FailureReason";
+const _IEE = "InvalidEndpointException";
+const _ISE = "InternalServerException";
+const _IT = "InvocationTime";
+const _K = "Key";
+const _KKI = "KmsKeyId";
+const _LRS = "LastRunStatus";
+const _LRSa = "LastRunSummary";
+const _LSQ = "ListScheduledQueries";
+const _LSQR = "ListScheduledQueriesRequest";
+const _LSQRi = "ListScheduledQueriesResponse";
+const _LTFR = "ListTagsForResource";
+const _LTFRR = "ListTagsForResourceRequest";
+const _LTFRRi = "ListTagsForResourceResponse";
+const _LU = "LastUpdate";
+const _M = "Message";
+const _MMAM = "MultiMeasureAttributeMappings";
+const _MMAML = "MultiMeasureAttributeMappingList";
+const _MMAMu = "MultiMeasureAttributeMapping";
+const _MMM = "MixedMeasureMapping";
+const _MMML = "MixedMeasureMappingList";
+const _MMMi = "MixedMeasureMappings";
+const _MMMu = "MultiMeasureMappings";
+const _MN = "MeasureName";
+const _MNC = "MeasureNameColumn";
+const _MQTCU = "MaxQueryTCU";
+const _MR = "MaxResults";
+const _MRa = "MaxRows";
+const _MVT = "MeasureValueType";
+const _Ma = "Max";
+const _Mo = "Mode";
+const _N = "Name";
+const _NC = "NotificationConfiguration";
+const _NIT = "NextInvocationTime";
+const _NT = "NextToken";
+const _NV = "NullValue";
+const _OB = "OutputBytes";
+const _OK = "ObjectKey";
+const _OKP = "ObjectKeyPrefix";
+const _OR = "OutputRows";
+const _P = "Parameters";
+const _PC = "ProvisionedCapacity";
+const _PCR = "ProvisionedCapacityRequest";
+const _PCRr = "ProvisionedCapacityResponse";
+const _PIT = "PreviousInvocationTime";
+const _PK = "PartitionKey";
+const _PM = "ParameterMapping";
+const _PML = "ParameterMappingList";
+const _PP = "ProgressPercentage";
+const _PQ = "PrepareQuery";
+const _PQR = "PrepareQueryRequest";
+const _PQRr = "PrepareQueryResponse";
+const _Q = "Query";
+const _QC = "QueryCompute";
+const _QCR = "QueryComputeRequest";
+const _QCRu = "QueryComputeResponse";
+const _QEE = "QueryExecutionException";
+const _QI = "QueryId";
+const _QIR = "QueryInsightsResponse";
+const _QIu = "QueryInsights";
+const _QPM = "QueryPricingModel";
+const _QR = "QueryRequest";
+const _QRR = "QueryResultRows";
+const _QRu = "QueryResponse";
+const _QS = "QueryString";
+const _QSC = "QuerySpatialCoverage";
+const _QSCM = "QuerySpatialCoverageMax";
+const _QSu = "QueryStatus";
+const _QTC = "QueryTableCount";
+const _QTR = "QueryTemporalRange";
+const _QTRM = "QueryTemporalRangeMax";
+const _R = "Rows";
+const _RA = "RoleArn";
+const _RARN = "ResourceARN";
+const _RCI = "RowColumnInfo";
+const _RFR = "RecentlyFailedRuns";
+const _RI = "RecordsIngested";
+const _RL = "RowList";
+const _RNFE = "ResourceNotFoundException";
+const _RS = "RunStatus";
+const _RV = "RowValue";
+const _Ro = "Row";
+const _S = "Status";
+const _SC = "SnsConfiguration";
+const _SCL = "SelectColumnList";
+const _SCc = "ScheduleConfiguration";
+const _SCe = "SelectColumn";
+const _SCo = "S3Configuration";
+const _SCou = "SourceColumn";
+const _SE = "ScheduleExpression";
+const _SM = "StatusMessage";
+const _SQ = "ScheduledQuery";
+const _SQA = "ScheduledQueryArn";
+const _SQD = "ScheduledQueryDescription";
+const _SQEE = "ServiceQuotaExceededException";
+const _SQERA = "ScheduledQueryExecutionRoleArn";
+const _SQI = "ScheduledQueryInsights";
+const _SQIR = "ScheduledQueryInsightsResponse";
+const _SQL = "ScheduledQueryList";
+const _SQRS = "ScheduledQueryRunSummary";
+const _SQRSL = "ScheduledQueryRunSummaryList";
+const _SQc = "ScheduledQueries";
+const _SRL = "S3ReportLocation";
+const _ST = "ScalarType";
+const _SV = "ScalarValue";
+const _St = "State";
+const _T = "Type";
+const _TA = "TableArn";
+const _TAo = "TopicArn";
+const _TC = "TargetConfiguration";
+const _TCi = "TimestreamConfiguration";
+const _TCim = "TimeColumn";
+const _TD = "TargetDestination";
+const _TDi = "TimestreamDestination";
+const _TE = "ThrottlingException";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TMMAN = "TargetMultiMeasureAttributeName";
+const _TMMN = "TargetMultiMeasureName";
+const _TMN = "TargetMeasureName";
+const _TN = "TableName";
+const _TQTCU = "TargetQueryTCU";
+const _TR = "TagResource";
+const _TRR = "TagResourceRequest";
+const _TRRa = "TagResourceResponse";
+const _TSDP = "TimeSeriesDataPoint";
+const _TSDPL = "TimeSeriesDataPointList";
+const _TSMVCI = "TimeSeriesMeasureValueColumnInfo";
+const _TSV = "TimeSeriesValue";
+const _TT = "TriggerTime";
+const _Ta = "Tags";
+const _Tag = "Tag";
+const _Ti = "Time";
+const _UAS = "UpdateAccountSettings";
+const _UASR = "UpdateAccountSettingsRequest";
+const _UASRp = "UpdateAccountSettingsResponse";
+const _UPC = "UnloadPartitionCount";
+const _UR = "UntagResource";
+const _URR = "UntagResourceRequest";
+const _URRn = "UntagResourceResponse";
+const _USQ = "UpdateScheduledQuery";
+const _USQR = "UpdateScheduledQueryRequest";
+const _UWB = "UnloadWrittenBytes";
+const _UWR = "UnloadWrittenRows";
+const _V = "Value";
+const _VE = "ValidationException";
+const _VO = "ValidateOnly";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _e = "error";
+const _hE = "httpError";
+const _s = "server";
+const _sm = "smithy.ts.sdk.synthetic.com.amazonaws.timestreamquery";
+const n0 = "com.amazonaws.timestreamquery";
+var ClientRequestToken = [0, n0, _CRT, 8, 0];
+var ClientToken = [0, n0, _CT, 8, 0];
+var QueryString = [0, n0, _QS, 8, 0];
+var AccessDeniedException = [
+    -3,
+    n0,
+    _ADE,
+    {
+        [_e]: _c,
+        [_hE]: 403,
+        [_aQE]: [`AccessDenied`, 403],
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(AccessDeniedException, AccessDeniedException$1);
+var AccountSettingsNotificationConfiguration = [
+    3,
+    n0,
+    _ASNC,
+    0,
+    [_SC, _RA],
+    [() => SnsConfiguration, 0],
+];
+var CancelQueryRequest = [3, n0, _CQR, 0, [_QI], [0]];
+var CancelQueryResponse = [3, n0, _CQRa, 0, [_CM], [0]];
+var ColumnInfo = [3, n0, _CI, 0, [_N, _T], [0, () => Type]];
+var ConflictException = [
+    -3,
+    n0,
+    _CE,
+    {
+        [_e]: _c,
+        [_hE]: 409,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ConflictException, ConflictException$1);
+var CreateScheduledQueryRequest = [
+    3,
+    n0,
+    _CSQR,
+    0,
+    [_N, _QS, _SCc, _NC, _TC, _CT, _SQERA, _Ta, _KKI, _ERC],
+    [
+        0,
+        [() => QueryString, 0],
+        () => ScheduleConfiguration,
+        () => NotificationConfiguration,
+        () => TargetConfiguration,
+        [() => ClientToken, 4],
+        0,
+        () => TagList,
+        0,
+        () => ErrorReportConfiguration,
+    ],
+];
+var CreateScheduledQueryResponse = [3, n0, _CSQRr, 0, [_A], [0]];
+var Datum = [
+    3,
+    n0,
+    _D,
+    0,
+    [_SV, _TSV, _AV, _RV, _NV],
+    [0, () => TimeSeriesDataPointList, () => DatumList, () => Row, 2],
+];
+var DeleteScheduledQueryRequest = [3, n0, _DSQR, 0, [_SQA], [0]];
+var DescribeAccountSettingsRequest = [3, n0, _DASR, 0, [], []];
+var DescribeAccountSettingsResponse = [
+    3,
+    n0,
+    _DASRe,
+    0,
+    [_MQTCU, _QPM, _QC],
+    [1, 0, () => QueryComputeResponse],
+];
+var DescribeEndpointsRequest = [3, n0, _DER, 0, [], []];
+var DescribeEndpointsResponse = [3, n0, _DERe, 0, [_E], [() => Endpoints]];
+var DescribeScheduledQueryRequest = [3, n0, _DSQRe, 0, [_SQA], [0]];
+var DescribeScheduledQueryResponse = [
+    3,
+    n0,
+    _DSQRes,
+    0,
+    [_SQ],
+    [[() => ScheduledQueryDescription, 0]],
+];
+var DimensionMapping = [3, n0, _DM, 0, [_N, _DVT], [0, 0]];
+var Endpoint = [3, n0, _En, 0, [_Ad, _CPIM], [0, 1]];
+var ErrorReportConfiguration = [3, n0, _ERC, 0, [_SCo], [() => S3Configuration]];
+var ErrorReportLocation = [3, n0, _ERL, 0, [_SRL], [() => S3ReportLocation]];
+var ExecuteScheduledQueryRequest = [
+    3,
+    n0,
+    _ESQR,
+    0,
+    [_SQA, _IT, _CT, _QIu],
+    [0, 4, [() => ClientToken, 4], () => ScheduledQueryInsights],
+];
+var ExecutionStats = [
+    3,
+    n0,
+    _ES,
+    0,
+    [_ETIM, _DW, _BM, _CBS, _RI, _QRR],
+    [1, 1, 1, 1, 1, 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 LastUpdate = [3, n0, _LU, 0, [_TQTCU, _S, _SM], [1, 0, 0]];
+var ListScheduledQueriesRequest = [3, n0, _LSQR, 0, [_MR, _NT], [1, 0]];
+var ListScheduledQueriesResponse = [
+    3,
+    n0,
+    _LSQRi,
+    0,
+    [_SQc, _NT],
+    [() => ScheduledQueryList, 0],
+];
+var ListTagsForResourceRequest = [3, n0, _LTFRR, 0, [_RARN, _MR, _NT], [0, 1, 0]];
+var ListTagsForResourceResponse = [3, n0, _LTFRRi, 0, [_Ta, _NT], [() => TagList, 0]];
+var MixedMeasureMapping = [
+    3,
+    n0,
+    _MMM,
+    0,
+    [_MN, _SCou, _TMN, _MVT, _MMAM],
+    [0, 0, 0, 0, () => MultiMeasureAttributeMappingList],
+];
+var MultiMeasureAttributeMapping = [3, n0, _MMAMu, 0, [_SCou, _TMMAN, _MVT], [0, 0, 0]];
+var MultiMeasureMappings = [
+    3,
+    n0,
+    _MMMu,
+    0,
+    [_TMMN, _MMAM],
+    [0, () => MultiMeasureAttributeMappingList],
+];
+var NotificationConfiguration = [3, n0, _NC, 0, [_SC], [() => SnsConfiguration]];
+var ParameterMapping = [3, n0, _PM, 0, [_N, _T], [0, () => Type]];
+var PrepareQueryRequest = [3, n0, _PQR, 0, [_QS, _VO], [[() => QueryString, 0], 2]];
+var PrepareQueryResponse = [
+    3,
+    n0,
+    _PQRr,
+    0,
+    [_QS, _C, _P],
+    [[() => QueryString, 0], () => SelectColumnList, () => ParameterMappingList],
+];
+var ProvisionedCapacityRequest = [
+    3,
+    n0,
+    _PCR,
+    0,
+    [_TQTCU, _NC],
+    [1, () => AccountSettingsNotificationConfiguration],
+];
+var ProvisionedCapacityResponse = [
+    3,
+    n0,
+    _PCRr,
+    0,
+    [_AQTCU, _NC, _LU],
+    [1, () => AccountSettingsNotificationConfiguration, () => LastUpdate],
+];
+var QueryComputeRequest = [
+    3,
+    n0,
+    _QCR,
+    0,
+    [_CMo, _PC],
+    [0, () => ProvisionedCapacityRequest],
+];
+var QueryComputeResponse = [
+    3,
+    n0,
+    _QCRu,
+    0,
+    [_CMo, _PC],
+    [0, () => ProvisionedCapacityResponse],
+];
+var QueryExecutionException = [
+    -3,
+    n0,
+    _QEE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(QueryExecutionException, QueryExecutionException$1);
+var QueryInsights = [3, n0, _QIu, 0, [_Mo], [0]];
+var QueryInsightsResponse = [
+    3,
+    n0,
+    _QIR,
+    0,
+    [_QSC, _QTR, _QTC, _OR, _OB, _UPC, _UWR, _UWB],
+    [() => QuerySpatialCoverage, () => QueryTemporalRange, 1, 1, 1, 1, 1, 1],
+];
+var QueryRequest = [
+    3,
+    n0,
+    _QR,
+    0,
+    [_QS, _CT, _NT, _MRa, _QIu],
+    [[() => QueryString, 0], [() => ClientRequestToken, 4], 0, 1, () => QueryInsights],
+];
+var QueryResponse = [
+    3,
+    n0,
+    _QRu,
+    0,
+    [_QI, _NT, _R, _CI, _QSu, _QIR],
+    [0, 0, () => RowList, () => ColumnInfoList, () => QueryStatus, () => QueryInsightsResponse],
+];
+var QuerySpatialCoverage = [3, n0, _QSC, 0, [_Ma], [() => QuerySpatialCoverageMax]];
+var QuerySpatialCoverageMax = [3, n0, _QSCM, 0, [_V, _TA, _PK], [1, 0, 64 | 0]];
+var QueryStatus = [3, n0, _QSu, 0, [_PP, _CBS, _CBM], [1, 1, 1]];
+var QueryTemporalRange = [3, n0, _QTR, 0, [_Ma], [() => QueryTemporalRangeMax]];
+var QueryTemporalRangeMax = [3, n0, _QTRM, 0, [_V, _TA], [1, 0]];
+var ResourceNotFoundException = [
+    -3,
+    n0,
+    _RNFE,
+    {
+        [_e]: _c,
+        [_hE]: 404,
+    },
+    [_M, _SQA],
+    [0, 0],
+];
+schema.TypeRegistry.for(n0).registerError(ResourceNotFoundException, ResourceNotFoundException$1);
+var Row = [3, n0, _Ro, 0, [_Da], [() => DatumList]];
+var S3Configuration = [3, n0, _SCo, 0, [_BN, _OKP, _EO], [0, 0, 0]];
+var S3ReportLocation = [3, n0, _SRL, 0, [_BN, _OK], [0, 0]];
+var ScheduleConfiguration = [3, n0, _SCc, 0, [_SE], [0]];
+var ScheduledQuery = [
+    3,
+    n0,
+    _SQ,
+    0,
+    [_A, _N, _CTr, _St, _PIT, _NIT, _ERC, _TD, _LRS],
+    [0, 0, 4, 0, 4, 4, () => ErrorReportConfiguration, () => TargetDestination, 0],
+];
+var ScheduledQueryDescription = [
+    3,
+    n0,
+    _SQD,
+    0,
+    [_A, _N, _QS, _CTr, _St, _PIT, _NIT, _SCc, _NC, _TC, _SQERA, _KKI, _ERC, _LRSa, _RFR],
+    [
+        0,
+        0,
+        [() => QueryString, 0],
+        4,
+        0,
+        4,
+        4,
+        () => ScheduleConfiguration,
+        () => NotificationConfiguration,
+        () => TargetConfiguration,
+        0,
+        0,
+        () => ErrorReportConfiguration,
+        () => ScheduledQueryRunSummary,
+        () => ScheduledQueryRunSummaryList,
+    ],
+];
+var ScheduledQueryInsights = [3, n0, _SQI, 0, [_Mo], [0]];
+var ScheduledQueryInsightsResponse = [
+    3,
+    n0,
+    _SQIR,
+    0,
+    [_QSC, _QTR, _QTC, _OR, _OB],
+    [() => QuerySpatialCoverage, () => QueryTemporalRange, 1, 1, 1],
+];
+var ScheduledQueryRunSummary = [
+    3,
+    n0,
+    _SQRS,
+    0,
+    [_IT, _TT, _RS, _ES, _QIR, _ERL, _FR],
+    [4, 4, 0, () => ExecutionStats, () => ScheduledQueryInsightsResponse, () => ErrorReportLocation, 0],
+];
+var SelectColumn = [3, n0, _SCe, 0, [_N, _T, _DN, _TN, _Al], [0, () => Type, 0, 0, 2]];
+var ServiceQuotaExceededException = [
+    -3,
+    n0,
+    _SQEE,
+    {
+        [_e]: _c,
+        [_hE]: 402,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ServiceQuotaExceededException, ServiceQuotaExceededException$1);
+var SnsConfiguration = [3, n0, _SC, 0, [_TAo], [0]];
+var Tag = [3, n0, _Tag, 0, [_K, _V], [0, 0]];
+var TagResourceRequest = [3, n0, _TRR, 0, [_RARN, _Ta], [0, () => TagList]];
+var TagResourceResponse = [3, n0, _TRRa, 0, [], []];
+var TargetConfiguration = [3, n0, _TC, 0, [_TCi], [() => TimestreamConfiguration]];
+var TargetDestination = [3, n0, _TD, 0, [_TDi], [() => TimestreamDestination]];
+var ThrottlingException = [
+    -3,
+    n0,
+    _TE,
+    {
+        [_e]: _c,
+        [_hE]: 429,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ThrottlingException, ThrottlingException$1);
+var TimeSeriesDataPoint = [3, n0, _TSDP, 0, [_Ti, _V], [0, () => Datum]];
+var TimestreamConfiguration = [
+    3,
+    n0,
+    _TCi,
+    0,
+    [_DN, _TN, _TCim, _DMi, _MMMu, _MMMi, _MNC],
+    [0, 0, 0, () => DimensionMappingList, () => MultiMeasureMappings, () => MixedMeasureMappingList, 0],
+];
+var TimestreamDestination = [3, n0, _TDi, 0, [_DN, _TN], [0, 0]];
+var Type = [
+    3,
+    n0,
+    _T,
+    0,
+    [_ST, _ACI, _TSMVCI, _RCI],
+    [0, () => ColumnInfo, () => ColumnInfo, () => ColumnInfoList],
+];
+var UntagResourceRequest = [3, n0, _URR, 0, [_RARN, _TK], [0, 64 | 0]];
+var UntagResourceResponse = [3, n0, _URRn, 0, [], []];
+var UpdateAccountSettingsRequest = [
+    3,
+    n0,
+    _UASR,
+    0,
+    [_MQTCU, _QPM, _QC],
+    [1, 0, () => QueryComputeRequest],
+];
+var UpdateAccountSettingsResponse = [
+    3,
+    n0,
+    _UASRp,
+    0,
+    [_MQTCU, _QPM, _QC],
+    [1, 0, () => QueryComputeResponse],
+];
+var UpdateScheduledQueryRequest = [3, n0, _USQR, 0, [_SQA, _St], [0, 0]];
+var ValidationException = [
+    -3,
+    n0,
+    _VE,
+    {
+        [_e]: _c,
+        [_hE]: 400,
+    },
+    [_M],
+    [0],
+];
+schema.TypeRegistry.for(n0).registerError(ValidationException, ValidationException$1);
+var __Unit = "unit";
+var TimestreamQueryServiceException = [-3, _sm, "TimestreamQueryServiceException", 0, [], []];
+schema.TypeRegistry.for(_sm).registerError(TimestreamQueryServiceException, TimestreamQueryServiceException$1);
+var ColumnInfoList = [1, n0, _CIL, 0, () => ColumnInfo];
+var DatumList = [1, n0, _DL, 0, () => Datum];
+var DimensionMappingList = [1, n0, _DML, 0, () => DimensionMapping];
+var Endpoints = [1, n0, _E, 0, () => Endpoint];
+var MixedMeasureMappingList = [1, n0, _MMML, 0, () => MixedMeasureMapping];
+var MultiMeasureAttributeMappingList = [1, n0, _MMAML, 0, () => MultiMeasureAttributeMapping];
+var ParameterMappingList = [1, n0, _PML, 0, () => ParameterMapping];
+var RowList = [1, n0, _RL, 0, () => Row];
+var ScheduledQueryList = [1, n0, _SQL, 0, () => ScheduledQuery];
+var ScheduledQueryRunSummaryList = [1, n0, _SQRSL, 0, () => ScheduledQueryRunSummary];
+var SelectColumnList = [1, n0, _SCL, 0, () => SelectColumn];
+var TagList = [1, n0, _TL, 0, () => Tag];
+var TimeSeriesDataPointList = [1, n0, _TSDPL, 0, () => TimeSeriesDataPoint];
+var CancelQuery = [9, n0, _CQ, 2, () => CancelQueryRequest, () => CancelQueryResponse];
+var CreateScheduledQuery = [
+    9,
+    n0,
+    _CSQ,
+    2,
+    () => CreateScheduledQueryRequest,
+    () => CreateScheduledQueryResponse,
+];
+var DeleteScheduledQuery = [
+    9,
+    n0,
+    _DSQ,
+    2,
+    () => DeleteScheduledQueryRequest,
+    () => __Unit,
+];
+var DescribeAccountSettings = [
+    9,
+    n0,
+    _DAS,
+    0,
+    () => DescribeAccountSettingsRequest,
+    () => DescribeAccountSettingsResponse,
+];
+var DescribeEndpoints = [
+    9,
+    n0,
+    _DE,
+    0,
+    () => DescribeEndpointsRequest,
+    () => DescribeEndpointsResponse,
+];
+var DescribeScheduledQuery = [
+    9,
+    n0,
+    _DSQe,
+    0,
+    () => DescribeScheduledQueryRequest,
+    () => DescribeScheduledQueryResponse,
+];
+var ExecuteScheduledQuery = [
+    9,
+    n0,
+    _ESQ,
+    2,
+    () => ExecuteScheduledQueryRequest,
+    () => __Unit,
+];
+var ListScheduledQueries = [
+    9,
+    n0,
+    _LSQ,
+    0,
+    () => ListScheduledQueriesRequest,
+    () => ListScheduledQueriesResponse,
+];
+var ListTagsForResource = [
+    9,
+    n0,
+    _LTFR,
+    0,
+    () => ListTagsForResourceRequest,
+    () => ListTagsForResourceResponse,
+];
+var PrepareQuery = [9, n0, _PQ, 2, () => PrepareQueryRequest, () => PrepareQueryResponse];
+var Query = [9, n0, _Q, 2, () => QueryRequest, () => QueryResponse];
+var TagResource = [9, n0, _TR, 0, () => TagResourceRequest, () => TagResourceResponse];
+var UntagResource = [
+    9,
+    n0,
+    _UR,
+    0,
+    () => UntagResourceRequest,
+    () => UntagResourceResponse,
+];
+var UpdateAccountSettings = [
+    9,
+    n0,
+    _UAS,
+    2,
+    () => UpdateAccountSettingsRequest,
+    () => UpdateAccountSettingsResponse,
+];
+var UpdateScheduledQuery = [
+    9,
+    n0,
+    _USQ,
+    0,
+    () => UpdateScheduledQueryRequest,
+    () => __Unit,
+];
 
 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("TimestreamQueryClient", "DescribeEndpointsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeEndpointsCommand)
-    .de(de_DescribeEndpointsCommand)
+    .sc(DescribeEndpoints)
     .build() {
 }
 
@@ -1028,19 +1018,20 @@ class TimestreamQueryClient 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.defaultTimestreamQueryHttpAuthSchemeParametersProvider,
-            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();
@@ -1052,7 +1043,6 @@ class CancelQueryCommand 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,
@@ -1063,9 +1053,7 @@ class CancelQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "CancelQuery", {})
     .n("TimestreamQueryClient", "CancelQueryCommand")
-    .f(void 0, void 0)
-    .ser(se_CancelQueryCommand)
-    .de(de_CancelQueryCommand)
+    .sc(CancelQuery)
     .build() {
 }
 
@@ -1074,7 +1062,6 @@ class CreateScheduledQueryCommand 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,
@@ -1085,9 +1072,7 @@ class CreateScheduledQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "CreateScheduledQuery", {})
     .n("TimestreamQueryClient", "CreateScheduledQueryCommand")
-    .f(CreateScheduledQueryRequestFilterSensitiveLog, void 0)
-    .ser(se_CreateScheduledQueryCommand)
-    .de(de_CreateScheduledQueryCommand)
+    .sc(CreateScheduledQuery)
     .build() {
 }
 
@@ -1096,7 +1081,6 @@ class DeleteScheduledQueryCommand 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,
@@ -1107,9 +1091,7 @@ class DeleteScheduledQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DeleteScheduledQuery", {})
     .n("TimestreamQueryClient", "DeleteScheduledQueryCommand")
-    .f(void 0, void 0)
-    .ser(se_DeleteScheduledQueryCommand)
-    .de(de_DeleteScheduledQueryCommand)
+    .sc(DeleteScheduledQuery)
     .build() {
 }
 
@@ -1118,7 +1100,6 @@ class DescribeAccountSettingsCommand 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,
@@ -1129,9 +1110,7 @@ class DescribeAccountSettingsCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DescribeAccountSettings", {})
     .n("TimestreamQueryClient", "DescribeAccountSettingsCommand")
-    .f(void 0, void 0)
-    .ser(se_DescribeAccountSettingsCommand)
-    .de(de_DescribeAccountSettingsCommand)
+    .sc(DescribeAccountSettings)
     .build() {
 }
 
@@ -1140,7 +1119,6 @@ class DescribeScheduledQueryCommand 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,
@@ -1151,9 +1129,7 @@ class DescribeScheduledQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "DescribeScheduledQuery", {})
     .n("TimestreamQueryClient", "DescribeScheduledQueryCommand")
-    .f(void 0, DescribeScheduledQueryResponseFilterSensitiveLog)
-    .ser(se_DescribeScheduledQueryCommand)
-    .de(de_DescribeScheduledQueryCommand)
+    .sc(DescribeScheduledQuery)
     .build() {
 }
 
@@ -1162,7 +1138,6 @@ class ExecuteScheduledQueryCommand 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,
@@ -1173,9 +1148,7 @@ class ExecuteScheduledQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ExecuteScheduledQuery", {})
     .n("TimestreamQueryClient", "ExecuteScheduledQueryCommand")
-    .f(ExecuteScheduledQueryRequestFilterSensitiveLog, void 0)
-    .ser(se_ExecuteScheduledQueryCommand)
-    .de(de_ExecuteScheduledQueryCommand)
+    .sc(ExecuteScheduledQuery)
     .build() {
 }
 
@@ -1184,7 +1157,6 @@ class ListScheduledQueriesCommand 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,
@@ -1195,9 +1167,7 @@ class ListScheduledQueriesCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListScheduledQueries", {})
     .n("TimestreamQueryClient", "ListScheduledQueriesCommand")
-    .f(void 0, void 0)
-    .ser(se_ListScheduledQueriesCommand)
-    .de(de_ListScheduledQueriesCommand)
+    .sc(ListScheduledQueries)
     .build() {
 }
 
@@ -1206,7 +1176,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,
@@ -1217,9 +1186,7 @@ class ListTagsForResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "ListTagsForResource", {})
     .n("TimestreamQueryClient", "ListTagsForResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_ListTagsForResourceCommand)
-    .de(de_ListTagsForResourceCommand)
+    .sc(ListTagsForResource)
     .build() {
 }
 
@@ -1228,7 +1195,6 @@ class PrepareQueryCommand 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,
@@ -1239,9 +1205,7 @@ class PrepareQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "PrepareQuery", {})
     .n("TimestreamQueryClient", "PrepareQueryCommand")
-    .f(PrepareQueryRequestFilterSensitiveLog, PrepareQueryResponseFilterSensitiveLog)
-    .ser(se_PrepareQueryCommand)
-    .de(de_PrepareQueryCommand)
+    .sc(PrepareQuery)
     .build() {
 }
 
@@ -1250,7 +1214,6 @@ class QueryCommand 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,
@@ -1261,9 +1224,7 @@ class QueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "Query", {})
     .n("TimestreamQueryClient", "QueryCommand")
-    .f(QueryRequestFilterSensitiveLog, void 0)
-    .ser(se_QueryCommand)
-    .de(de_QueryCommand)
+    .sc(Query)
     .build() {
 }
 
@@ -1272,7 +1233,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,
@@ -1283,9 +1243,7 @@ class TagResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "TagResource", {})
     .n("TimestreamQueryClient", "TagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_TagResourceCommand)
-    .de(de_TagResourceCommand)
+    .sc(TagResource)
     .build() {
 }
 
@@ -1294,7 +1252,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,
@@ -1305,9 +1262,7 @@ class UntagResourceCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UntagResource", {})
     .n("TimestreamQueryClient", "UntagResourceCommand")
-    .f(void 0, void 0)
-    .ser(se_UntagResourceCommand)
-    .de(de_UntagResourceCommand)
+    .sc(UntagResource)
     .build() {
 }
 
@@ -1316,7 +1271,6 @@ class UpdateAccountSettingsCommand 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,
@@ -1327,9 +1281,7 @@ class UpdateAccountSettingsCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UpdateAccountSettings", {})
     .n("TimestreamQueryClient", "UpdateAccountSettingsCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateAccountSettingsCommand)
-    .de(de_UpdateAccountSettingsCommand)
+    .sc(UpdateAccountSettings)
     .build() {
 }
 
@@ -1338,7 +1290,6 @@ class UpdateScheduledQueryCommand 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,
@@ -1349,9 +1300,7 @@ class UpdateScheduledQueryCommand extends smithyClient.Command
 })
     .s("Timestream_20181101", "UpdateScheduledQuery", {})
     .n("TimestreamQueryClient", "UpdateScheduledQueryCommand")
-    .f(void 0, void 0)
-    .ser(se_UpdateScheduledQueryCommand)
-    .de(de_UpdateScheduledQueryCommand)
+    .sc(UpdateScheduledQuery)
     .build() {
 }
 
@@ -1376,11 +1325,11 @@ class TimestreamQuery extends TimestreamQueryClient {
 }
 smithyClient.createAggregatedClient(commands, TimestreamQuery);
 
-const paginateListScheduledQueries = core$1.createPaginator(TimestreamQueryClient, ListScheduledQueriesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListScheduledQueries = core.createPaginator(TimestreamQueryClient, ListScheduledQueriesCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateListTagsForResource = core$1.createPaginator(TimestreamQueryClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListTagsForResource = core.createPaginator(TimestreamQueryClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
 
-const paginateQuery = core$1.createPaginator(TimestreamQueryClient, QueryCommand, "NextToken", "NextToken", "MaxRows");
+const paginateQuery = core.createPaginator(TimestreamQueryClient, QueryCommand, "NextToken", "NextToken", "MaxRows");
 
 Object.defineProperty(exports, "$Command", {
     enumerable: true,
@@ -1390,52 +1339,45 @@ Object.defineProperty(exports, "__Client", {
     enumerable: true,
     get: function () { return smithyClient.Client; }
 });
-exports.AccessDeniedException = AccessDeniedException;
+exports.AccessDeniedException = AccessDeniedException$1;
 exports.CancelQueryCommand = CancelQueryCommand;
 exports.ComputeMode = ComputeMode;
-exports.ConflictException = ConflictException;
+exports.ConflictException = ConflictException$1;
 exports.CreateScheduledQueryCommand = CreateScheduledQueryCommand;
-exports.CreateScheduledQueryRequestFilterSensitiveLog = CreateScheduledQueryRequestFilterSensitiveLog;
 exports.DeleteScheduledQueryCommand = DeleteScheduledQueryCommand;
 exports.DescribeAccountSettingsCommand = DescribeAccountSettingsCommand;
 exports.DescribeEndpointsCommand = DescribeEndpointsCommand;
 exports.DescribeScheduledQueryCommand = DescribeScheduledQueryCommand;
-exports.DescribeScheduledQueryResponseFilterSensitiveLog = DescribeScheduledQueryResponseFilterSensitiveLog;
 exports.DimensionValueType = DimensionValueType;
 exports.ExecuteScheduledQueryCommand = ExecuteScheduledQueryCommand;
-exports.ExecuteScheduledQueryRequestFilterSensitiveLog = ExecuteScheduledQueryRequestFilterSensitiveLog;
-exports.InternalServerException = InternalServerException;
-exports.InvalidEndpointException = InvalidEndpointException;
+exports.InternalServerException = InternalServerException$1;
+exports.InvalidEndpointException = InvalidEndpointException$1;
 exports.LastUpdateStatus = LastUpdateStatus;
 exports.ListScheduledQueriesCommand = ListScheduledQueriesCommand;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
 exports.MeasureValueType = MeasureValueType;
 exports.PrepareQueryCommand = PrepareQueryCommand;
-exports.PrepareQueryRequestFilterSensitiveLog = PrepareQueryRequestFilterSensitiveLog;
-exports.PrepareQueryResponseFilterSensitiveLog = PrepareQueryResponseFilterSensitiveLog;
 exports.QueryCommand = QueryCommand;
-exports.QueryExecutionException = QueryExecutionException;
+exports.QueryExecutionException = QueryExecutionException$1;
 exports.QueryInsightsMode = QueryInsightsMode;
 exports.QueryPricingModel = QueryPricingModel;
-exports.QueryRequestFilterSensitiveLog = QueryRequestFilterSensitiveLog;
-exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException = ResourceNotFoundException$1;
 exports.S3EncryptionOption = S3EncryptionOption;
 exports.ScalarMeasureValueType = ScalarMeasureValueType;
 exports.ScalarType = ScalarType;
-exports.ScheduledQueryDescriptionFilterSensitiveLog = ScheduledQueryDescriptionFilterSensitiveLog;
 exports.ScheduledQueryInsightsMode = ScheduledQueryInsightsMode;
 exports.ScheduledQueryRunStatus = ScheduledQueryRunStatus;
 exports.ScheduledQueryState = ScheduledQueryState;
-exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException$1;
 exports.TagResourceCommand = TagResourceCommand;
-exports.ThrottlingException = ThrottlingException;
+exports.ThrottlingException = ThrottlingException$1;
 exports.TimestreamQuery = TimestreamQuery;
 exports.TimestreamQueryClient = TimestreamQueryClient;
-exports.TimestreamQueryServiceException = TimestreamQueryServiceException;
+exports.TimestreamQueryServiceException = TimestreamQueryServiceException$1;
 exports.UntagResourceCommand = UntagResourceCommand;
 exports.UpdateAccountSettingsCommand = UpdateAccountSettingsCommand;
 exports.UpdateScheduledQueryCommand = UpdateScheduledQueryCommand;
-exports.ValidationException = ValidationException;
+exports.ValidationException = ValidationException$1;
 exports.paginateListScheduledQueries = paginateListScheduledQueries;
 exports.paginateListTagsForResource = paginateListTagsForResource;
 exports.paginateQuery = paginateQuery;