@aws-sdk/client-rds-data 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,695 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { RDSDataServiceException as __BaseException } from "./RDSDataServiceException";
+
+export declare class BadRequestException extends __BaseException {
+    readonly name: "BadRequestException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<BadRequestException, __BaseException>);
+}
+export declare enum TypeHint {
+    DATE = "DATE",
+    DECIMAL = "DECIMAL",
+    JSON = "JSON",
+    TIME = "TIME",
+    TIMESTAMP = "TIMESTAMP",
+    UUID = "UUID"
+}
+
+export declare class ForbiddenException extends __BaseException {
+    readonly name: "ForbiddenException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
+}
+
+export declare class InternalServerErrorException extends __BaseException {
+    readonly name: "InternalServerErrorException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<InternalServerErrorException, __BaseException>);
+}
+
+export declare class ServiceUnavailableError extends __BaseException {
+    readonly name: "ServiceUnavailableError";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableError, __BaseException>);
+}
+
+export declare class StatementTimeoutException extends __BaseException {
+    readonly name: "StatementTimeoutException";
+    readonly $fault: "client";
+    
+    dbConnectionId?: number;
+    
+    constructor(opts: __ExceptionOptionType<StatementTimeoutException, __BaseException>);
+}
+
+export interface BeginTransactionRequest {
+    
+    resourceArn: string | undefined;
+    
+    secretArn: string | undefined;
+    
+    database?: string;
+    
+    schema?: string;
+}
+export declare namespace BeginTransactionRequest {
+    
+    const filterSensitiveLog: (obj: BeginTransactionRequest) => any;
+}
+
+export interface BeginTransactionResponse {
+    
+    transactionId?: string;
+}
+export declare namespace BeginTransactionResponse {
+    
+    const filterSensitiveLog: (obj: BeginTransactionResponse) => any;
+}
+
+export interface ColumnMetadata {
+    
+    name?: string;
+    
+    type?: number;
+    
+    typeName?: string;
+    
+    label?: string;
+    
+    schemaName?: string;
+    
+    tableName?: string;
+    
+    isAutoIncrement?: boolean;
+    
+    isSigned?: boolean;
+    
+    isCurrency?: boolean;
+    
+    isCaseSensitive?: boolean;
+    
+    nullable?: number;
+    
+    precision?: number;
+    
+    scale?: number;
+    
+    arrayBaseColumnType?: number;
+}
+export declare namespace ColumnMetadata {
+    
+    const filterSensitiveLog: (obj: ColumnMetadata) => any;
+}
+
+export interface CommitTransactionRequest {
+    
+    resourceArn: string | undefined;
+    
+    secretArn: string | undefined;
+    
+    transactionId: string | undefined;
+}
+export declare namespace CommitTransactionRequest {
+    
+    const filterSensitiveLog: (obj: CommitTransactionRequest) => any;
+}
+
+export interface CommitTransactionResponse {
+    
+    transactionStatus?: string;
+}
+export declare namespace CommitTransactionResponse {
+    
+    const filterSensitiveLog: (obj: CommitTransactionResponse) => any;
+}
+
+export declare class NotFoundException extends __BaseException {
+    readonly name: "NotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<NotFoundException, __BaseException>);
+}
+export declare enum DecimalReturnType {
+    DOUBLE_OR_LONG = "DOUBLE_OR_LONG",
+    STRING = "STRING"
+}
+
+export interface ExecuteSqlRequest {
+    
+    dbClusterOrInstanceArn: string | undefined;
+    
+    awsSecretStoreArn: string | undefined;
+    
+    sqlStatements: string | undefined;
+    
+    database?: string;
+    
+    schema?: string;
+}
+export declare namespace ExecuteSqlRequest {
+    
+    const filterSensitiveLog: (obj: ExecuteSqlRequest) => any;
+}
+
+export interface ResultSetMetadata {
+    
+    columnCount?: number;
+    
+    columnMetadata?: ColumnMetadata[];
+}
+export declare namespace ResultSetMetadata {
+    
+    const filterSensitiveLog: (obj: ResultSetMetadata) => any;
+}
+
+export interface ResultSetOptions {
+    
+    decimalReturnType?: DecimalReturnType | string;
+}
+export declare namespace ResultSetOptions {
+    
+    const filterSensitiveLog: (obj: ResultSetOptions) => any;
+}
+
+export interface RollbackTransactionRequest {
+    
+    resourceArn: string | undefined;
+    
+    secretArn: string | undefined;
+    
+    transactionId: string | undefined;
+}
+export declare namespace RollbackTransactionRequest {
+    
+    const filterSensitiveLog: (obj: RollbackTransactionRequest) => any;
+}
+
+export interface RollbackTransactionResponse {
+    
+    transactionStatus?: string;
+}
+export declare namespace RollbackTransactionResponse {
+    
+    const filterSensitiveLog: (obj: RollbackTransactionResponse) => any;
+}
+
+export declare type ArrayValue = ArrayValue.ArrayValuesMember | ArrayValue.BooleanValuesMember | ArrayValue.DoubleValuesMember | ArrayValue.LongValuesMember | ArrayValue.StringValuesMember | ArrayValue.$UnknownMember;
+export declare namespace ArrayValue {
+    
+    interface BooleanValuesMember {
+        booleanValues: boolean[];
+        longValues?: never;
+        doubleValues?: never;
+        stringValues?: never;
+        arrayValues?: never;
+        $unknown?: never;
+    }
+    
+    interface LongValuesMember {
+        booleanValues?: never;
+        longValues: number[];
+        doubleValues?: never;
+        stringValues?: never;
+        arrayValues?: never;
+        $unknown?: never;
+    }
+    
+    interface DoubleValuesMember {
+        booleanValues?: never;
+        longValues?: never;
+        doubleValues: number[];
+        stringValues?: never;
+        arrayValues?: never;
+        $unknown?: never;
+    }
+    
+    interface StringValuesMember {
+        booleanValues?: never;
+        longValues?: never;
+        doubleValues?: never;
+        stringValues: string[];
+        arrayValues?: never;
+        $unknown?: never;
+    }
+    
+    interface ArrayValuesMember {
+        booleanValues?: never;
+        longValues?: never;
+        doubleValues?: never;
+        stringValues?: never;
+        arrayValues: ArrayValue[];
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        booleanValues?: never;
+        longValues?: never;
+        doubleValues?: never;
+        stringValues?: never;
+        arrayValues?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        booleanValues: (value: boolean[]) => T;
+        longValues: (value: number[]) => T;
+        doubleValues: (value: number[]) => T;
+        stringValues: (value: string[]) => T;
+        arrayValues: (value: ArrayValue[]) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ArrayValue, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: ArrayValue) => any;
+}
+
+export declare type Field = Field.ArrayValueMember | Field.BlobValueMember | Field.BooleanValueMember | Field.DoubleValueMember | Field.IsNullMember | Field.LongValueMember | Field.StringValueMember | Field.$UnknownMember;
+export declare namespace Field {
+    
+    interface IsNullMember {
+        isNull: boolean;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BooleanValueMember {
+        isNull?: never;
+        booleanValue: boolean;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface LongValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue: number;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface DoubleValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue: number;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface StringValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue: string;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BlobValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue: Uint8Array;
+        arrayValue?: never;
+        $unknown?: never;
+    }
+    
+    interface ArrayValueMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue: ArrayValue;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        isNull?: never;
+        booleanValue?: never;
+        longValue?: never;
+        doubleValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValue?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        isNull: (value: boolean) => T;
+        booleanValue: (value: boolean) => T;
+        longValue: (value: number) => T;
+        doubleValue: (value: number) => T;
+        stringValue: (value: string) => T;
+        blobValue: (value: Uint8Array) => T;
+        arrayValue: (value: ArrayValue) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Field, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: Field) => any;
+}
+
+export interface SqlParameter {
+    
+    name?: string;
+    
+    value?: Field;
+    
+    typeHint?: TypeHint | string;
+}
+export declare namespace SqlParameter {
+    
+    const filterSensitiveLog: (obj: SqlParameter) => any;
+}
+
+export interface UpdateResult {
+    
+    generatedFields?: Field[];
+}
+export declare namespace UpdateResult {
+    
+    const filterSensitiveLog: (obj: UpdateResult) => any;
+}
+
+export declare type Value = Value.ArrayValuesMember | Value.BigIntValueMember | Value.BitValueMember | Value.BlobValueMember | Value.DoubleValueMember | Value.IntValueMember | Value.IsNullMember | Value.RealValueMember | Value.StringValueMember | Value.StructValueMember | Value.$UnknownMember;
+export declare namespace Value {
+    
+    interface IsNullMember {
+        isNull: boolean;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BitValueMember {
+        isNull?: never;
+        bitValue: boolean;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BigIntValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue: number;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface IntValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue: number;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface DoubleValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue: number;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface RealValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue: number;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface StringValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue: string;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BlobValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue: Uint8Array;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface ArrayValuesMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues: Value[];
+        structValue?: never;
+        $unknown?: never;
+    }
+    
+    interface StructValueMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue: StructValue;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        isNull?: never;
+        bitValue?: never;
+        bigIntValue?: never;
+        intValue?: never;
+        doubleValue?: never;
+        realValue?: never;
+        stringValue?: never;
+        blobValue?: never;
+        arrayValues?: never;
+        structValue?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        isNull: (value: boolean) => T;
+        bitValue: (value: boolean) => T;
+        bigIntValue: (value: number) => T;
+        intValue: (value: number) => T;
+        doubleValue: (value: number) => T;
+        realValue: (value: number) => T;
+        stringValue: (value: string) => T;
+        blobValue: (value: Uint8Array) => T;
+        arrayValues: (value: Value[]) => T;
+        structValue: (value: StructValue) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: Value, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: Value) => any;
+}
+
+export interface ExecuteStatementRequest {
+    
+    resourceArn: string | undefined;
+    
+    secretArn: string | undefined;
+    
+    sql: string | undefined;
+    
+    database?: string;
+    
+    schema?: string;
+    
+    parameters?: SqlParameter[];
+    
+    transactionId?: string;
+    
+    includeResultMetadata?: boolean;
+    
+    continueAfterTimeout?: boolean;
+    
+    resultSetOptions?: ResultSetOptions;
+}
+export declare namespace ExecuteStatementRequest {
+    
+    const filterSensitiveLog: (obj: ExecuteStatementRequest) => any;
+}
+
+export interface StructValue {
+    
+    attributes?: Value[];
+}
+export declare namespace StructValue {
+    
+    const filterSensitiveLog: (obj: StructValue) => any;
+}
+
+export interface BatchExecuteStatementRequest {
+    
+    resourceArn: string | undefined;
+    
+    secretArn: string | undefined;
+    
+    sql: string | undefined;
+    
+    database?: string;
+    
+    schema?: string;
+    
+    parameterSets?: SqlParameter[][];
+    
+    transactionId?: string;
+}
+export declare namespace BatchExecuteStatementRequest {
+    
+    const filterSensitiveLog: (obj: BatchExecuteStatementRequest) => any;
+}
+
+export interface BatchExecuteStatementResponse {
+    
+    updateResults?: UpdateResult[];
+}
+export declare namespace BatchExecuteStatementResponse {
+    
+    const filterSensitiveLog: (obj: BatchExecuteStatementResponse) => any;
+}
+
+export interface _Record {
+    
+    values?: Value[];
+}
+export declare namespace _Record {
+    
+    const filterSensitiveLog: (obj: _Record) => any;
+}
+
+export interface ExecuteStatementResponse {
+    
+    records?: Field[][];
+    
+    columnMetadata?: ColumnMetadata[];
+    
+    numberOfRecordsUpdated?: number;
+    
+    generatedFields?: Field[];
+}
+export declare namespace ExecuteStatementResponse {
+    
+    const filterSensitiveLog: (obj: ExecuteStatementResponse) => any;
+}
+
+export interface ResultFrame {
+    
+    resultSetMetadata?: ResultSetMetadata;
+    
+    records?: _Record[];
+}
+export declare namespace ResultFrame {
+    
+    const filterSensitiveLog: (obj: ResultFrame) => any;
+}
+
+export interface SqlStatementResult {
+    
+    resultFrame?: ResultFrame;
+    
+    numberOfRecordsUpdated?: number;
+}
+export declare namespace SqlStatementResult {
+    
+    const filterSensitiveLog: (obj: SqlStatementResult) => any;
+}
+
+export interface ExecuteSqlResponse {
+    
+    sqlStatementResults?: SqlStatementResult[];
+}
+export declare namespace ExecuteSqlResponse {
+    
+    const filterSensitiveLog: (obj: ExecuteSqlResponse) => any;
+}

package/dist-types/ts3.4/protocols/Aws_restJson1.d.ts

@@ -0,0 +1,20 @@
+import { HttpRequest as __HttpRequest, HttpResponse as __HttpResponse } from "@aws-sdk/protocol-http";
+import { SerdeContext as __SerdeContext } from "@aws-sdk/types";
+import { BatchExecuteStatementCommandInput, BatchExecuteStatementCommandOutput } from "../commands/BatchExecuteStatementCommand";
+import { BeginTransactionCommandInput, BeginTransactionCommandOutput } from "../commands/BeginTransactionCommand";
+import { CommitTransactionCommandInput, CommitTransactionCommandOutput } from "../commands/CommitTransactionCommand";
+import { ExecuteSqlCommandInput, ExecuteSqlCommandOutput } from "../commands/ExecuteSqlCommand";
+import { ExecuteStatementCommandInput, ExecuteStatementCommandOutput } from "../commands/ExecuteStatementCommand";
+import { RollbackTransactionCommandInput, RollbackTransactionCommandOutput } from "../commands/RollbackTransactionCommand";
+export declare const serializeAws_restJson1BatchExecuteStatementCommand: (input: BatchExecuteStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1BeginTransactionCommand: (input: BeginTransactionCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1CommitTransactionCommand: (input: CommitTransactionCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ExecuteSqlCommand: (input: ExecuteSqlCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1ExecuteStatementCommand: (input: ExecuteStatementCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const serializeAws_restJson1RollbackTransactionCommand: (input: RollbackTransactionCommandInput, context: __SerdeContext) => Promise<__HttpRequest>;
+export declare const deserializeAws_restJson1BatchExecuteStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<BatchExecuteStatementCommandOutput>;
+export declare const deserializeAws_restJson1BeginTransactionCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<BeginTransactionCommandOutput>;
+export declare const deserializeAws_restJson1CommitTransactionCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<CommitTransactionCommandOutput>;
+export declare const deserializeAws_restJson1ExecuteSqlCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ExecuteSqlCommandOutput>;
+export declare const deserializeAws_restJson1ExecuteStatementCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<ExecuteStatementCommandOutput>;
+export declare const deserializeAws_restJson1RollbackTransactionCommand: (output: __HttpResponse, context: __SerdeContext) => Promise<RollbackTransactionCommandOutput>;