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

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/serde.d.ts

@@ -1,112 +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.
- * @public
- */
-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-crypto/util/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-common-types.d.ts

@@ -1,33 +0,0 @@
-/// <reference types="node" />
-import type { Readable } from "stream";
-import type { 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-crypto/util/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-input-types.d.ts

@@ -1,63 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Readable } from "stream";
-import type { 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-crypto/util/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -1,53 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { IncomingMessage } from "http";
-import type { Readable } from "stream";
-import type { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
-import type { 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-crypto/util/node_modules/@smithy/types/dist-types/transfer.d.ts

@@ -1,41 +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;
-}
-/**
- * @public
- * Values from ALPN Protocol IDs.
- * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
- */
-export declare enum RequestHandlerProtocol {
-    HTTP_0_9 = "http/0.9",
-    HTTP_1_0 = "http/1.0",
-    TDS_8_0 = "tds/8.0"
-}
-/**
- * @public
- */
-export interface RequestContext {
-    destination: URL;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/transform/client-payload-blob-type-narrow.d.ts

@@ -1,79 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { IncomingMessage } from "http";
-import type { ClientHttp2Stream } from "http2";
-import type { InvokeMethod } from "../client";
-import type { GetOutputType } from "../command";
-import type { HttpHandlerOptions } from "../http";
-import type { SdkStream } from "../serde";
-import type { BrowserRuntimeStreamingBlobPayloadInputTypes, NodeJsRuntimeStreamingBlobPayloadInputTypes, StreamingBlobPayloadInputTypes } from "../streaming-payload/streaming-blob-payload-input-types";
-import type { StreamingBlobPayloadOutputTypes } from "../streaming-payload/streaming-blob-payload-output-types";
-import type { NarrowedInvokeMethod } from "./client-method-transforms";
-import type { Transform } from "./type-transform";
-/**
- * @public
- *
- * Creates a type with a given client type that narrows payload blob output
- * types to SdkStream<IncomingMessage>.
- *
- * This can be used for clients with the NodeHttpHandler requestHandler,
- * the default in Node.js when not using HTTP2.
- *
- * Usage example:
- * ```typescript
- * const client = new YourClient({}) as NodeJsClient<YourClient>;
- * ```
- */
-export type NodeJsClient<ClientType extends object> = NarrowPayloadBlobTypes<NodeJsRuntimeStreamingBlobPayloadInputTypes, SdkStream<IncomingMessage>, ClientType>;
-/**
- * @public
- * Variant of NodeJsClient for node:http2.
- */
-export type NodeJsHttp2Client<ClientType extends object> = NarrowPayloadBlobTypes<NodeJsRuntimeStreamingBlobPayloadInputTypes, SdkStream<ClientHttp2Stream>, ClientType>;
-/**
- * @public
- *
- * Creates a type with a given client type that narrows payload blob output
- * types to SdkStream<ReadableStream>.
- *
- * This can be used for clients with the FetchHttpHandler requestHandler,
- * which is the default in browser environments.
- *
- * Usage example:
- * ```typescript
- * const client = new YourClient({}) as BrowserClient<YourClient>;
- * ```
- */
-export type BrowserClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream>, ClientType>;
-/**
- * @public
- *
- * Variant of BrowserClient for XMLHttpRequest.
- */
-export type BrowserXhrClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream | Blob>, ClientType>;
-/**
- * @public
- *
- * @deprecated use NarrowPayloadBlobTypes<I, O, ClientType>.
- *
- * Narrow a given Client's blob payload outputs to the given type T.
- */
-export type NarrowPayloadBlobOutputType<T, ClientType extends object> = {
-    [key in keyof ClientType]: [ClientType[key]] extends [
-        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
-    ] ? NarrowedInvokeMethod<T, HttpHandlerOptions, FunctionInputTypes, FunctionOutputTypes> : ClientType[key];
-} & {
-    send<Command>(command: Command, options?: any): Promise<Transform<GetOutputType<Command>, StreamingBlobPayloadOutputTypes | undefined, T>>;
-};
-/**
- * @public
- *
- * Narrow a Client's blob payload input and output types to I and O.
- */
-export type NarrowPayloadBlobTypes<I, O, ClientType extends object> = {
-    [key in keyof ClientType]: [ClientType[key]] extends [
-        InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>
-    ] ? NarrowedInvokeMethod<O, HttpHandlerOptions, Transform<FunctionInputTypes, StreamingBlobPayloadInputTypes | undefined, I>, FunctionOutputTypes> : ClientType[key];
-} & {
-    send<Command>(command: Command, options?: any): Promise<Transform<GetOutputType<Command>, StreamingBlobPayloadOutputTypes | undefined, O>>;
-};

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

@@ -1,41 +0,0 @@
-/// <reference types="node" />
-import { Readable } from "stream";
-import { BlobOptionalType, ReadableStreamOptionalType } from "../externals-check/browser-externals-check";
-/**
- * @public
- *
- * A union of types that can be used as inputs for the service model
- * "blob" type when it represents the request's entire payload or body.
- *
- * For example, in Lambda::invoke, the payload is modeled as a blob type
- * and this union applies to it.
- * In contrast, in Lambda::createFunction the Zip file option is a blob type,
- * but is not the (entire) payload and this union does not apply.
- *
- * 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 work in some cases,
- * but the expected types are primarily string and Uint8Array.
- *
- * Additional details may be found in the internal
- * function "getPayloadHash" in the SignatureV4 module.
- */
-export type BlobPayloadInputTypes = string | ArrayBuffer | ArrayBufferView | Uint8Array | NodeJsRuntimeBlobTypes | BrowserRuntimeBlobTypes;
-/**
- * @public
- *
- * Additional blob types for the Node.js environment.
- */
-export type NodeJsRuntimeBlobTypes = Readable | Buffer;
-/**
- * @public
- *
- * Additional blob types for the browser environment.
- */
-export type BrowserRuntimeBlobTypes = BlobOptionalType | ReadableStreamOptionalType;
-/**
- * @internal
- * @deprecated renamed to BlobPayloadInputTypes.
- */
-export type BlobTypes = BlobPayloadInputTypes;

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/client.d.ts

@@ -1,57 +0,0 @@
-import { Command } from "./command";
-import { MiddlewareStack } from "./middleware";
-import { MetadataBearer } from "./response";
-import { OptionalParameter } from "./util";
-/**
- * @public
- *
- * A type which checks if the client configuration is optional.
- * If all entries of the client configuration are optional, it allows client creation without passing any config.
- */
-export type CheckOptionalClientConfig<T> = OptionalParameter<T>;
-/**
- * @public
- *
- * function definition for different overrides of client's 'send' function.
- */
-export interface InvokeFunction<InputTypes extends object, OutputTypes extends MetadataBearer, ResolvedClientConfiguration> {
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any): Promise<OutputType>;
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, cb: (err: any, data?: OutputType) => void): void;
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options: any, cb: (err: any, data?: OutputType) => void): void;
-    <InputType extends InputTypes, OutputType extends OutputTypes>(command: Command<InputTypes, InputType, OutputTypes, OutputType, ResolvedClientConfiguration>, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
-}
-/**
- * @public
- *
- * Signature that appears on aggregated clients' methods.
- */
-export interface InvokeMethod<InputType extends object, OutputType extends MetadataBearer> {
-    (input: InputType, options?: any): Promise<OutputType>;
-    (input: InputType, cb: (err: any, data?: OutputType) => void): void;
-    (input: InputType, options: any, cb: (err: any, data?: OutputType) => void): void;
-    (input: InputType, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
-}
-/**
- * @public
- *
- * Signature that appears on aggregated clients' methods when argument is optional.
- */
-export interface InvokeMethodOptionalArgs<InputType extends object, OutputType extends MetadataBearer> {
-    (): Promise<OutputType>;
-    (input: InputType, options?: any): Promise<OutputType>;
-    (input: InputType, cb: (err: any, data?: OutputType) => void): void;
-    (input: InputType, options: any, cb: (err: any, data?: OutputType) => void): void;
-    (input: InputType, options?: any, cb?: (err: any, data?: OutputType) => void): Promise<OutputType> | void;
-}
-/**
- * A general interface for service clients, idempotent to browser or node clients
- * This type corresponds to SmithyClient(https://github.com/aws/aws-sdk-js-v3/blob/main/packages/smithy-client/src/client.ts).
- * It's provided for using without importing the SmithyClient class.
- * @internal
- */
-export interface Client<Input extends object, Output extends MetadataBearer, ResolvedClientConfiguration> {
-    readonly config: ResolvedClientConfiguration;
-    middlewareStack: MiddlewareStack<Input, Output>;
-    send: InvokeFunction<Input, Output, ResolvedClientConfiguration>;
-    destroy: () => void;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/command.d.ts

@@ -1,23 +0,0 @@
-import { Handler, MiddlewareStack } from "./middleware";
-import { MetadataBearer } from "./response";
-/**
- * @public
- */
-export interface Command<ClientInput extends object, InputType extends ClientInput, ClientOutput extends MetadataBearer, OutputType extends ClientOutput, ResolvedConfiguration> extends CommandIO<InputType, OutputType> {
-    readonly input: InputType;
-    readonly middlewareStack: MiddlewareStack<InputType, OutputType>;
-    resolveMiddleware(stack: MiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedConfiguration, options: any): Handler<InputType, OutputType>;
-}
-/**
- * @internal
- *
- * This is a subset of the Command type used only to detect the i/o types.
- */
-export interface CommandIO<InputType extends object, OutputType extends MetadataBearer> {
-    readonly input: InputType;
-    resolveMiddleware(stack: any, configuration: any, options: any): Handler<InputType, OutputType>;
-}
-/**
- * @internal
- */
-export type GetOutputType<Command> = Command extends CommandIO<any, infer O> ? O : never;

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/connection/config.d.ts

@@ -1,10 +0,0 @@
-/**
- * @public
- */
-export interface ConnectConfiguration {
-    /**
-     * The maximum time in milliseconds that the connection phase of a request
-     * may take before the connection attempt is abandoned.
-     */
-    requestTimeout?: number;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/connection/manager.d.ts

@@ -1,34 +0,0 @@
-import { RequestContext } from "../transfer";
-import { ConnectConfiguration } from "./config";
-/**
- * @public
- */
-export interface ConnectionManagerConfiguration {
-    /**
-     * Maximum number of allowed concurrent requests per connection.
-     */
-    maxConcurrency?: number;
-    /**
-     * Disables concurrent requests per connection.
-     */
-    disableConcurrency?: boolean;
-}
-/**
- * @public
- */
-export interface ConnectionManager<T> {
-    /**
-     * Retrieves a connection from the connection pool if available,
-     * otherwise establish a new connection
-     */
-    lease(requestContext: RequestContext, connectionConfiguration: ConnectConfiguration): T;
-    /**
-     * Releases the connection back to the pool making it potentially
-     * re-usable by other requests.
-     */
-    release(requestContext: RequestContext, connection: T): void;
-    /**
-     * Destroys the connection manager. All connections will be closed.
-     */
-    destroy(): void;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/connection/pool.d.ts

@@ -1,32 +0,0 @@
-/**
- * @public
- */
-export interface ConnectionPool<T> {
-    /**
-     * Retrieve the first connection in the pool
-     */
-    poll(): T | void;
-    /**
-     * Release the connection back to the pool making it potentially
-     * re-usable by other requests.
-     */
-    offerLast(connection: T): void;
-    /**
-     * Removes the connection from the pool, and destroys it.
-     */
-    destroy(connection: T): void;
-    /**
-     * Implements the iterable protocol and allows arrays to be consumed
-     * by most syntaxes expecting iterables, such as the spread syntax
-     * and for...of loops
-     */
-    [Symbol.iterator](): Iterator<T>;
-}
-/**
- * Unused.
- * @internal
- * @deprecated
- */
-export interface CacheKey {
-    destination: string;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/encode.d.ts

@@ -1,31 +0,0 @@
-import { Message } from "./eventStream";
-/**
- * @public
- */
-export interface MessageEncoder {
-    encode(message: Message): Uint8Array;
-}
-/**
- * @public
- */
-export interface MessageDecoder {
-    decode(message: ArrayBufferView): Message;
-    feed(message: ArrayBufferView): void;
-    endOfStream(): void;
-    getMessage(): AvailableMessage;
-    getAvailableMessages(): AvailableMessages;
-}
-/**
- * @public
- */
-export interface AvailableMessage {
-    getMessage(): Message | undefined;
-    isEndOfStream(): boolean;
-}
-/**
- * @public
- */
-export interface AvailableMessages {
-    getMessages(): Message[];
-    isEndOfStream(): boolean;
-}

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/endpoints/EndpointRuleObject.d.ts

@@ -1,27 +0,0 @@
-import { EndpointObjectProperty } from "../endpoint";
-import { ConditionObject, Expression } from "./shared";
-/**
- * @public
- */
-export type EndpointObjectProperties = Record<string, EndpointObjectProperty>;
-/**
- * @public
- */
-export type EndpointObjectHeaders = Record<string, Expression[]>;
-/**
- * @public
- */
-export type EndpointObject = {
-    url: Expression;
-    properties?: EndpointObjectProperties;
-    headers?: EndpointObjectHeaders;
-};
-/**
- * @public
- */
-export type EndpointRuleObject = {
-    type: "endpoint";
-    conditions?: ConditionObject[];
-    endpoint: EndpointObject;
-    documentation?: string;
-};

package/node_modules/@aws-crypto/util/node_modules/@smithy/types/dist-types/ts3.4/endpoints/ErrorRuleObject.d.ts

@@ -1,10 +0,0 @@
-import { ConditionObject, Expression } from "./shared";
-/**
- * @public
- */
-export type ErrorRuleObject = {
-    type: "error";
-    conditions?: ConditionObject[];
-    error: Expression;
-    documentation?: string;
-};