@aws-amplify/graphql-api-construct 1.20.1 → 1.20.3

package/node_modules/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/retry.d.ts

@@ -0,0 +1,133 @@
+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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/serde.d.ts

@@ -0,0 +1,111 @@
+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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/shapes.d.ts

@@ -0,0 +1,82 @@
+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;
+    };
+    cause?: Error;
+};

package/node_modules/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/signature.d.ts

@@ -0,0 +1,155 @@
+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>;
+    /**
+     * This overrides any headers with the same name(s) set by unhoistableHeaders.
+     * These headers will be hoisted into the query string and signed.
+     */
+    hoistableHeaders?: 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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/stream.d.ts

@@ -0,0 +1,22 @@
+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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-common-types.d.ts

@@ -0,0 +1,33 @@
+/// <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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-payload-input-types.d.ts

@@ -0,0 +1,61 @@
+/// <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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -0,0 +1,52 @@
+/// <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/@aws-amplify/ai-constructs/node_modules/@aws-sdk/util-endpoints/node_modules/@smithy/types/dist-types/ts3.4/transfer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @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;
+}