import * as HttpClient from "effect/unstable/http/HttpClient";
import * as S from "effect/Schema";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type Arn = string;
export type SqlStatement = string;
export type DbName = string;
export type ParameterName = string;
export type BoxedBoolean = boolean;
export type BoxedLong = number;
export type BoxedDouble = number;
export type TypeHint = string;
export type Id = string;
export type ErrorMessage = string;
export type TransactionStatus = string;
export type BoxedInteger = number;
export type BoxedFloat = number;
export type RecordsUpdated = number;
export type DecimalReturnType = string;
export type LongReturnType = string;
export type RecordsFormatType = string;
export type FormattedSqlRecords = string;
export type BooleanArray = boolean[];
export declare const BooleanArray: S.$Array<S.Boolean>;
export type LongArray = number[];
export declare const LongArray: S.$Array<S.Number>;
export type DoubleArray = number[];
export declare const DoubleArray: S.$Array<S.Number>;
export type StringArray = string[];
export declare const StringArray: S.$Array<S.String>;
export type ArrayOfArray = ArrayValue[];
export declare const ArrayOfArray: S.Schema<ArrayOfArray>;
export type ArrayValue = {
    booleanValues: boolean[];
    longValues?: never;
    doubleValues?: never;
    stringValues?: never;
    arrayValues?: never;
} | {
    booleanValues?: never;
    longValues: number[];
    doubleValues?: never;
    stringValues?: never;
    arrayValues?: never;
} | {
    booleanValues?: never;
    longValues?: never;
    doubleValues: number[];
    stringValues?: never;
    arrayValues?: never;
} | {
    booleanValues?: never;
    longValues?: never;
    doubleValues?: never;
    stringValues: string[];
    arrayValues?: never;
} | {
    booleanValues?: never;
    longValues?: never;
    doubleValues?: never;
    stringValues?: never;
    arrayValues: ArrayValue[];
};
export declare const ArrayValue: S.Schema<ArrayValue>;
export type Field = {
    isNull: boolean;
    booleanValue?: never;
    longValue?: never;
    doubleValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue: boolean;
    longValue?: never;
    doubleValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue?: never;
    longValue: number;
    doubleValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue?: never;
    longValue?: never;
    doubleValue: number;
    stringValue?: never;
    blobValue?: never;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue?: never;
    longValue?: never;
    doubleValue?: never;
    stringValue: string;
    blobValue?: never;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue?: never;
    longValue?: never;
    doubleValue?: never;
    stringValue?: never;
    blobValue: Uint8Array;
    arrayValue?: never;
} | {
    isNull?: never;
    booleanValue?: never;
    longValue?: never;
    doubleValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValue: ArrayValue;
};
export declare const Field: S.Union<readonly [S.Struct<{
    readonly isNull: S.Boolean;
}>, S.Struct<{
    readonly booleanValue: S.Boolean;
}>, S.Struct<{
    readonly longValue: S.Number;
}>, S.Struct<{
    readonly doubleValue: S.Number;
}>, S.Struct<{
    readonly stringValue: S.String;
}>, S.Struct<{
    readonly blobValue: S.decodeTo<S.instanceOf<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, S.String, never, never>;
}>, S.Struct<{
    readonly arrayValue: S.Schema<ArrayValue>;
}>]>;
export interface SqlParameter {
    name?: string;
    value?: Field;
    typeHint?: string;
}
export declare const SqlParameter: S.Schema<SqlParameter>;
export type SqlParametersList = SqlParameter[];
export declare const SqlParametersList: S.$Array<S.Schema<SqlParameter>>;
export type SqlParameterSets = SqlParameter[][];
export declare const SqlParameterSets: S.$Array<S.$Array<S.Schema<SqlParameter>>>;
export interface BatchExecuteStatementRequest {
    resourceArn: string;
    secretArn: string;
    sql: string;
    database?: string;
    schema?: string;
    parameterSets?: SqlParameter[][];
    transactionId?: string;
}
export declare const BatchExecuteStatementRequest: S.Schema<BatchExecuteStatementRequest>;
export type FieldList = Field[];
export declare const FieldList: S.$Array<S.Union<readonly [S.Struct<{
    readonly isNull: S.Boolean;
}>, S.Struct<{
    readonly booleanValue: S.Boolean;
}>, S.Struct<{
    readonly longValue: S.Number;
}>, S.Struct<{
    readonly doubleValue: S.Number;
}>, S.Struct<{
    readonly stringValue: S.String;
}>, S.Struct<{
    readonly blobValue: S.decodeTo<S.instanceOf<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, S.String, never, never>;
}>, S.Struct<{
    readonly arrayValue: S.Schema<ArrayValue>;
}>]>>;
export interface UpdateResult {
    generatedFields?: Field[];
}
export declare const UpdateResult: S.Schema<UpdateResult>;
export type UpdateResults = UpdateResult[];
export declare const UpdateResults: S.$Array<S.Schema<UpdateResult>>;
export interface BatchExecuteStatementResponse {
    updateResults?: UpdateResult[];
}
export declare const BatchExecuteStatementResponse: S.Schema<BatchExecuteStatementResponse>;
export interface BeginTransactionRequest {
    resourceArn: string;
    secretArn: string;
    database?: string;
    schema?: string;
}
export declare const BeginTransactionRequest: S.Schema<BeginTransactionRequest>;
export interface BeginTransactionResponse {
    transactionId?: string;
}
export declare const BeginTransactionResponse: S.Schema<BeginTransactionResponse>;
export interface CommitTransactionRequest {
    resourceArn: string;
    secretArn: string;
    transactionId: string;
}
export declare const CommitTransactionRequest: S.Schema<CommitTransactionRequest>;
export interface CommitTransactionResponse {
    transactionStatus?: string;
}
export declare const CommitTransactionResponse: S.Schema<CommitTransactionResponse>;
export interface ExecuteSqlRequest {
    dbClusterOrInstanceArn: string;
    awsSecretStoreArn: string;
    sqlStatements: string;
    database?: string;
    schema?: string;
}
export declare const ExecuteSqlRequest: S.Schema<ExecuteSqlRequest>;
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 const ColumnMetadata: S.Schema<ColumnMetadata>;
export type Metadata = ColumnMetadata[];
export declare const Metadata: S.$Array<S.Schema<ColumnMetadata>>;
export interface ResultSetMetadata {
    columnCount?: number;
    columnMetadata?: ColumnMetadata[];
}
export declare const ResultSetMetadata: S.Schema<ResultSetMetadata>;
export type ArrayValueList = Value[];
export declare const ArrayValueList: S.Schema<ArrayValueList>;
export interface StructValue {
    attributes?: Value[];
}
export declare const StructValue: S.Schema<StructValue>;
export type Value = {
    isNull: boolean;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue: boolean;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue: number;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue: number;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue: number;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue: number;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue: string;
    blobValue?: never;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue: Uint8Array;
    arrayValues?: never;
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues: Value[];
    structValue?: never;
} | {
    isNull?: never;
    bitValue?: never;
    bigIntValue?: never;
    intValue?: never;
    doubleValue?: never;
    realValue?: never;
    stringValue?: never;
    blobValue?: never;
    arrayValues?: never;
    structValue: StructValue;
};
export declare const Value: S.Schema<Value>;
export type Row = Value[];
export declare const Row: S.$Array<S.suspend<S.Schema<Value>>>;
export interface Record {
    values?: Value[];
}
export declare const Record: S.Schema<Record>;
export type Records = Record[];
export declare const Records: S.$Array<S.Schema<Record>>;
export interface ResultFrame {
    resultSetMetadata?: ResultSetMetadata;
    records?: Record[];
}
export declare const ResultFrame: S.Schema<ResultFrame>;
export interface SqlStatementResult {
    resultFrame?: ResultFrame;
    numberOfRecordsUpdated?: number;
}
export declare const SqlStatementResult: S.Schema<SqlStatementResult>;
export type SqlStatementResults = SqlStatementResult[];
export declare const SqlStatementResults: S.$Array<S.Schema<SqlStatementResult>>;
export interface ExecuteSqlResponse {
    sqlStatementResults?: SqlStatementResult[];
}
export declare const ExecuteSqlResponse: S.Schema<ExecuteSqlResponse>;
export interface ResultSetOptions {
    decimalReturnType?: string;
    longReturnType?: string;
}
export declare const ResultSetOptions: S.Schema<ResultSetOptions>;
export interface ExecuteStatementRequest {
    resourceArn: string;
    secretArn: string;
    sql: string;
    database?: string;
    schema?: string;
    parameters?: SqlParameter[];
    transactionId?: string;
    includeResultMetadata?: boolean;
    continueAfterTimeout?: boolean;
    resultSetOptions?: ResultSetOptions;
    formatRecordsAs?: string;
}
export declare const ExecuteStatementRequest: S.Schema<ExecuteStatementRequest>;
export type SqlRecords = Field[][];
export declare const SqlRecords: S.$Array<S.$Array<S.Union<readonly [S.Struct<{
    readonly isNull: S.Boolean;
}>, S.Struct<{
    readonly booleanValue: S.Boolean;
}>, S.Struct<{
    readonly longValue: S.Number;
}>, S.Struct<{
    readonly doubleValue: S.Number;
}>, S.Struct<{
    readonly stringValue: S.String;
}>, S.Struct<{
    readonly blobValue: S.decodeTo<S.instanceOf<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>, S.String, never, never>;
}>, S.Struct<{
    readonly arrayValue: S.Schema<ArrayValue>;
}>]>>>;
export interface ExecuteStatementResponse {
    records?: Field[][];
    columnMetadata?: ColumnMetadata[];
    numberOfRecordsUpdated?: number;
    generatedFields?: Field[];
    formattedRecords?: string;
}
export declare const ExecuteStatementResponse: S.Schema<ExecuteStatementResponse>;
export interface RollbackTransactionRequest {
    resourceArn: string;
    secretArn: string;
    transactionId: string;
}
export declare const RollbackTransactionRequest: S.Schema<RollbackTransactionRequest>;
export interface RollbackTransactionResponse {
    transactionStatus?: string;
}
export declare const RollbackTransactionResponse: S.Schema<RollbackTransactionResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const DatabaseErrorException_base: S.Class<DatabaseErrorException, S.TaggedStruct<"DatabaseErrorException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class DatabaseErrorException extends DatabaseErrorException_base {
}
declare const DatabaseNotFoundException_base: S.Class<DatabaseNotFoundException, S.TaggedStruct<"DatabaseNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class DatabaseNotFoundException extends DatabaseNotFoundException_base {
}
declare const DatabaseResumingException_base: S.Class<DatabaseResumingException, S.TaggedStruct<"DatabaseResumingException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class DatabaseResumingException extends DatabaseResumingException_base {
}
declare const DatabaseUnavailableException_base: S.Class<DatabaseUnavailableException, S.TaggedStruct<"DatabaseUnavailableException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        TimeoutError: true;
    };
});
export declare class DatabaseUnavailableException extends DatabaseUnavailableException_base {
}
declare const ForbiddenException_base: S.Class<ForbiddenException, S.TaggedStruct<"ForbiddenException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class ForbiddenException extends ForbiddenException_base {
}
declare const HttpEndpointNotEnabledException_base: S.Class<HttpEndpointNotEnabledException, S.TaggedStruct<"HttpEndpointNotEnabledException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class HttpEndpointNotEnabledException extends HttpEndpointNotEnabledException_base {
}
declare const InternalServerErrorException_base: S.Class<InternalServerErrorException, S.TaggedStruct<"InternalServerErrorException", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerErrorException extends InternalServerErrorException_base {
}
declare const InvalidResourceStateException_base: S.Class<InvalidResourceStateException, S.TaggedStruct<"InvalidResourceStateException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidResourceStateException extends InvalidResourceStateException_base {
}
declare const InvalidSecretException_base: S.Class<InvalidSecretException, S.TaggedStruct<"InvalidSecretException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidSecretException extends InvalidSecretException_base {
}
declare const SecretsErrorException_base: S.Class<SecretsErrorException, S.TaggedStruct<"SecretsErrorException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class SecretsErrorException extends SecretsErrorException_base {
}
declare const ServiceUnavailableError_base: S.Class<ServiceUnavailableError, S.TaggedStruct<"ServiceUnavailableError", {}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class ServiceUnavailableError extends ServiceUnavailableError_base {
}
declare const StatementTimeoutException_base: S.Class<StatementTimeoutException, S.TaggedStruct<"StatementTimeoutException", {
    readonly message: S.optional<S.String>;
    readonly dbConnectionId: S.optional<S.Number>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class StatementTimeoutException extends StatementTimeoutException_base {
}
declare const TransactionNotFoundException_base: S.Class<TransactionNotFoundException, S.TaggedStruct<"TransactionNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TransactionNotFoundException extends TransactionNotFoundException_base {
}
declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NotFoundException extends NotFoundException_base {
}
declare const UnsupportedResultException_base: S.Class<UnsupportedResultException, S.TaggedStruct<"UnsupportedResultException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class UnsupportedResultException extends UnsupportedResultException_base {
}
export type BatchExecuteStatementError = AccessDeniedException | BadRequestException | DatabaseErrorException | DatabaseNotFoundException | DatabaseResumingException | DatabaseUnavailableException | ForbiddenException | HttpEndpointNotEnabledException | InternalServerErrorException | InvalidResourceStateException | InvalidSecretException | SecretsErrorException | ServiceUnavailableError | StatementTimeoutException | TransactionNotFoundException | CommonErrors;
/**
 * Runs a batch SQL statement over an array of data.
 *
 * You can run bulk update and insert operations for multiple records using a DML
 * statement with different parameter sets. Bulk operations can provide a significant
 * performance improvement over individual insert and update operations.
 *
 * If a call isn't part of a transaction because it doesn't include the `transactionID` parameter,
 * changes that result from the call are committed automatically.
 *
 * There isn't a fixed upper limit on the number of parameter sets. However, the maximum size of the HTTP request
 * submitted through the Data API is 4 MiB. If the request exceeds this limit, the Data API returns an error and doesn't
 * process the request. This 4-MiB limit includes the size of the HTTP headers and the JSON notation in the request. Thus, the
 * number of parameter sets that you can include depends on a combination of factors, such as the size of the SQL statement and
 * the size of each parameter set.
 *
 * The response size limit is 1 MiB. If the call returns more than 1 MiB of response data, the call is terminated.
 */
export declare const batchExecuteStatement: API.OperationMethod<BatchExecuteStatementRequest, BatchExecuteStatementResponse, BatchExecuteStatementError, Credentials | Region | HttpClient.HttpClient>;
export type BeginTransactionError = AccessDeniedException | BadRequestException | DatabaseErrorException | DatabaseNotFoundException | DatabaseResumingException | DatabaseUnavailableException | ForbiddenException | HttpEndpointNotEnabledException | InternalServerErrorException | InvalidResourceStateException | InvalidSecretException | SecretsErrorException | ServiceUnavailableError | StatementTimeoutException | TransactionNotFoundException | CommonErrors;
/**
 * Starts a SQL transaction.
 *
 * A transaction can run for a maximum of 24 hours. A transaction is terminated and rolled back automatically after 24
 * hours.
 *
 * A transaction times out if no calls use its transaction ID in three minutes. If a transaction times out before it's
 * committed, it's rolled back automatically.
 *
 * For Aurora MySQL, DDL statements inside a transaction cause an implicit commit. We recommend that you run each MySQL DDL statement in a separate
 * `ExecuteStatement` call with `continueAfterTimeout` enabled.
 */
export declare const beginTransaction: API.OperationMethod<BeginTransactionRequest, BeginTransactionResponse, BeginTransactionError, Credentials | Region | HttpClient.HttpClient>;
export type CommitTransactionError = AccessDeniedException | BadRequestException | DatabaseErrorException | DatabaseNotFoundException | DatabaseUnavailableException | ForbiddenException | HttpEndpointNotEnabledException | InternalServerErrorException | InvalidResourceStateException | InvalidSecretException | NotFoundException | SecretsErrorException | ServiceUnavailableError | StatementTimeoutException | TransactionNotFoundException | CommonErrors;
/**
 * Ends a SQL transaction started with the `BeginTransaction` operation and
 * commits the changes.
 */
export declare const commitTransaction: API.OperationMethod<CommitTransactionRequest, CommitTransactionResponse, CommitTransactionError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteSqlError = AccessDeniedException | BadRequestException | ForbiddenException | InternalServerErrorException | ServiceUnavailableError | CommonErrors;
/**
 * Runs one or more SQL statements.
 *
 * This operation isn't supported for Aurora Serverless v2 and provisioned DB clusters.
 * For Aurora Serverless v1 DB clusters, the operation is deprecated.
 * Use the `BatchExecuteStatement` or `ExecuteStatement` operation.
 */
export declare const executeSql: API.OperationMethod<ExecuteSqlRequest, ExecuteSqlResponse, ExecuteSqlError, Credentials | Region | HttpClient.HttpClient>;
export type ExecuteStatementError = AccessDeniedException | BadRequestException | DatabaseErrorException | DatabaseNotFoundException | DatabaseResumingException | DatabaseUnavailableException | ForbiddenException | HttpEndpointNotEnabledException | InternalServerErrorException | InvalidResourceStateException | InvalidSecretException | SecretsErrorException | ServiceUnavailableError | StatementTimeoutException | TransactionNotFoundException | UnsupportedResultException | CommonErrors;
/**
 * Runs a SQL statement against a database.
 *
 * If a call isn't part of a transaction because it doesn't include the
 * `transactionID` parameter, changes that result from the call are
 * committed automatically.
 *
 * If the binary response data from the database is more than 1 MB, the call is terminated.
 */
export declare const executeStatement: API.OperationMethod<ExecuteStatementRequest, ExecuteStatementResponse, ExecuteStatementError, Credentials | Region | HttpClient.HttpClient>;
export type RollbackTransactionError = AccessDeniedException | BadRequestException | DatabaseErrorException | DatabaseNotFoundException | DatabaseUnavailableException | ForbiddenException | HttpEndpointNotEnabledException | InternalServerErrorException | InvalidResourceStateException | InvalidSecretException | NotFoundException | SecretsErrorException | ServiceUnavailableError | StatementTimeoutException | TransactionNotFoundException | CommonErrors;
/**
 * Performs a rollback of a transaction. Rolling back a transaction cancels its changes.
 */
export declare const rollbackTransaction: API.OperationMethod<RollbackTransactionRequest, RollbackTransactionResponse, RollbackTransactionError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=rds-data.d.ts.map