@aws-sdk/client-rds-data 3.131.0 → 3.142.0

package/dist-cjs/protocols/Aws_restJson1.js

@@ -166,15 +166,14 @@ const deserializeAws_restJson1BatchExecuteStatementCommand = async (output, cont
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1BatchExecuteStatementCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        updateResults: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.updateResults !== undefined && data.updateResults !== null) {
+    if (data.updateResults != null) {
         contents.updateResults = deserializeAws_restJson1UpdateResults(data.updateResults, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1BatchExecuteStatementCommand = deserializeAws_restJson1BatchExecuteStatementCommand;
 const deserializeAws_restJson1BatchExecuteStatementCommandError = async (output, context) => {
@@ -182,7 +181,6 @@ const deserializeAws_restJson1BatchExecuteStatementCommandError = async (output,
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -205,29 +203,26 @@ const deserializeAws_restJson1BatchExecuteStatementCommandError = async (output,
             throw await deserializeAws_restJson1StatementTimeoutExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1BeginTransactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1BeginTransactionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        transactionId: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.transactionId !== undefined && data.transactionId !== null) {
+    if (data.transactionId != null) {
         contents.transactionId = (0, smithy_client_1.expectString)(data.transactionId);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1BeginTransactionCommand = deserializeAws_restJson1BeginTransactionCommand;
 const deserializeAws_restJson1BeginTransactionCommandError = async (output, context) => {
@@ -235,7 +230,6 @@ const deserializeAws_restJson1BeginTransactionCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -258,29 +252,26 @@ const deserializeAws_restJson1BeginTransactionCommandError = async (output, cont
             throw await deserializeAws_restJson1StatementTimeoutExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1CommitTransactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1CommitTransactionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        transactionStatus: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.transactionStatus !== undefined && data.transactionStatus !== null) {
+    if (data.transactionStatus != null) {
         contents.transactionStatus = (0, smithy_client_1.expectString)(data.transactionStatus);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1CommitTransactionCommand = deserializeAws_restJson1CommitTransactionCommand;
 const deserializeAws_restJson1CommitTransactionCommandError = async (output, context) => {
@@ -288,7 +279,6 @@ const deserializeAws_restJson1CommitTransactionCommandError = async (output, con
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -314,29 +304,26 @@ const deserializeAws_restJson1CommitTransactionCommandError = async (output, con
             throw await deserializeAws_restJson1StatementTimeoutExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ExecuteSqlCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ExecuteSqlCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        sqlStatementResults: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.sqlStatementResults !== undefined && data.sqlStatementResults !== null) {
+    if (data.sqlStatementResults != null) {
         contents.sqlStatementResults = deserializeAws_restJson1SqlStatementResults(data.sqlStatementResults, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ExecuteSqlCommand = deserializeAws_restJson1ExecuteSqlCommand;
 const deserializeAws_restJson1ExecuteSqlCommandError = async (output, context) => {
@@ -344,7 +331,6 @@ const deserializeAws_restJson1ExecuteSqlCommandError = async (output, context) =
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -364,45 +350,38 @@ const deserializeAws_restJson1ExecuteSqlCommandError = async (output, context) =
             throw await deserializeAws_restJson1ServiceUnavailableErrorResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1ExecuteStatementCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1ExecuteStatementCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        columnMetadata: undefined,
-        formattedRecords: undefined,
-        generatedFields: undefined,
-        numberOfRecordsUpdated: undefined,
-        records: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.columnMetadata !== undefined && data.columnMetadata !== null) {
+    if (data.columnMetadata != null) {
         contents.columnMetadata = deserializeAws_restJson1Metadata(data.columnMetadata, context);
     }
-    if (data.formattedRecords !== undefined && data.formattedRecords !== null) {
+    if (data.formattedRecords != null) {
         contents.formattedRecords = (0, smithy_client_1.expectString)(data.formattedRecords);
     }
-    if (data.generatedFields !== undefined && data.generatedFields !== null) {
+    if (data.generatedFields != null) {
         contents.generatedFields = deserializeAws_restJson1FieldList(data.generatedFields, context);
     }
-    if (data.numberOfRecordsUpdated !== undefined && data.numberOfRecordsUpdated !== null) {
+    if (data.numberOfRecordsUpdated != null) {
         contents.numberOfRecordsUpdated = (0, smithy_client_1.expectLong)(data.numberOfRecordsUpdated);
     }
-    if (data.records !== undefined && data.records !== null) {
+    if (data.records != null) {
         contents.records = deserializeAws_restJson1SqlRecords(data.records, context);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1ExecuteStatementCommand = deserializeAws_restJson1ExecuteStatementCommand;
 const deserializeAws_restJson1ExecuteStatementCommandError = async (output, context) => {
@@ -410,7 +389,6 @@ const deserializeAws_restJson1ExecuteStatementCommandError = async (output, cont
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -433,29 +411,26 @@ const deserializeAws_restJson1ExecuteStatementCommandError = async (output, cont
             throw await deserializeAws_restJson1StatementTimeoutExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
 const deserializeAws_restJson1RollbackTransactionCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return deserializeAws_restJson1RollbackTransactionCommandError(output, context);
     }
-    const contents = {
+    const contents = map({
         $metadata: deserializeMetadata(output),
-        transactionStatus: undefined,
-    };
+    });
     const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body");
-    if (data.transactionStatus !== undefined && data.transactionStatus !== null) {
+    if (data.transactionStatus != null) {
         contents.transactionStatus = (0, smithy_client_1.expectString)(data.transactionStatus);
     }
-    return Promise.resolve(contents);
+    return contents;
 };
 exports.deserializeAws_restJson1RollbackTransactionCommand = deserializeAws_restJson1RollbackTransactionCommand;
 const deserializeAws_restJson1RollbackTransactionCommandError = async (output, context) => {
@@ -463,7 +438,6 @@ const deserializeAws_restJson1RollbackTransactionCommandError = async (output, c
         ...output,
         body: await parseBody(output.body, context),
     };
-    let response;
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
         case "AccessDeniedException":
@@ -489,20 +463,19 @@ const deserializeAws_restJson1RollbackTransactionCommandError = async (output, c
             throw await deserializeAws_restJson1StatementTimeoutExceptionResponse(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
-            const $metadata = deserializeMetadata(output);
-            const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
-            response = new RDSDataServiceException_1.RDSDataServiceException({
-                name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknowError",
-                $fault: "client",
-                $metadata,
+            (0, smithy_client_1.throwDefaultError)({
+                output,
+                parsedBody,
+                exceptionCtor: RDSDataServiceException_1.RDSDataServiceException,
+                errorCode,
             });
-            throw (0, smithy_client_1.decorateServiceException)(response, parsedBody);
     }
 };
+const map = smithy_client_1.map;
 const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.AccessDeniedException({
@@ -512,9 +485,9 @@ const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutpu
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.BadRequestException({
@@ -524,9 +497,9 @@ const deserializeAws_restJson1BadRequestExceptionResponse = async (parsedOutput,
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.ForbiddenException({
@@ -536,7 +509,7 @@ const deserializeAws_restJson1ForbiddenExceptionResponse = async (parsedOutput,
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
     const exception = new models_0_1.InternalServerErrorException({
         $metadata: deserializeMetadata(parsedOutput),
@@ -545,9 +518,9 @@ const deserializeAws_restJson1InternalServerErrorExceptionResponse = async (pars
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.NotFoundException({
@@ -557,7 +530,7 @@ const deserializeAws_restJson1NotFoundExceptionResponse = async (parsedOutput, c
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1ServiceUnavailableErrorResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
     const exception = new models_0_1.ServiceUnavailableError({
         $metadata: deserializeMetadata(parsedOutput),
@@ -566,12 +539,12 @@ const deserializeAws_restJson1ServiceUnavailableErrorResponse = async (parsedOut
     return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body);
 };
 const deserializeAws_restJson1StatementTimeoutExceptionResponse = async (parsedOutput, context) => {
-    const contents = {};
+    const contents = map({});
     const data = parsedOutput.body;
-    if (data.dbConnectionId !== undefined && data.dbConnectionId !== null) {
+    if (data.dbConnectionId != null) {
         contents.dbConnectionId = (0, smithy_client_1.expectLong)(data.dbConnectionId);
     }
-    if (data.message !== undefined && data.message !== null) {
+    if (data.message != null) {
         contents.message = (0, smithy_client_1.expectString)(data.message);
     }
     const exception = new models_0_1.StatementTimeoutException({
@@ -584,9 +557,6 @@ const serializeAws_restJson1ArrayOfArray = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return serializeAws_restJson1ArrayValue(entry, context);
     });
 };
@@ -604,9 +574,6 @@ const serializeAws_restJson1BooleanArray = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return entry;
     });
 };
@@ -614,9 +581,6 @@ const serializeAws_restJson1DoubleArray = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return (0, smithy_client_1.serializeFloat)(entry);
     });
 };
@@ -636,9 +600,6 @@ const serializeAws_restJson1LongArray = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return entry;
     });
 };
@@ -659,9 +620,6 @@ const serializeAws_restJson1SqlParameterSets = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return serializeAws_restJson1SqlParametersList(entry, context);
     });
 };
@@ -669,9 +627,6 @@ const serializeAws_restJson1SqlParametersList = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return serializeAws_restJson1SqlParameter(entry, context);
     });
 };
@@ -679,9 +634,6 @@ const serializeAws_restJson1StringArray = (input, context) => {
     return input
         .filter((e) => e != null)
         .map((entry) => {
-        if (entry === null) {
-            return null;
-        }
         return entry;
     });
 };
@@ -697,27 +649,27 @@ const deserializeAws_restJson1ArrayOfArray = (output, context) => {
     return retVal;
 };
 const deserializeAws_restJson1ArrayValue = (output, context) => {
-    if (output.arrayValues !== undefined && output.arrayValues !== null) {
+    if (output.arrayValues != null) {
         return {
             arrayValues: deserializeAws_restJson1ArrayOfArray(output.arrayValues, context),
         };
     }
-    if (output.booleanValues !== undefined && output.booleanValues !== null) {
+    if (output.booleanValues != null) {
         return {
             booleanValues: deserializeAws_restJson1BooleanArray(output.booleanValues, context),
         };
     }
-    if (output.doubleValues !== undefined && output.doubleValues !== null) {
+    if (output.doubleValues != null) {
         return {
             doubleValues: deserializeAws_restJson1DoubleArray(output.doubleValues, context),
         };
     }
-    if (output.longValues !== undefined && output.longValues !== null) {
+    if (output.longValues != null) {
         return {
             longValues: deserializeAws_restJson1LongArray(output.longValues, context),
         };
     }
-    if (output.stringValues !== undefined && output.stringValues !== null) {
+    if (output.stringValues != null) {
         return {
             stringValues: deserializeAws_restJson1StringArray(output.stringValues, context),
         };
@@ -776,12 +728,12 @@ const deserializeAws_restJson1DoubleArray = (output, context) => {
     return retVal;
 };
 const deserializeAws_restJson1Field = (output, context) => {
-    if (output.arrayValue !== undefined && output.arrayValue !== null) {
+    if (output.arrayValue != null) {
         return {
             arrayValue: deserializeAws_restJson1ArrayValue((0, smithy_client_1.expectUnion)(output.arrayValue), context),
         };
     }
-    if (output.blobValue !== undefined && output.blobValue !== null) {
+    if (output.blobValue != null) {
         return {
             blobValue: context.base64Decoder(output.blobValue),
         };
@@ -938,7 +890,7 @@ const deserializeAws_restJson1UpdateResults = (output, context) => {
     return retVal;
 };
 const deserializeAws_restJson1Value = (output, context) => {
-    if (output.arrayValues !== undefined && output.arrayValues !== null) {
+    if (output.arrayValues != null) {
         return {
             arrayValues: deserializeAws_restJson1ArrayValueList(output.arrayValues, context),
         };
@@ -949,7 +901,7 @@ const deserializeAws_restJson1Value = (output, context) => {
     if ((0, smithy_client_1.expectBoolean)(output.bitValue) !== undefined) {
         return { bitValue: (0, smithy_client_1.expectBoolean)(output.bitValue) };
     }
-    if (output.blobValue !== undefined && output.blobValue !== null) {
+    if (output.blobValue != null) {
         return {
             blobValue: context.base64Decoder(output.blobValue),
         };
@@ -969,7 +921,7 @@ const deserializeAws_restJson1Value = (output, context) => {
     if ((0, smithy_client_1.expectString)(output.stringValue) !== undefined) {
         return { stringValue: (0, smithy_client_1.expectString)(output.stringValue) };
     }
-    if (output.structValue !== undefined && output.structValue !== null) {
+    if (output.structValue != null) {
         return {
             structValue: deserializeAws_restJson1StructValue(output.structValue, context),
         };

package/dist-es/commands/BatchExecuteStatementCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { BatchExecuteStatementRequest, BatchExecuteStatementResponse } from "../models/models_0";
+import { BatchExecuteStatementRequestFilterSensitiveLog, BatchExecuteStatementResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1BatchExecuteStatementCommand, serializeAws_restJson1BatchExecuteStatementCommand, } from "../protocols/Aws_restJson1";
 var BatchExecuteStatementCommand = (function (_super) {
     __extends(BatchExecuteStatementCommand, _super);
@@ -20,8 +20,8 @@ var BatchExecuteStatementCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: BatchExecuteStatementRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: BatchExecuteStatementResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: BatchExecuteStatementRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: BatchExecuteStatementResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {

package/dist-es/commands/BeginTransactionCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { BeginTransactionRequest, BeginTransactionResponse } from "../models/models_0";
+import { BeginTransactionRequestFilterSensitiveLog, BeginTransactionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1BeginTransactionCommand, serializeAws_restJson1BeginTransactionCommand, } from "../protocols/Aws_restJson1";
 var BeginTransactionCommand = (function (_super) {
     __extends(BeginTransactionCommand, _super);
@@ -20,8 +20,8 @@ var BeginTransactionCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: BeginTransactionRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: BeginTransactionResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: BeginTransactionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: BeginTransactionResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {

package/dist-es/commands/CommitTransactionCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { CommitTransactionRequest, CommitTransactionResponse } from "../models/models_0";
+import { CommitTransactionRequestFilterSensitiveLog, CommitTransactionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1CommitTransactionCommand, serializeAws_restJson1CommitTransactionCommand, } from "../protocols/Aws_restJson1";
 var CommitTransactionCommand = (function (_super) {
     __extends(CommitTransactionCommand, _super);
@@ -20,8 +20,8 @@ var CommitTransactionCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: CommitTransactionRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: CommitTransactionResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: CommitTransactionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CommitTransactionResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {

package/dist-es/commands/ExecuteSqlCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { ExecuteSqlRequest, ExecuteSqlResponse } from "../models/models_0";
+import { ExecuteSqlRequestFilterSensitiveLog, ExecuteSqlResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ExecuteSqlCommand, serializeAws_restJson1ExecuteSqlCommand, } from "../protocols/Aws_restJson1";
 var ExecuteSqlCommand = (function (_super) {
     __extends(ExecuteSqlCommand, _super);
@@ -20,8 +20,8 @@ var ExecuteSqlCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: ExecuteSqlRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: ExecuteSqlResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: ExecuteSqlRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ExecuteSqlResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {

package/dist-es/commands/ExecuteStatementCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { ExecuteStatementRequest, ExecuteStatementResponse } from "../models/models_0";
+import { ExecuteStatementRequestFilterSensitiveLog, ExecuteStatementResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1ExecuteStatementCommand, serializeAws_restJson1ExecuteStatementCommand, } from "../protocols/Aws_restJson1";
 var ExecuteStatementCommand = (function (_super) {
     __extends(ExecuteStatementCommand, _super);
@@ -20,8 +20,8 @@ var ExecuteStatementCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: ExecuteStatementRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: ExecuteStatementResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: ExecuteStatementRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ExecuteStatementResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {

package/dist-es/commands/RollbackTransactionCommand.js

@@ -1,7 +1,7 @@
 import { __extends } from "tslib";
 import { getSerdePlugin } from "@aws-sdk/middleware-serde";
 import { Command as $Command } from "@aws-sdk/smithy-client";
-import { RollbackTransactionRequest, RollbackTransactionResponse } from "../models/models_0";
+import { RollbackTransactionRequestFilterSensitiveLog, RollbackTransactionResponseFilterSensitiveLog, } from "../models/models_0";
 import { deserializeAws_restJson1RollbackTransactionCommand, serializeAws_restJson1RollbackTransactionCommand, } from "../protocols/Aws_restJson1";
 var RollbackTransactionCommand = (function (_super) {
     __extends(RollbackTransactionCommand, _super);
@@ -20,8 +20,8 @@ var RollbackTransactionCommand = (function (_super) {
             logger: logger,
             clientName: clientName,
             commandName: commandName,
-            inputFilterSensitiveLog: RollbackTransactionRequest.filterSensitiveLog,
-            outputFilterSensitiveLog: RollbackTransactionResponse.filterSensitiveLog,
+            inputFilterSensitiveLog: RollbackTransactionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: RollbackTransactionResponseFilterSensitiveLog,
         };
         var requestHandler = configuration.requestHandler;
         return stack.resolve(function (request) {