@aws-sdk/client-rds-data 3.478.0 → 3.481.0

package/dist-es/commands/ExecuteStatementCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_ExecuteStatementCommand, se_ExecuteStatementCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class ExecuteStatementCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, ExecuteStatementCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSDataClient";
-        const commandName = "ExecuteStatementCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "RdsDataService",
-                operation: "ExecuteStatement",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_ExecuteStatementCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_ExecuteStatementCommand(output, context);
-    }
+export class ExecuteStatementCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("RdsDataService", "ExecuteStatement", {})
+    .n("RDSDataClient", "ExecuteStatementCommand")
+    .f(void 0, void 0)
+    .ser(se_ExecuteStatementCommand)
+    .de(de_ExecuteStatementCommand)
+    .build() {
 }

package/dist-es/commands/RollbackTransactionCommand.js

@@ -1,47 +1,24 @@
 import { getEndpointPlugin } from "@smithy/middleware-endpoint";
 import { getSerdePlugin } from "@smithy/middleware-serde";
 import { Command as $Command } from "@smithy/smithy-client";
-import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { commonParams } from "../endpoint/EndpointParameters";
 import { de_RollbackTransactionCommand, se_RollbackTransactionCommand } from "../protocols/Aws_restJson1";
 export { $Command };
-export class RollbackTransactionCommand extends $Command {
-    static getEndpointParameterInstructions() {
-        return {
-            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-            Endpoint: { type: "builtInParams", name: "endpoint" },
-            Region: { type: "builtInParams", name: "region" },
-            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
-        };
-    }
-    constructor(input) {
-        super();
-        this.input = input;
-    }
-    resolveMiddleware(clientStack, configuration, options) {
-        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
-        this.middlewareStack.use(getEndpointPlugin(configuration, RollbackTransactionCommand.getEndpointParameterInstructions()));
-        const stack = clientStack.concat(this.middlewareStack);
-        const { logger } = configuration;
-        const clientName = "RDSDataClient";
-        const commandName = "RollbackTransactionCommand";
-        const handlerExecutionContext = {
-            logger,
-            clientName,
-            commandName,
-            inputFilterSensitiveLog: (_) => _,
-            outputFilterSensitiveLog: (_) => _,
-            [SMITHY_CONTEXT_KEY]: {
-                service: "RdsDataService",
-                operation: "RollbackTransaction",
-            },
-        };
-        const { requestHandler } = configuration;
-        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
-    }
-    serialize(input, context) {
-        return se_RollbackTransactionCommand(input, context);
-    }
-    deserialize(output, context) {
-        return de_RollbackTransactionCommand(output, context);
-    }
+export class RollbackTransactionCommand extends $Command
+    .classBuilder()
+    .ep({
+    ...commonParams,
+})
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+        getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("RdsDataService", "RollbackTransaction", {})
+    .n("RDSDataClient", "RollbackTransactionCommand")
+    .f(void 0, void 0)
+    .ser(se_RollbackTransactionCommand)
+    .de(de_RollbackTransactionCommand)
+    .build() {
 }

package/dist-es/endpoint/EndpointParameters.js

@@ -6,3 +6,9 @@ export const resolveClientEndpointParameters = (options) => {
         defaultSigningName: "rds-data",
     };
 };
+export const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+};

package/dist-es/models/models_0.js

@@ -31,6 +31,42 @@ export const TypeHint = {
     TIMESTAMP: "TIMESTAMP",
     UUID: "UUID",
 };
+export class DatabaseErrorException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "DatabaseErrorException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "DatabaseErrorException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, DatabaseErrorException.prototype);
+    }
+}
+export class DatabaseNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "DatabaseNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "DatabaseNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, DatabaseNotFoundException.prototype);
+    }
+}
+export class DatabaseUnavailableException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "DatabaseUnavailableException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "DatabaseUnavailableException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, DatabaseUnavailableException.prototype);
+    }
+}
 export class ForbiddenException extends __BaseException {
     constructor(opts) {
         super({
@@ -43,6 +79,18 @@ export class ForbiddenException extends __BaseException {
         Object.setPrototypeOf(this, ForbiddenException.prototype);
     }
 }
+export class HttpEndpointNotEnabledException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "HttpEndpointNotEnabledException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "HttpEndpointNotEnabledException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, HttpEndpointNotEnabledException.prototype);
+    }
+}
 export class InternalServerErrorException extends __BaseException {
     constructor(opts) {
         super({
@@ -55,6 +103,30 @@ export class InternalServerErrorException extends __BaseException {
         Object.setPrototypeOf(this, InternalServerErrorException.prototype);
     }
 }
+export class InvalidSecretException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InvalidSecretException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "InvalidSecretException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, InvalidSecretException.prototype);
+    }
+}
+export class SecretsErrorException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "SecretsErrorException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "SecretsErrorException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, SecretsErrorException.prototype);
+    }
+}
 export class ServiceUnavailableError extends __BaseException {
     constructor(opts) {
         super({
@@ -80,6 +152,18 @@ export class StatementTimeoutException extends __BaseException {
         this.dbConnectionId = opts.dbConnectionId;
     }
 }
+export class TransactionNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "TransactionNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "TransactionNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, TransactionNotFoundException.prototype);
+    }
+}
 export class NotFoundException extends __BaseException {
     constructor(opts) {
         super({
@@ -104,6 +188,18 @@ export const LongReturnType = {
     LONG: "LONG",
     STRING: "STRING",
 };
+export class UnsupportedResultException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "UnsupportedResultException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "UnsupportedResultException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, UnsupportedResultException.prototype);
+    }
+}
 export var ArrayValue;
 (function (ArrayValue) {
     ArrayValue.visit = (value, visitor) => {

package/dist-es/protocols/Aws_restJson1.js

@@ -1,7 +1,7 @@
 import { awsExpectUnion as __expectUnion } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
 import { _json, collectBody, decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, limitedParseDouble as __limitedParseDouble, limitedParseFloat32 as __limitedParseFloat32, map, serializeFloat as __serializeFloat, take, withBaseException, } from "@smithy/smithy-client";
-import { AccessDeniedException, ArrayValue, BadRequestException, Field, ForbiddenException, InternalServerErrorException, NotFoundException, ServiceUnavailableError, StatementTimeoutException, } from "../models/models_0";
+import { AccessDeniedException, ArrayValue, BadRequestException, DatabaseErrorException, DatabaseNotFoundException, DatabaseUnavailableException, Field, ForbiddenException, HttpEndpointNotEnabledException, InternalServerErrorException, InvalidSecretException, NotFoundException, SecretsErrorException, ServiceUnavailableError, StatementTimeoutException, TransactionNotFoundException, UnsupportedResultException, } from "../models/models_0";
 import { RDSDataServiceException as __BaseException } from "../models/RDSDataServiceException";
 export const se_BatchExecuteStatementCommand = async (input, context) => {
     const b = rb(input, context);
@@ -135,18 +135,39 @@ const de_BatchExecuteStatementCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.rdsdata#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "DatabaseErrorException":
+        case "com.amazonaws.rdsdata#DatabaseErrorException":
+            throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+        case "DatabaseNotFoundException":
+        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+            throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+        case "DatabaseUnavailableException":
+        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+            throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.rdsdata#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "HttpEndpointNotEnabledException":
+        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+            throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.rdsdata#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "InvalidSecretException":
+        case "com.amazonaws.rdsdata#InvalidSecretException":
+            throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+        case "SecretsErrorException":
+        case "com.amazonaws.rdsdata#SecretsErrorException":
+            throw await de_SecretsErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableError":
         case "com.amazonaws.rdsdata#ServiceUnavailableError":
             throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
         case "StatementTimeoutException":
         case "com.amazonaws.rdsdata#StatementTimeoutException":
             throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+        case "TransactionNotFoundException":
+        case "com.amazonaws.rdsdata#TransactionNotFoundException":
+            throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -183,18 +204,39 @@ const de_BeginTransactionCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.rdsdata#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "DatabaseErrorException":
+        case "com.amazonaws.rdsdata#DatabaseErrorException":
+            throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+        case "DatabaseNotFoundException":
+        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+            throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+        case "DatabaseUnavailableException":
+        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+            throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.rdsdata#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "HttpEndpointNotEnabledException":
+        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+            throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.rdsdata#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "InvalidSecretException":
+        case "com.amazonaws.rdsdata#InvalidSecretException":
+            throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+        case "SecretsErrorException":
+        case "com.amazonaws.rdsdata#SecretsErrorException":
+            throw await de_SecretsErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableError":
         case "com.amazonaws.rdsdata#ServiceUnavailableError":
             throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
         case "StatementTimeoutException":
         case "com.amazonaws.rdsdata#StatementTimeoutException":
             throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+        case "TransactionNotFoundException":
+        case "com.amazonaws.rdsdata#TransactionNotFoundException":
+            throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -231,21 +273,42 @@ const de_CommitTransactionCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.rdsdata#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "DatabaseErrorException":
+        case "com.amazonaws.rdsdata#DatabaseErrorException":
+            throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+        case "DatabaseNotFoundException":
+        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+            throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+        case "DatabaseUnavailableException":
+        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+            throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.rdsdata#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "HttpEndpointNotEnabledException":
+        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+            throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.rdsdata#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "InvalidSecretException":
+        case "com.amazonaws.rdsdata#InvalidSecretException":
+            throw await de_InvalidSecretExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.rdsdata#NotFoundException":
             throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "SecretsErrorException":
+        case "com.amazonaws.rdsdata#SecretsErrorException":
+            throw await de_SecretsErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableError":
         case "com.amazonaws.rdsdata#ServiceUnavailableError":
             throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
         case "StatementTimeoutException":
         case "com.amazonaws.rdsdata#StatementTimeoutException":
             throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+        case "TransactionNotFoundException":
+        case "com.amazonaws.rdsdata#TransactionNotFoundException":
+            throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -331,18 +394,42 @@ const de_ExecuteStatementCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.rdsdata#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "DatabaseErrorException":
+        case "com.amazonaws.rdsdata#DatabaseErrorException":
+            throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+        case "DatabaseNotFoundException":
+        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+            throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+        case "DatabaseUnavailableException":
+        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+            throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.rdsdata#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "HttpEndpointNotEnabledException":
+        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+            throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.rdsdata#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "InvalidSecretException":
+        case "com.amazonaws.rdsdata#InvalidSecretException":
+            throw await de_InvalidSecretExceptionRes(parsedOutput, context);
+        case "SecretsErrorException":
+        case "com.amazonaws.rdsdata#SecretsErrorException":
+            throw await de_SecretsErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableError":
         case "com.amazonaws.rdsdata#ServiceUnavailableError":
             throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
         case "StatementTimeoutException":
         case "com.amazonaws.rdsdata#StatementTimeoutException":
             throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+        case "TransactionNotFoundException":
+        case "com.amazonaws.rdsdata#TransactionNotFoundException":
+            throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
+        case "UnsupportedResultException":
+        case "com.amazonaws.rdsdata#UnsupportedResultException":
+            throw await de_UnsupportedResultExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -379,21 +466,42 @@ const de_RollbackTransactionCommandError = async (output, context) => {
         case "BadRequestException":
         case "com.amazonaws.rdsdata#BadRequestException":
             throw await de_BadRequestExceptionRes(parsedOutput, context);
+        case "DatabaseErrorException":
+        case "com.amazonaws.rdsdata#DatabaseErrorException":
+            throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
+        case "DatabaseNotFoundException":
+        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
+            throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
+        case "DatabaseUnavailableException":
+        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
+            throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
         case "ForbiddenException":
         case "com.amazonaws.rdsdata#ForbiddenException":
             throw await de_ForbiddenExceptionRes(parsedOutput, context);
+        case "HttpEndpointNotEnabledException":
+        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
+            throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
         case "InternalServerErrorException":
         case "com.amazonaws.rdsdata#InternalServerErrorException":
             throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+        case "InvalidSecretException":
+        case "com.amazonaws.rdsdata#InvalidSecretException":
+            throw await de_InvalidSecretExceptionRes(parsedOutput, context);
         case "NotFoundException":
         case "com.amazonaws.rdsdata#NotFoundException":
             throw await de_NotFoundExceptionRes(parsedOutput, context);
+        case "SecretsErrorException":
+        case "com.amazonaws.rdsdata#SecretsErrorException":
+            throw await de_SecretsErrorExceptionRes(parsedOutput, context);
         case "ServiceUnavailableError":
         case "com.amazonaws.rdsdata#ServiceUnavailableError":
             throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
         case "StatementTimeoutException":
         case "com.amazonaws.rdsdata#StatementTimeoutException":
             throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
+        case "TransactionNotFoundException":
+        case "com.amazonaws.rdsdata#TransactionNotFoundException":
+            throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
         default:
             const parsedBody = parsedOutput.body;
             return throwDefaultError({
@@ -430,6 +538,43 @@ const de_BadRequestExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_DatabaseErrorExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new DatabaseErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_DatabaseNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new DatabaseNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_DatabaseUnavailableExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {});
+    Object.assign(contents, doc);
+    const exception = new DatabaseUnavailableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -443,6 +588,19 @@ const de_ForbiddenExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_HttpEndpointNotEnabledExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new HttpEndpointNotEnabledException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -454,6 +612,19 @@ const de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_InvalidSecretExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new InvalidSecretException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -467,6 +638,19 @@ const de_NotFoundExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_SecretsErrorExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new SecretsErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const de_ServiceUnavailableErrorRes = async (parsedOutput, context) => {
     const contents = map({});
     const data = parsedOutput.body;
@@ -492,6 +676,32 @@ const de_StatementTimeoutExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_TransactionNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new TransactionNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_UnsupportedResultExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        message: __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new UnsupportedResultException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
 const se_ArrayOfArray = (input, context) => {
     return input
         .filter((e) => e != null)

package/dist-types/RDSData.d.ts

@@ -46,14 +46,20 @@ export interface RDSData {
 }
 /**
  * @public
- * <fullname>Amazon RDS Data Service</fullname>
- *         <p>Amazon RDS provides an HTTP endpoint to run SQL statements on an Amazon Aurora Serverless v1 DB cluster. To run these
- *             statements, you work with the Data Service API.</p>
- *         <note>
- *             <p>The Data Service API isn't supported on Amazon Aurora Serverless v2 DB clusters.</p>
- *         </note>
- *         <p>For more information about the Data Service API, see
- *           <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html">Using the Data API</a>
+ * <fullname>RDS Data API</fullname>
+ *          <p>Amazon RDS provides an HTTP endpoint to run SQL statements on an Amazon Aurora DB cluster. To run these
+ *             statements, you use the RDS Data API (Data API).</p>
+ *          <p>Data API is available with the following types of Aurora databases:</p>
+ *          <ul>
+ *             <li>
+ *                <p>Aurora PostgreSQL - Serverless v2, Serverless v1, and provisioned</p>
+ *             </li>
+ *             <li>
+ *                <p>Aurora MySQL - Serverless v1 only</p>
+ *             </li>
+ *          </ul>
+ *          <p>For more information about the Data API, see
+ *           <a href="https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/data-api.html">Using RDS Data API</a>
  *           in the <i>Amazon Aurora User Guide</i>.</p>
  */
 export declare class RDSData extends RDSDataClient implements RDSData {