cdk-rds-sql 5.0.0 → 6.0.0

package/node_modules/@smithy/types/dist-types/ts3.4/retry.d.ts

@@ -1,133 +0,0 @@
-import { SdkError } from "./shapes";
-/**
- * @public
- */
-export type RetryErrorType = 
-/**
- * This is a connection level error such as a socket timeout, socket connect
- * error, tls negotiation timeout etc...
- * Typically these should never be applied for non-idempotent request types
- * since in this scenario, it's impossible to know whether the operation had
- * a side effect on the server.
- */
-"TRANSIENT"
-/**
- * This is an error where the server explicitly told the client to back off,
- * such as a 429 or 503 Http error.
- */
- | "THROTTLING"
-/**
- * This is a server error that isn't explicitly throttling but is considered
- * by the client to be something that should be retried.
- */
- | "SERVER_ERROR"
-/**
- * Doesn't count against any budgets. This could be something like a 401
- * challenge in Http.
- */
- | "CLIENT_ERROR";
-/**
- * @public
- */
-export interface RetryErrorInfo {
-    /**
-     * The error thrown during the initial request, if available.
-     */
-    error?: SdkError;
-    errorType: RetryErrorType;
-    /**
-     * Protocol hint. This could come from Http's 'retry-after' header or
-     * something from MQTT or any other protocol that has the ability to convey
-     * retry info from a peer.
-     *
-     * The Date after which a retry should be attempted.
-     */
-    retryAfterHint?: Date;
-}
-/**
- * @public
- */
-export interface RetryBackoffStrategy {
-    /**
-     * @returns the number of milliseconds to wait before retrying an action.
-     */
-    computeNextBackoffDelay(retryAttempt: number): number;
-}
-/**
- * @public
- */
-export interface StandardRetryBackoffStrategy extends RetryBackoffStrategy {
-    /**
-     * Sets the delayBase used to compute backoff delays.
-     * @param delayBase -
-     */
-    setDelayBase(delayBase: number): void;
-}
-/**
- * @public
- */
-export interface RetryStrategyOptions {
-    backoffStrategy: RetryBackoffStrategy;
-    maxRetriesBase: number;
-}
-/**
- * @public
- */
-export interface RetryToken {
-    /**
-     * @returns the current count of retry.
-     */
-    getRetryCount(): number;
-    /**
-     * @returns the number of milliseconds to wait before retrying an action.
-     */
-    getRetryDelay(): number;
-}
-/**
- * @public
- */
-export interface StandardRetryToken extends RetryToken {
-    /**
-     * @returns the cost of the last retry attempt.
-     */
-    getRetryCost(): number | undefined;
-}
-/**
- * @public
- */
-export interface RetryStrategyV2 {
-    /**
-     * Called before any retries (for the first call to the operation). It either
-     * returns a retry token or an error upon the failure to acquire a token prior.
-     *
-     * tokenScope is arbitrary and out of scope for this component. However,
-     * adding it here offers us a lot of future flexibility for outage detection.
-     * For example, it could be "us-east-1" on a shared retry strategy, or
-     * "us-west-2-c:dynamodb".
-     */
-    acquireInitialRetryToken(retryTokenScope: string): Promise<RetryToken>;
-    /**
-     * After a failed operation call, this function is invoked to refresh the
-     * retryToken returned by acquireInitialRetryToken(). This function can
-     * either choose to allow another retry and send a new or updated token,
-     * or reject the retry attempt and report the error either in an exception
-     * or returning an error.
-     */
-    refreshRetryTokenForRetry(tokenToRenew: RetryToken, errorInfo: RetryErrorInfo): Promise<RetryToken>;
-    /**
-     * Upon successful completion of the operation, this function is called
-     * to record that the operation was successful.
-     */
-    recordSuccess(token: RetryToken): void;
-}
-/**
- * @public
- */
-export type ExponentialBackoffJitterType = "DEFAULT" | "NONE" | "FULL" | "DECORRELATED";
-/**
- * @public
- */
-export interface ExponentialBackoffStrategyOptions {
-    jitterType: ExponentialBackoffJitterType;
-    backoffScaleValue?: number;
-}

package/node_modules/@smithy/types/dist-types/ts3.4/serde.d.ts

@@ -1,111 +0,0 @@
-import { Endpoint } from "./http";
-import { RequestHandler } from "./transfer";
-import { Decoder, Encoder, Provider } from "./util";
-/**
- * @public
- *
- * Interface for object requires an Endpoint set.
- */
-export interface EndpointBearer {
-    endpoint: Provider<Endpoint>;
-}
-/**
- * @public
- */
-export interface StreamCollector {
-    /**
-     * A function that converts a stream into an array of bytes.
-     *
-     * @param stream - The low-level native stream from browser or Nodejs runtime
-     */
-    (stream: any): Promise<Uint8Array>;
-}
-/**
- * @public
- *
- * Request and Response serde util functions and settings for AWS services
- */
-export interface SerdeContext extends SerdeFunctions, EndpointBearer {
-    requestHandler: RequestHandler<any, any>;
-    disableHostPrefix: boolean;
-}
-/**
- * @public
- *
- * Serde functions from the client config.
- */
-export interface SerdeFunctions {
-    base64Encoder: Encoder;
-    base64Decoder: Decoder;
-    utf8Encoder: Encoder;
-    utf8Decoder: Decoder;
-    streamCollector: StreamCollector;
-}
-/**
- * @public
- */
-export interface RequestSerializer<Request, Context extends EndpointBearer = any> {
-    /**
-     * Converts the provided `input` into a request object
-     *
-     * @param input - The user input to serialize.
-     *
-     * @param context - Context containing runtime-specific util functions.
-     */
-    (input: any, context: Context): Promise<Request>;
-}
-/**
- * @public
- */
-export interface ResponseDeserializer<OutputType, ResponseType = any, Context = any> {
-    /**
-     * Converts the output of an operation into JavaScript types.
-     *
-     * @param output - The HTTP response received from the service
-     *
-     * @param context - context containing runtime-specific util functions.
-     */
-    (output: ResponseType, context: Context): Promise<OutputType>;
-}
-/**
- * The interface contains mix-in utility functions to transfer the runtime-specific
- * stream implementation to specified format. Each stream can ONLY be transformed
- * once.
- */
-export interface SdkStreamMixin {
-    transformToByteArray: () => Promise<Uint8Array>;
-    transformToString: (encoding?: string) => Promise<string>;
-    transformToWebStream: () => ReadableStream;
-}
-/**
- * @public
- *
- * The type describing a runtime-specific stream implementation with mix-in
- * utility functions.
- */
-export type SdkStream<BaseStream> = BaseStream & SdkStreamMixin;
-/**
- * @public
- *
- * Indicates that the member of type T with
- * key StreamKey have been extended
- * with the SdkStreamMixin helper methods.
- */
-export type WithSdkStreamMixin<T, StreamKey extends keyof T> = {
-    [key in keyof T]: key extends StreamKey ? SdkStream<T[StreamKey]> : T[key];
-};
-/**
- * Interface for internal function to inject stream utility functions
- * implementation
- *
- * @internal
- */
-export interface SdkStreamMixinInjector {
-    (stream: unknown): SdkStreamMixin;
-}
-/**
- * @internal
- */
-export interface SdkStreamSerdeContext {
-    sdkStreamMixin: SdkStreamMixinInjector;
-}

package/node_modules/@smithy/types/dist-types/ts3.4/shapes.d.ts

@@ -1,81 +0,0 @@
-import { HttpResponse } from "./http";
-import { MetadataBearer } from "./response";
-/**
- * @public
- *
- * A document type represents an untyped JSON-like value.
- *
- * Not all protocols support document types, and the serialization format of a
- * document type is protocol specific. All JSON protocols SHOULD support
- * document types and they SHOULD serialize document types inline as normal
- * JSON values.
- */
-export type DocumentType = null | boolean | number | string | DocumentType[] | {
-    [prop: string]: DocumentType;
-};
-/**
- * @public
- *
- * A structure shape with the error trait.
- * https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait
- */
-export interface RetryableTrait {
-    /**
-     * Indicates that the error is a retryable throttling error.
-     */
-    readonly throttling?: boolean;
-}
-/**
- * @public
- *
- * Type that is implemented by all Smithy shapes marked with the
- * error trait.
- * @deprecated
- */
-export interface SmithyException {
-    /**
-     * The shape ID name of the exception.
-     */
-    readonly name: string;
-    /**
-     * Whether the client or server are at fault.
-     */
-    readonly $fault: "client" | "server";
-    /**
-     * The service that encountered the exception.
-     */
-    readonly $service?: string;
-    /**
-     * Indicates that an error MAY be retried by the client.
-     */
-    readonly $retryable?: RetryableTrait;
-    /**
-     * Reference to low-level HTTP response object.
-     */
-    readonly $response?: HttpResponse;
-}
-/**
- * @public
- *
- * @deprecated See {@link https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/}
- *
- * This type should not be used in your application.
- * Users of the AWS SDK for JavaScript v3 service clients should prefer to
- * use the specific Exception classes corresponding to each operation.
- * These can be found as code in the deserializer for the operation's Command class,
- * or as declarations in the service model file in codegen/sdk-codegen/aws-models.
- *
- * If no exceptions are enumerated by a particular Command operation,
- * the base exception for the service should be used. Each client exports
- * a base ServiceException prefixed with the service name.
- */
-export type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer> & {
-    $metadata?: Partial<MetadataBearer>["$metadata"] & {
-        /**
-         * If present, will have value of true and indicates that the error resulted in a
-         * correction of the clock skew, a.k.a. config.systemClockOffset.
-         * This is specific to AWS SDK and sigv4.
-         */
-        readonly clockSkewCorrected?: true;
-    };
-};

package/node_modules/@smithy/types/dist-types/ts3.4/signature.d.ts

@@ -1,150 +0,0 @@
-import { Message } from "./eventStream";
-import { HttpRequest } from "./http";
-/**
- * @public
- *
- * A `Date` object, a unix (epoch) timestamp in seconds, or a string that can be
- * understood by the JavaScript `Date` constructor.
- */
-export type DateInput = number | string | Date;
-/**
- * @public
- */
-export interface SigningArguments {
-    /**
-     * The date and time to be used as signature metadata. This value should be
-     * a Date object, a unix (epoch) timestamp, or a string that can be
-     * understood by the JavaScript `Date` constructor.If not supplied, the
-     * value returned by `new Date()` will be used.
-     */
-    signingDate?: DateInput;
-    /**
-     * The service signing name. It will override the service name of the signer
-     * in current invocation
-     */
-    signingService?: string;
-    /**
-     * The region name to sign the request. It will override the signing region of the
-     * signer in current invocation
-     */
-    signingRegion?: string;
-}
-/**
- * @public
- */
-export interface RequestSigningArguments extends SigningArguments {
-    /**
-     * A set of strings whose members represents headers that cannot be signed.
-     * All headers in the provided request will have their names converted to
-     * lower case and then checked for existence in the unsignableHeaders set.
-     */
-    unsignableHeaders?: Set<string>;
-    /**
-     * A set of strings whose members represents headers that should be signed.
-     * Any values passed here will override those provided via unsignableHeaders,
-     * allowing them to be signed.
-     *
-     * All headers in the provided request will have their names converted to
-     * lower case before signing.
-     */
-    signableHeaders?: Set<string>;
-}
-/**
- * @public
- */
-export interface RequestPresigningArguments extends RequestSigningArguments {
-    /**
-     * The number of seconds before the presigned URL expires
-     */
-    expiresIn?: number;
-    /**
-     * A set of strings whose representing headers that should not be hoisted
-     * to presigned request's query string. If not supplied, the presigner
-     * moves all the AWS-specific headers (starting with `x-amz-`) to the request
-     * query string. If supplied, these headers remain in the presigned request's
-     * header.
-     * All headers in the provided request will have their names converted to
-     * lower case and then checked for existence in the unhoistableHeaders set.
-     */
-    unhoistableHeaders?: Set<string>;
-}
-/**
- * @public
- */
-export interface EventSigningArguments extends SigningArguments {
-    priorSignature: string;
-}
-/**
- * @public
- */
-export interface RequestPresigner {
-    /**
-     * Signs a request for future use.
-     *
-     * The request will be valid until either the provided `expiration` time has
-     * passed or the underlying credentials have expired.
-     *
-     * @param requestToSign - The request that should be signed.
-     * @param options - Additional signing options.
-     */
-    presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
-}
-/**
- * @public
- *
- * An object that signs request objects with AWS credentials using one of the
- * AWS authentication protocols.
- */
-export interface RequestSigner {
-    /**
-     * Sign the provided request for immediate dispatch.
-     */
-    sign(requestToSign: HttpRequest, options?: RequestSigningArguments): Promise<HttpRequest>;
-}
-/**
- * @public
- */
-export interface StringSigner {
-    /**
-     * Sign the provided `stringToSign` for use outside of the context of
-     * request signing. Typical uses include signed policy generation.
-     */
-    sign(stringToSign: string, options?: SigningArguments): Promise<string>;
-}
-/**
- * @public
- */
-export interface FormattedEvent {
-    headers: Uint8Array;
-    payload: Uint8Array;
-}
-/**
- * @public
- */
-export interface EventSigner {
-    /**
-     * Sign the individual event of the event stream.
-     */
-    sign(event: FormattedEvent, options: EventSigningArguments): Promise<string>;
-}
-/**
- * @public
- */
-export interface SignableMessage {
-    message: Message;
-    priorSignature: string;
-}
-/**
- * @public
- */
-export interface SignedMessage {
-    message: Message;
-    signature: string;
-}
-/**
- * @public
- */
-export interface MessageSigner {
-    signMessage(message: SignableMessage, args: SigningArguments): Promise<SignedMessage>;
-    sign(event: SignableMessage, options: SigningArguments): Promise<SignedMessage>;
-}

package/node_modules/@smithy/types/dist-types/ts3.4/stream.d.ts

@@ -1,22 +0,0 @@
-import { ChecksumConstructor } from "./checksum";
-import { HashConstructor, StreamHasher } from "./crypto";
-import { BodyLengthCalculator, Encoder } from "./util";
-/**
- * @public
- */
-export interface GetAwsChunkedEncodingStreamOptions {
-    base64Encoder?: Encoder;
-    bodyLengthChecker: BodyLengthCalculator;
-    checksumAlgorithmFn?: ChecksumConstructor | HashConstructor;
-    checksumLocationName?: string;
-    streamHasher?: StreamHasher;
-}
-/**
- * @public
- *
- * A function that returns Readable Stream which follows aws-chunked encoding stream.
- * It optionally adds checksum if options are provided.
- */
-export interface GetAwsChunkedEncodingStream<StreamType = any> {
-    (readableStream: StreamType, options: GetAwsChunkedEncodingStreamOptions): StreamType;
-}

package/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-common-types.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import { Readable } from "stream";
-import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
-/**
- * @public
- *
- * This is the union representing the modeled blob type with streaming trait
- * in a generic format that does not relate to HTTP input or output payloads.
- *
- * Note: the non-streaming blob type is represented by Uint8Array, but because
- * the streaming blob type is always in the request/response paylod, it has
- * historically been handled with different types.
- *
- * @see https://smithy.io/2.0/spec/simple-types.html#blob
- *
- * For compatibility with its historical representation, it must contain at least
- * Readble (Node.js), Blob (browser), and ReadableStream (browser).
- *
- * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
- */
-export type StreamingBlobTypes = NodeJsRuntimeStreamingBlobTypes | BrowserRuntimeStreamingBlobTypes;
-/**
- * @public
- *
- * Node.js streaming blob type.
- */
-export type NodeJsRuntimeStreamingBlobTypes = Readable;
-/**
- * @public
- *
- * Browser streaming blob types.
- */
-export type BrowserRuntimeStreamingBlobTypes = ReadableStreamOptionalType | BlobOptionalType;

package/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-payload-input-types.d.ts

@@ -1,61 +0,0 @@
-/// <reference types="node" />
-import { Readable } from "stream";
-import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
-/**
- * @public
- *
- * This union represents a superset of the compatible types you
- * can use for streaming payload inputs.
- *
- * FAQ:
- * Why does the type union mix mutually exclusive runtime types, namely
- * Node.js and browser types?
- *
- * There are several reasons:
- * 1. For backwards compatibility.
- * 2. As a convenient compromise solution so that users in either environment may use the types
- *    without customization.
- * 3. The SDK does not have static type information about the exact implementation
- *    of the HTTP RequestHandler being used in your client(s) (e.g. fetch, XHR, node:http, or node:http2),
- *    given that it is chosen at runtime. There are multiple possible request handlers
- *    in both the Node.js and browser runtime environments.
- *
- *    Rather than restricting the type to a known common format (Uint8Array, for example)
- *    which doesn't include a universal streaming format in the currently supported Node.js versions,
- *    the type declaration is widened to multiple possible formats.
- *    It is up to the user to ultimately select a compatible format with the
- *    runtime and HTTP handler implementation they are using.
- *
- * Usage:
- *    The typical solution we expect users to have is to manually narrow the
- *    type when needed, picking the appropriate one out of the union according to the
- *    runtime environment and specific request handler.
- *    There is also the type utility "NodeJsClient", "BrowserClient" and more
- *    exported from this package. These can be applied at the client level
- *    to pre-narrow these streaming payload blobs. For usage see the readme.md
- *    in the root of the @smithy/types NPM package.
- */
-export type StreamingBlobPayloadInputTypes = NodeJsRuntimeStreamingBlobPayloadInputTypes | BrowserRuntimeStreamingBlobPayloadInputTypes;
-/**
- * @public
- *
- * Streaming payload input types in the Node.js environment.
- * These are derived from the types compatible with the request body used by node:http.
- *
- * Note: not all types are signable by the standard SignatureV4 signer when
- * used as the request body. For example, in Node.js a Readable stream
- * is not signable by the default signer.
- * They are included in the union because it may be intended in some cases,
- * but the expected types are primarily string, Uint8Array, and Buffer.
- *
- * Additional details may be found in the internal
- * function "getPayloadHash" in the SignatureV4 module.
- */
-export type NodeJsRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | Buffer | Readable;
-/**
- * @public
- *
- * Streaming payload input types in the browser environment.
- * These are derived from the types compatible with fetch's Request.body.
- */
-export type BrowserRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | ReadableStreamOptionalType | BlobOptionalType;

package/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -1,52 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage } from "http";
-import { Readable } from "stream";
-import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
-import { SdkStream } from "../serde";
-/**
- * @public
- *
- * This union represents a superset of the types you may receive
- * in streaming payload outputs.
- *
- * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
- *
- * To highlight the upstream docs about the SdkStream mixin:
- *
- * The interface contains mix-in (via Object.assign) methods to transform the runtime-specific
- * stream implementation to specified format. Each stream can ONLY be transformed
- * once.
- *
- * The available methods are described on the SdkStream type via SdkStreamMixin.
- */
-export type StreamingBlobPayloadOutputTypes = NodeJsRuntimeStreamingBlobPayloadOutputTypes | BrowserRuntimeStreamingBlobPayloadOutputTypes;
-/**
- * @public
- *
- * Streaming payload output types in the Node.js environment.
- *
- * This is by default the IncomingMessage type from node:http responses when
- * using the default node-http-handler in Node.js environments.
- *
- * It can be other Readable types like node:http2's ClientHttp2Stream
- * such as when using the node-http2-handler.
- *
- * The SdkStreamMixin adds methods on this type to help transform (collect) it to
- * other formats.
- */
-export type NodeJsRuntimeStreamingBlobPayloadOutputTypes = SdkStream<IncomingMessage | Readable>;
-/**
- * @public
- *
- * Streaming payload output types in the browser environment.
- *
- * This is by default fetch's Response.body type (ReadableStream) when using
- * the default fetch-http-handler in browser-like environments.
- *
- * It may be a Blob, such as when using the XMLHttpRequest handler
- * and receiving an arraybuffer response body.
- *
- * The SdkStreamMixin adds methods on this type to help transform (collect) it to
- * other formats.
- */
-export type BrowserRuntimeStreamingBlobPayloadOutputTypes = SdkStream<ReadableStreamOptionalType | BlobOptionalType>;

package/node_modules/@smithy/types/dist-types/ts3.4/transfer.d.ts

@@ -1,33 +0,0 @@
-/**
- * @public
- */
-export type RequestHandlerOutput<ResponseType> = {
-    response: ResponseType;
-};
-/**
- * @public
- */
-export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
-    /**
-     * metadata contains information of a handler. For example
-     * 'h2' refers this handler is for handling HTTP/2 requests,
-     * whereas 'h1' refers handling HTTP1 requests
-     */
-    metadata?: RequestHandlerMetadata;
-    destroy?: () => void;
-    handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
-}
-/**
- * @public
- */
-export interface RequestHandlerMetadata {
-    handlerProtocol: RequestHandlerProtocol | string;
-}
-export declare enum RequestHandlerProtocol {
-    HTTP_0_9 = "http/0.9",
-    HTTP_1_0 = "http/1.0",
-    TDS_8_0 = "tds/8.0"
-}
-export interface RequestContext {
-    destination: URL;
-}