@caitlyn-ai/sdk-core 0.0.1 → 0.1.0

package/dist-types/index.d.ts

@@ -1,12 +1,3169 @@
-export { CaitlynRestJsonProtocol, type WithRaw } from './protocol.js';
-export { getCaitlynSdkPlugin, NotSupportedByServer, CAITLYN_SDK_USER_AGENT_PREFIX } from './plugin.js';
-export { CaitlynRetryStrategy, NO_RETRY } from './retry.js';
-export { caitlynEndpointProvider } from './endpoint.js';
-export { getCaitlynTelemetryPlugin } from './telemetry.js';
-export { SseStream, type SseSpec } from './stream.js';
-export { parseSse, type SseMessage } from './sse.js';
-export { uploadFile, type UploadMeta, type UploadSlot } from './upload.js';
-export { clientConfig, createAuth, workspaceEndpoint, type CaitlynOptions, type CallOptions, type CaitlynErrorFields, type CaitlynFieldError } from './client.js';
-export { AuthSession, CaitlynAuthError, workspaceAudience, workspaceHost, getCaitlynAuthPlugin, tokenIdentityProvider, type AuthOptions, type OAuthTokens, type TokenStore } from './auth.js';
-export { signV4, getWebIdentityToken, defaultAwsCredentials, type AwsCredentials, type AwsCredentialSource } from './aws.js';
-export { waitUntil, WaiterError, type WaiterOptions, type WaiterState } from './waiter.js';
+/** Stand-in for node:http's Agent, so these types need no @types/node. */
+interface Agent {}
+/** Stand-in for node:http's AgentOptions, so these types need no @types/node. */
+interface AgentOptions {}
+/** Stand-in for node:https's Agent, so these types need no @types/node. */
+interface Agent$1 {}
+/** Stand-in for node:https's AgentOptions, so these types need no @types/node. */
+interface AgentOptions$1 {}
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { TracerProvider, Tracer } from '@opentelemetry/api';
+
+/**
+ * @public
+ */
+interface AbortHandler {
+    (this: AbortSignal | AbortSignal$1, ev: any): any;
+}
+
+/**
+ * Holders of an AbortSignal object may query if the associated operation has
+ * been aborted and register an onabort handler.
+ *
+ * @public
+ * @deprecated use platform (global) type for AbortSignal.
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+ */
+interface AbortSignal$1 {
+    /**
+     * Whether the action represented by this signal has been cancelled.
+     */
+    readonly aborted: boolean;
+    /**
+     * A function to be invoked when the action represented by this signal has
+     * been cancelled.
+     */
+    onabort: AbortHandler | Function | null;
+}
+
+/**
+ * Authentication schemes represent a way that the service will authenticate the customer’s identity.
+ *
+ * @internal
+ */
+interface AuthScheme {
+    /**
+     * @example "sigv4a" or "sigv4"
+     */
+    name: "sigv4" | "sigv4a" | string;
+    /**
+     * @example "s3"
+     */
+    signingName: string;
+    /**
+     * @example "us-east-1"
+     */
+    signingRegion: string;
+    /**
+     * @example ["*"]
+     * @example ["us-west-2", "us-east-1"]
+     */
+    signingRegionSet?: string[];
+    /**
+     * @deprecated this field was renamed to signingRegion.
+     */
+    signingScope?: never;
+    properties: Record<string, unknown>;
+}
+/**
+ * @deprecated
+ *
+ * @internal
+ */
+interface HttpAuthDefinition {
+    /**
+     * Defines the location of where the Auth is serialized.
+     */
+    in: HttpAuthLocation;
+    /**
+     * Defines the name of the HTTP header or query string parameter
+     * that contains the Auth.
+     */
+    name: string;
+    /**
+     * Defines the security scheme to use on the `Authorization` header value.
+     * This can only be set if the "in" property is set to {@link HttpAuthLocation.HEADER}.
+     */
+    scheme?: string;
+}
+/**
+ * @deprecated
+ *
+ * @internal
+ */
+declare enum HttpAuthLocation {
+    HEADER = "header",
+    QUERY = "query"
+}
+
+/**
+ * @public
+ */
+interface Identity {
+    /**
+     * A `Date` when the identity or credential will no longer be accepted.
+     */
+    readonly expiration?: Date;
+}
+
+/**
+ * @public
+ */
+interface ResponseMetadata {
+    /**
+     * The status code of the last HTTP response received for this operation.
+     */
+    httpStatusCode?: number;
+    /**
+     * A unique identifier for the last request sent for this operation. Often
+     * requested by AWS service teams to aid in debugging.
+     */
+    requestId?: string;
+    /**
+     * A secondary identifier for the last request sent. Used for debugging.
+     */
+    extendedRequestId?: string;
+    /**
+     * A tertiary identifier for the last request sent. Used for debugging.
+     */
+    cfId?: string;
+    /**
+     * The number of times this operation was attempted.
+     */
+    attempts?: number;
+    /**
+     * The total amount of time (in milliseconds) that was spent waiting between
+     * retry attempts.
+     */
+    totalRetryDelay?: number;
+}
+/**
+ * @public
+ */
+interface MetadataBearer {
+    /**
+     * Metadata pertaining to this request.
+     */
+    $metadata: ResponseMetadata;
+}
+
+/**
+ * @public
+ */
+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>;
+    /**
+     * This should be OperationSchema from @smithy/types, but would
+     * create problems with the client transform type adaptors.
+     */
+    readonly schema?: any;
+    resolveMiddleware(stack: MiddlewareStack<ClientInput, ClientOutput>, configuration: ResolvedConfiguration, options: any): Handler<InputType, OutputType>;
+}
+/**
+ * This is a subset of the Command type used only to detect the i/o types.
+ *
+ * @internal
+ */
+interface CommandIO<InputType extends object, OutputType extends MetadataBearer> {
+    readonly input: InputType;
+    resolveMiddleware(stack: any, configuration: any, options: any): Handler<InputType, OutputType>;
+}
+
+/**
+ * @public
+ */
+type EndpointObjectProperty = string | boolean | {
+    [key: string]: EndpointObjectProperty;
+} | EndpointObjectProperty[];
+/**
+ * @public
+ */
+interface EndpointV2 {
+    url: URL;
+    properties?: {
+        authSchemes?: AuthScheme[];
+    } & Record<string, EndpointObjectProperty>;
+    headers?: Record<string, string[]>;
+}
+
+/**
+ * @internal
+ */
+type SmithyFeatures = Partial<{
+    RESOURCE_MODEL: "A";
+    WAITER: "B";
+    PAGINATOR: "C";
+    RETRY_MODE_LEGACY: "D";
+    RETRY_MODE_STANDARD: "E";
+    RETRY_MODE_ADAPTIVE: "F";
+    GZIP_REQUEST_COMPRESSION: "L";
+    PROTOCOL_RPC_V2_CBOR: "M";
+    ENDPOINT_OVERRIDE: "N";
+    SIGV4A_SIGNING: "S";
+    CREDENTIALS_CODE: "e";
+}>;
+
+/**
+ * Represents a logger object that is available in HandlerExecutionContext
+ * throughout the middleware stack.
+ *
+ * @public
+ */
+interface Logger {
+    trace?: (...content: any[]) => void;
+    debug: (...content: any[]) => void;
+    info: (...content: any[]) => void;
+    warn: (...content: any[]) => void;
+    error: (...content: any[]) => void;
+}
+
+/**
+ * Outcome of a request, recorded by the framework via {@link MetricsRecorder.recordRequestOutcome}.
+ *
+ * @public
+ */
+type RequestOutcome = "Success" | "Fault";
+/**
+ * Unit attached to a recorded metric value. The vocabulary follows the
+ * CloudWatch unit names so backends that emit to CloudWatch can pass it
+ * through, but it carries no backend-specific semantics — a recorder is free
+ * to map or ignore it.
+ *
+ * @public
+ */
+type MetricUnit = "Seconds" | "Microseconds" | "Milliseconds" | "Bytes" | "Kilobytes" | "Megabytes" | "Gigabytes" | "Terabytes" | "Bits" | "Kilobits" | "Megabits" | "Gigabits" | "Terabits" | "Percent" | "Count" | "None" | "Bytes/Second" | "Kilobytes/Second" | "Megabytes/Second" | "Gigabytes/Second" | "Terabytes/Second" | "Bits/Second" | "Kilobits/Second" | "Megabits/Second" | "Gigabits/Second" | "Terabits/Second" | "Count/Second";
+/**
+ * Backend-agnostic recorder for per-request metrics. The framework drives the
+ * lifecycle of recorders obtained from a factory and records request-level
+ * metrics through this interface; user handlers record their own business
+ * metrics through the same methods. Concrete recorders (e.g. an EMF recorder,
+ * or a future OpenTelemetry recorder) translate these abstract calls into their
+ * own primitives.
+ *
+ * @typeParam Native - the concrete backend handle returned by
+ *   {@link MetricsRecorder.getMetrics}, e.g. an OpenTelemetry `Meter`. The
+ *   parameter is required so that native access is always typed rather than
+ *   erased to `unknown`.
+ *
+ * @public
+ */
+interface MetricsRecorder<Native> {
+    /**
+     * Open the recorder for the current request. Called by the framework once at
+     * the start of request handling when it owns the recorder.
+     */
+    begin(): void;
+    /**
+     * Close the recorder for the current request. Called by the framework once at
+     * the end of request handling when it owns the recorder; this is where an
+     * implementation typically flushes its event.
+     */
+    end(): void;
+    /**
+     * Records the outcome and duration of a request. The concrete backend decides
+     * how to express this.
+     */
+    recordRequestOutcome(outcome: RequestOutcome, durationMs: number): void;
+    /**
+     * Records a count. Values should be non-negative for cross-backend portability.
+     */
+    addCount(name: string, value: number): void;
+    /**
+     * Records a duration in milliseconds.
+     */
+    addTime(name: string, value: number): void;
+    /**
+     * Records a level — a sampled value that should average meaningfully across
+     * calls (e.g. queue depth, batch size).
+     */
+    addLevel(name: string, value: number, unit?: MetricUnit): void;
+    /**
+     * Records a discrete data point where percentiles matter (e.g. per-call
+     * latency, item size).
+     */
+    addMetric(name: string, value: number, unit?: MetricUnit): void;
+    /**
+     * Records a unitless ratio (e.g. cache hit rate, throttle rate).
+     */
+    addRatio(name: string, value: number): void;
+    /**
+     * Attaches a property to the request's metrics. A nullish or empty value
+     * removes the property.
+     */
+    setProperty(name: string, value: string | null | undefined): void;
+    /**
+     * Returns the recorder's native backend handle, so callers can reach
+     * library-specific features the abstract methods do not expose (e.g. an
+     * OpenTelemetry `Meter`).
+     */
+    getMetrics(): Native;
+}
+
+/**
+ * Represents the components parts of a Uniform Resource Identifier used to
+ * construct the target location of a Request.
+ *
+ * @internal
+ */
+type URI = {
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query?: QueryParameterBag;
+    username?: string;
+    password?: string;
+    fragment?: string;
+};
+
+/**
+ * @public
+ *
+ * @deprecated use {@link EndpointV2} from `@smithy/types`.
+ */
+interface Endpoint {
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query?: QueryParameterBag;
+    headers?: HeaderBag;
+}
+/**
+ * Interface an HTTP request class. Contains
+ * addressing information in addition to standard message properties.
+ *
+ * @public
+ */
+interface HttpRequest$1 extends HttpMessage, URI {
+    method: string;
+}
+/**
+ * Represents an HTTP message as received in reply to a request. Contains a
+ * numeric status code in addition to standard message properties.
+ *
+ * @public
+ */
+interface HttpResponse$1 extends HttpMessage {
+    statusCode: number;
+    reason?: string;
+}
+/**
+ * A mapping of query parameter names to strings or arrays of strings, with the
+ * second being used when a parameter contains a list of values. Value can be set
+ * to null when query is not in key-value pairs shape
+ *
+ * @public
+ */
+type QueryParameterBag = Record<string, string | Array<string> | null>;
+/**
+ * A mapping of header names to string values. Multiple values for the same
+ * header should be represented as a single string with values separated by
+ * `, `.
+ * Keys should be considered case insensitive, even if this is not enforced by a
+ * particular implementation. For example, given the following HeaderBag, where
+ * keys differ only in case:
+ * ```json
+ * {
+ * 'x-request-date': '2000-01-01T00:00:00Z',
+ * 'X-Request-Date': '2001-01-01T00:00:00Z'
+ * }
+ * ```
+ * The SDK may at any point during processing remove one of the object
+ * properties in favor of the other. The headers may or may not be combined, and
+ * the SDK will not deterministically select which header candidate to use.
+ *
+ * @public
+ */
+type HeaderBag = Record<string, string>;
+/**
+ * Represents an HTTP message with headers and an optional static or streaming
+ * body. body: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
+ *
+ * @public
+ */
+interface HttpMessage {
+    headers: HeaderBag;
+    body?: any;
+}
+/**
+ * Represents an HTTP message with headers and an optional static or streaming
+ * body. bode: ArrayBuffer | ArrayBufferView | string | Uint8Array | Readable | ReadableStream;
+ *
+ * @public
+ */
+interface HttpMessage {
+    headers: HeaderBag;
+    body?: any;
+}
+/**
+ * Represents the options that may be passed to an Http Handler.
+ *
+ * @public
+ */
+interface HttpHandlerOptions {
+    abortSignal?: AbortSignal | AbortSignal$1;
+    /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     */
+    requestTimeout?: number;
+}
+
+/**
+ * A function that, given a Uint8Array of bytes, can produce a string
+ * representation thereof. The function may optionally attempt to
+ * convert other input types to Uint8Array before encoding.
+ *
+ * @example An encoder function that converts bytes to hexadecimal
+ * representation would return `'hello'` when given
+ * `new Uint8Array([104, 101, 108, 108, 111])`.
+ *
+ * @public
+ */
+interface Encoder {
+    /**
+     * Caution: the `any` type on the input is for backwards compatibility.
+     * Runtime support is limited to Uint8Array and string by default.
+     *
+     * You may choose to support more encoder input types if overriding the default
+     * implementations.
+     */
+    (input: Uint8Array | string | any): string;
+}
+/**
+ * A function that, given a string, can derive the bytes represented by that
+ * string.
+ *
+ * @example A decoder function that converts bytes to hexadecimal
+ * representation would return `new Uint8Array([104, 101, 108, 108, 111])` when
+ * given the string `'hello'`.
+ *
+ * @public
+ */
+interface Decoder {
+    (input: string): Uint8Array;
+}
+/**
+ * A function that, when invoked, returns a promise that will be fulfilled with
+ * a value of type T.
+ *
+ * @example A function that reads credentials from shared SDK configuration
+ * files, assuming roles and collecting MFA tokens as necessary.
+ *
+ * @public
+ */
+interface Provider<T> {
+    (): Promise<T>;
+}
+/**
+ * A tuple that represents an API name and optional version
+ * of a library built using the AWS SDK.
+ *
+ * @public
+ */
+type UserAgentPair = [name: string, version?: string];
+/**
+ * User agent data that to be put into the request's user
+ * agent.
+ *
+ * @public
+ */
+type UserAgent = UserAgentPair[];
+
+/**
+ * @public
+ */
+interface InitializeHandlerArguments<Input extends object> {
+    /**
+     * User input to a command. Reflects the userland representation of the
+     * union of data types the command can effectively handle.
+     */
+    input: Input;
+}
+/**
+ * @public
+ */
+interface InitializeHandlerOutput<Output extends object> extends DeserializeHandlerOutput<Output> {
+    output: Output;
+}
+/**
+ * @public
+ */
+interface SerializeHandlerArguments<Input extends object> extends InitializeHandlerArguments<Input> {
+    /**
+     * The user input serialized as a request object. The request object is unknown,
+     * so you cannot modify it directly. When work with request, you need to guard its
+     * type to e.g. HttpRequest with 'instanceof' operand
+     *
+     * During the build phase of the execution of a middleware stack, a built
+     * request may or may not be available.
+     */
+    request?: unknown;
+}
+/**
+ * @public
+ */
+interface SerializeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
+}
+/**
+ * @public
+ */
+interface BuildHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {
+}
+/**
+ * @public
+ */
+interface BuildHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
+}
+/**
+ * @public
+ */
+interface FinalizeHandlerArguments<Input extends object> extends SerializeHandlerArguments<Input> {
+    /**
+     * The user input serialized as a request.
+     */
+    request: unknown;
+}
+/**
+ * @public
+ */
+interface FinalizeHandlerOutput<Output extends object> extends InitializeHandlerOutput<Output> {
+}
+/**
+ * @public
+ */
+interface DeserializeHandlerArguments<Input extends object> extends FinalizeHandlerArguments<Input> {
+}
+/**
+ * @public
+ */
+interface DeserializeHandlerOutput<Output extends object> {
+    /**
+     * The raw response object from runtime is deserialized to structured output object.
+     * The response object is unknown so you cannot modify it directly. When work with
+     * response, you need to guard its type to e.g. HttpResponse with 'instanceof' operand.
+     *
+     * During the deserialize phase of the execution of a middleware stack, a deserialized
+     * response may or may not be available
+     */
+    response: unknown;
+    output?: Output;
+}
+/**
+ * @public
+ */
+interface InitializeHandler<Input extends object, Output extends object> {
+    /**
+     * Asynchronously converts an input object into an output object.
+     *
+     * @param args - An object containing a input to the command as well as any
+     *              associated or previously generated execution artifacts.
+     */
+    (args: InitializeHandlerArguments<Input>): Promise<InitializeHandlerOutput<Output>>;
+}
+/**
+ * @public
+ */
+type Handler<Input extends object, Output extends object> = InitializeHandler<Input, Output>;
+/**
+ * @public
+ */
+interface SerializeHandler<Input extends object, Output extends object> {
+    /**
+     * Asynchronously converts an input object into an output object.
+     *
+     * @param args - An object containing a input to the command as well as any
+     *              associated or previously generated execution artifacts.
+     */
+    (args: SerializeHandlerArguments<Input>): Promise<SerializeHandlerOutput<Output>>;
+}
+/**
+ * @public
+ */
+interface FinalizeHandler<Input extends object, Output extends object> {
+    /**
+     * Asynchronously converts an input object into an output object.
+     *
+     * @param args - An object containing a input to the command as well as any
+     *              associated or previously generated execution artifacts.
+     */
+    (args: FinalizeHandlerArguments<Input>): Promise<FinalizeHandlerOutput<Output>>;
+}
+/**
+ * @public
+ */
+interface BuildHandler<Input extends object, Output extends object> {
+    (args: BuildHandlerArguments<Input>): Promise<BuildHandlerOutput<Output>>;
+}
+/**
+ * @public
+ */
+interface DeserializeHandler<Input extends object, Output extends object> {
+    (args: DeserializeHandlerArguments<Input>): Promise<DeserializeHandlerOutput<Output>>;
+}
+/**
+ * A factory function that creates functions implementing the `Handler`
+ * interface.
+ *
+ * @public
+ */
+interface InitializeMiddleware<Input extends object, Output extends object> {
+    /**
+     * @param next - The handler to invoke after this middleware has operated on
+     * the user input and before this middleware operates on the output.
+     *
+     * @param context - Invariant data and functions for use by the handler.
+     */
+    (next: InitializeHandler<Input, Output>, context: HandlerExecutionContext): InitializeHandler<Input, Output>;
+}
+/**
+ * A factory function that creates functions implementing the `BuildHandler`
+ * interface.
+ *
+ * @public
+ */
+interface SerializeMiddleware<Input extends object, Output extends object> {
+    /**
+     * @param next - The handler to invoke after this middleware has operated on
+     * the user input and before this middleware operates on the output.
+     *
+     * @param context - Invariant data and functions for use by the handler.
+     */
+    (next: SerializeHandler<Input, Output>, context: HandlerExecutionContext): SerializeHandler<Input, Output>;
+}
+/**
+ * A factory function that creates functions implementing the `FinalizeHandler`
+ * interface.
+ *
+ * @public
+ */
+interface FinalizeRequestMiddleware<Input extends object, Output extends object> {
+    /**
+     * @param next - The handler to invoke after this middleware has operated on
+     * the user input and before this middleware operates on the output.
+     *
+     * @param context - Invariant data and functions for use by the handler.
+     */
+    (next: FinalizeHandler<Input, Output>, context: HandlerExecutionContext): FinalizeHandler<Input, Output>;
+}
+/**
+ * @public
+ */
+interface BuildMiddleware<Input extends object, Output extends object> {
+    (next: BuildHandler<Input, Output>, context: HandlerExecutionContext): BuildHandler<Input, Output>;
+}
+/**
+ * @public
+ */
+interface DeserializeMiddleware<Input extends object, Output extends object> {
+    (next: DeserializeHandler<Input, Output>, context: HandlerExecutionContext): DeserializeHandler<Input, Output>;
+}
+/**
+ * @public
+ */
+type MiddlewareType<Input extends object, Output extends object> = InitializeMiddleware<Input, Output> | SerializeMiddleware<Input, Output> | BuildMiddleware<Input, Output> | FinalizeRequestMiddleware<Input, Output> | DeserializeMiddleware<Input, Output>;
+/**
+ * @public
+ */
+type Step = "initialize" | "serialize" | "build" | "finalizeRequest" | "deserialize";
+/**
+ * @public
+ */
+type Priority = "high" | "normal" | "low";
+/**
+ * @public
+ */
+interface HandlerOptions {
+    /**
+     * Handlers are ordered using a "step" that describes the stage of command
+     * execution at which the handler will be executed. The available steps are:
+     *
+     * - initialize: The input is being prepared. Examples of typical
+     *      initialization tasks include injecting default options computing
+     *      derived parameters.
+     * - serialize: The input is complete and ready to be serialized. Examples
+     *      of typical serialization tasks include input validation and building
+     *      an HTTP request from user input.
+     * - build: The input has been serialized into an HTTP request, but that
+     *      request may require further modification. Any request alterations
+     *      will be applied to all retries. Examples of typical build tasks
+     *      include injecting HTTP headers that describe a stable aspect of the
+     *      request, such as `Content-Length` or a body checksum.
+     * - finalizeRequest: The request is being prepared to be sent over the wire. The
+     *      request in this stage should already be semantically complete and
+     *      should therefore only be altered as match the recipient's
+     *      expectations. Examples of typical finalization tasks include request
+     *      signing and injecting hop-by-hop headers.
+     * - deserialize: The response has arrived, the middleware here will deserialize
+     *      the raw response object to structured response
+     *
+     *      Unlike initialization and build handlers, which are executed once
+     *      per operation execution, finalization and deserialize handlers will be
+     *      executed foreach HTTP request sent.
+     *
+     * @defaultValue 'initialize'
+     */
+    step?: Step;
+    /**
+     * A list of strings to any that identify the general purpose or important
+     * characteristics of a given handler.
+     */
+    tags?: Array<string>;
+    /**
+     * A unique name to refer to a middleware
+     */
+    name?: string;
+    /**
+     * Aliases allows for middleware to be found by multiple names besides {@link HandlerOptions.name}.
+     * This allows for references to replaced middleware to continue working, e.g. replacing
+     * multiple auth-specific middleware with a single generic auth middleware.
+     *
+     * @internal
+     */
+    aliases?: Array<string>;
+    /**
+     * A flag to override the existing middleware with the same name. Without
+     * setting it, adding middleware with duplicated name will throw an exception.
+     * @internal
+     */
+    override?: boolean;
+}
+/**
+ * @public
+ */
+interface AbsoluteLocation {
+    /**
+     * By default middleware will be added to individual step in un-guaranteed order.
+     * In the case that
+     *
+     * @defaultValue 'normal'
+     */
+    priority?: Priority;
+}
+/**
+ * @public
+ */
+type Relation = "before" | "after";
+/**
+ * @public
+ */
+interface RelativeLocation {
+    /**
+     * Specify the relation to be before or after a know middleware.
+     */
+    relation: Relation;
+    /**
+     * A known middleware name to indicate inserting middleware's location.
+     */
+    toMiddleware: string;
+}
+/**
+ * @public
+ */
+type RelativeMiddlewareOptions = RelativeLocation & Omit<HandlerOptions, "step">;
+/**
+ * @public
+ */
+interface InitializeHandlerOptions extends HandlerOptions {
+    step?: "initialize";
+}
+/**
+ * @public
+ */
+interface SerializeHandlerOptions extends HandlerOptions {
+    step: "serialize";
+}
+/**
+ * @public
+ */
+interface BuildHandlerOptions extends HandlerOptions {
+    step: "build";
+}
+/**
+ * @public
+ */
+interface FinalizeRequestHandlerOptions extends HandlerOptions {
+    step: "finalizeRequest";
+}
+/**
+ * @public
+ */
+interface DeserializeHandlerOptions extends HandlerOptions {
+    step: "deserialize";
+}
+/**
+ * A stack storing middleware. It can be resolved into a handler. It supports 2
+ * approaches for adding middleware:
+ * 1. Adding middleware to specific step with `add()`. The order of middleware
+ * added into same step is determined by order of adding them. If one middleware
+ * needs to be executed at the front of the step or at the end of step, set
+ * `priority` options to `high` or `low`.
+ * 2. Adding middleware to location relative to known middleware with `addRelativeTo()`.
+ * This is useful when given middleware must be executed before or after specific
+ * middleware(`toMiddleware`). You can add a middleware relatively to another
+ * middleware which also added relatively. But eventually, this relative middleware
+ * chain **must** be 'anchored' by a middleware that added using `add()` API
+ * with absolute `step` and `priority`. This mothod will throw if specified
+ * `toMiddleware` is not found.
+ *
+ * @public
+ */
+interface MiddlewareStack<Input extends object, Output extends object> extends Pluggable<Input, Output> {
+    /**
+     * Add middleware to the stack to be executed during the "initialize" step,
+     * optionally specifying a priority, tags and name
+     */
+    add(middleware: InitializeMiddleware<Input, Output>, options?: InitializeHandlerOptions & AbsoluteLocation): void;
+    /**
+     * Add middleware to the stack to be executed during the "serialize" step,
+     * optionally specifying a priority, tags and name
+     */
+    add(middleware: SerializeMiddleware<Input, Output>, options: SerializeHandlerOptions & AbsoluteLocation): void;
+    /**
+     * Add middleware to the stack to be executed during the "build" step,
+     * optionally specifying a priority, tags and name
+     */
+    add(middleware: BuildMiddleware<Input, Output>, options: BuildHandlerOptions & AbsoluteLocation): void;
+    /**
+     * Add middleware to the stack to be executed during the "finalizeRequest" step,
+     * optionally specifying a priority, tags and name
+     */
+    add(middleware: FinalizeRequestMiddleware<Input, Output>, options: FinalizeRequestHandlerOptions & AbsoluteLocation): void;
+    /**
+     * Add middleware to the stack to be executed during the "deserialize" step,
+     * optionally specifying a priority, tags and name
+     */
+    add(middleware: DeserializeMiddleware<Input, Output>, options: DeserializeHandlerOptions & AbsoluteLocation): void;
+    /**
+     * Add middleware to a stack position before or after a known middleware，optionally
+     * specifying name and tags.
+     */
+    addRelativeTo(middleware: MiddlewareType<Input, Output>, options: RelativeMiddlewareOptions): void;
+    /**
+     * Apply a customization function to mutate the middleware stack, often
+     * used for customizations that requires mutating multiple middleware.
+     */
+    use(pluggable: Pluggable<Input, Output>): void;
+    /**
+     * Create a shallow clone of this stack. Step bindings and handler priorities
+     * and tags are preserved in the copy.
+     */
+    clone(): MiddlewareStack<Input, Output>;
+    /**
+     * Removes middleware from the stack.
+     *
+     * If a string is provided, it will be treated as middleware name. If a middleware
+     * is inserted with the given name, it will be removed.
+     *
+     * If a middleware class is provided, all usages thereof will be removed.
+     */
+    remove(toRemove: MiddlewareType<Input, Output> | string): boolean;
+    /**
+     * Removes middleware that contains given tag
+     *
+     * Multiple middleware will potentially be removed
+     */
+    removeByTag(toRemove: string): boolean;
+    /**
+     * Create a stack containing the middlewares in this stack as well as the
+     * middlewares in the `from` stack. Neither source is modified, and step
+     * bindings and handler priorities and tags are preserved in the copy.
+     */
+    concat<InputType extends Input, OutputType extends Output>(from: MiddlewareStack<InputType, OutputType>): MiddlewareStack<InputType, OutputType>;
+    /**
+     * Returns a list of the current order of middleware in the stack.
+     * This does not execute the middleware functions, nor does it
+     * provide a reference to the stack itself.
+     */
+    identify(): string[];
+    /**
+     * When an operation is called using this stack,
+     * it will log its list of middleware to the console using
+     * the identify function.
+     * If no argument given, returns the current value.
+     *
+     * @internal
+     * @param toggle - set whether to log on resolve.
+     */
+    identifyOnResolve(toggle?: boolean): boolean;
+    /**
+     * Builds a single handler function from zero or more middleware classes and
+     * a core handler. The core handler is meant to send command objects to AWS
+     * services and return promises that will resolve with the operation result
+     * or be rejected with an error.
+     *
+     * When a composed handler is invoked, the arguments will pass through all
+     * middleware in a defined order, and the return from the innermost handler
+     * will pass through all middleware in the reverse of that order.
+     */
+    resolve<InputType extends Input, OutputType extends Output>(handler: DeserializeHandler<InputType, OutputType>, context: HandlerExecutionContext): InitializeHandler<InputType, OutputType>;
+}
+/**
+ * @internal
+ */
+declare const SMITHY_CONTEXT_KEY = "__smithy_context";
+/**
+ * Data and helper objects that are not expected to change from one execution of
+ * a composed handler to another.
+ *
+ * @public
+ */
+interface HandlerExecutionContext {
+    /**
+     * A logger that may be invoked by any handler during execution of an
+     * operation.
+     */
+    logger?: Logger;
+    /**
+     * Name of the service the operation is being sent to.
+     */
+    clientName?: string;
+    /**
+     * Name of the operation being executed.
+     */
+    commandName?: string;
+    /**
+     * Additional user agent that inferred by middleware. It can be used to save
+     * the internal user agent sections without overriding the `customUserAgent`
+     * config in clients.
+     */
+    userAgent?: UserAgent;
+    /**
+     * Resolved by the endpointMiddleware function of `@smithy/middleware-endpoint`
+     * in the serialization stage.
+     */
+    endpointV2?: EndpointV2;
+    /**
+     * Set at the same time as endpointV2.
+     */
+    authSchemes?: AuthScheme[];
+    /**
+     * The current auth configuration that has been set by any auth middleware and
+     * that will prevent from being set more than once.
+     */
+    currentAuthConfig?: HttpAuthDefinition;
+    /**
+     * @deprecated do not extend this field, it is a carryover from AWS SDKs.
+     * Used by DynamoDbDocumentClient.
+     */
+    dynamoDbDocumentClientOptions?: Partial<{
+        overrideInputFilterSensitiveLog(...args: any[]): string | void;
+        overrideOutputFilterSensitiveLog(...args: any[]): string | void;
+    }>;
+    /**
+     * Context for Smithy properties.
+     *
+     * @internal
+     */
+    [SMITHY_CONTEXT_KEY]?: {
+        service?: string;
+        operation?: string;
+        commandInstance?: Command<any, any, any, any, any>;
+        selectedHttpAuthScheme?: SelectedHttpAuthScheme;
+        features?: SmithyFeatures;
+        /**
+         * Transferred from request options to the Smithy context.
+         */
+        metricsRecorder?: MetricsRecorder<unknown>;
+        /**
+         * Transferred from request options to allow middleware to cancel
+         * asynchronous work outside of the request handler.
+         */
+        abortSignal?: AbortSignal | AbortSignal$1;
+        /**
+         * @deprecated
+         * Do not assign arbitrary members to the Smithy Context,
+         * fields should be explicitly declared here to avoid collisions.
+         */
+        [key: string]: unknown;
+    };
+    /**
+     * Set by some operations which instructs the retry behavior to backoff
+     * after a failed request even when no further retry (of the same request) is expected.
+     * @internal
+     */
+    __retryLongPoll?: boolean;
+    /**
+     * @deprecated
+     * Do not assign arbitrary members to the context, since
+     * they can interfere with existing functionality.
+     *
+     * Additional members should instead be declared on the SMITHY_CONTEXT_KEY
+     * or other reserved keys.
+     */
+    [key: string]: any;
+}
+/**
+ * @public
+ */
+interface Pluggable<Input extends object, Output extends object> {
+    /**
+     * A function that mutate the passed in middleware stack. Functions implementing
+     * this interface can add, remove, modify existing middleware stack from clients
+     * or commands
+     */
+    applyToStack: (stack: MiddlewareStack<Input, Output>) => void;
+}
+
+/**
+ * @internal
+ */
+interface ErrorHandler {
+    (signingProperties: Record<string, unknown>): <E extends Error>(error: E) => never;
+}
+/**
+ * @internal
+ */
+interface SuccessHandler {
+    (httpResponse: HttpResponse$1 | unknown, signingProperties: Record<string, unknown>): void;
+}
+/**
+ * Interface to sign identity and signing properties.
+ * @internal
+ */
+interface HttpSigner {
+    /**
+     * Signs an HttpRequest with an identity and signing properties.
+     * @param httpRequest request to sign
+     * @param identity identity to sing the request with
+     * @param signingProperties property bag for signing
+     * @returns signed request in a promise
+     */
+    sign(httpRequest: HttpRequest$1, identity: Identity, signingProperties: Record<string, unknown>): Promise<HttpRequest$1>;
+    /**
+     * Handler that executes after the {@link HttpSigner.sign} invocation and corresponding
+     * middleware throws an error.
+     * The error handler is expected to throw the error it receives, so the return type of the error handler is `never`.
+     * @internal
+     */
+    errorHandler?: ErrorHandler;
+    /**
+     * Handler that executes after the {@link HttpSigner.sign} invocation and corresponding
+     * middleware succeeds.
+     * @internal
+     */
+    successHandler?: SuccessHandler;
+}
+
+/**
+ * ID for {@link HttpAuthScheme}
+ * @internal
+ */
+type HttpAuthSchemeId = string;
+/**
+ * Interface that defines the identity and signing properties when selecting
+ * an HttpAuthScheme.
+ * @internal
+ */
+interface HttpAuthOption {
+    schemeId: HttpAuthSchemeId;
+    identityProperties?: Record<string, unknown>;
+    signingProperties?: Record<string, unknown>;
+    propertiesExtractor?: <TConfig extends object, TContext extends HandlerExecutionContext>(config: TConfig, context: TContext) => {
+        identityProperties?: Record<string, unknown>;
+        signingProperties?: Record<string, unknown>;
+    };
+}
+/**
+ * @internal
+ */
+interface SelectedHttpAuthScheme {
+    httpAuthOption: HttpAuthOption;
+    identity: Identity;
+    signer: HttpSigner;
+}
+
+/**
+ * @public
+ */
+type RequestHandlerOutput<ResponseType> = {
+    response: ResponseType;
+};
+/**
+ * @public
+ */
+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
+ */
+interface RequestHandlerMetadata {
+    handlerProtocol: RequestHandlerProtocol | string;
+}
+/**
+ * Values from ALPN Protocol IDs.
+ *
+ * @public
+ * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
+ */
+declare enum RequestHandlerProtocol {
+    HTTP_0_9 = "http/0.9",
+    HTTP_1_0 = "http/1.0",
+    TDS_8_0 = "tds/8.0"
+}
+
+/**
+ * An event stream message. The headers and body properties will always be
+ * defined, with empty headers represented as an object with no keys and an
+ * empty body represented as a zero-length Uint8Array.
+ *
+ * @public
+ */
+interface Message {
+    headers: MessageHeaders;
+    body: Uint8Array;
+}
+/**
+ * @public
+ */
+type MessageHeaders = Record<string, MessageHeaderValue>;
+/**
+ * @public
+ */
+type HeaderValue<K extends string, V> = {
+    type: K;
+    value: V;
+};
+/**
+ * @public
+ */
+type BooleanHeaderValue = HeaderValue<"boolean", boolean>;
+/**
+ * @public
+ */
+type ByteHeaderValue = HeaderValue<"byte", number>;
+/**
+ * @public
+ */
+type ShortHeaderValue = HeaderValue<"short", number>;
+/**
+ * @public
+ */
+type IntegerHeaderValue = HeaderValue<"integer", number>;
+/**
+ * @public
+ */
+type LongHeaderValue = HeaderValue<"long", Int64>;
+/**
+ * @public
+ */
+type BinaryHeaderValue = HeaderValue<"binary", Uint8Array>;
+/**
+ * @public
+ */
+type StringHeaderValue = HeaderValue<"string", string>;
+/**
+ * @public
+ */
+type TimestampHeaderValue = HeaderValue<"timestamp", Date>;
+/**
+ * @public
+ */
+type UuidHeaderValue = HeaderValue<"uuid", string>;
+/**
+ * @public
+ */
+type MessageHeaderValue = BooleanHeaderValue | ByteHeaderValue | ShortHeaderValue | IntegerHeaderValue | LongHeaderValue | BinaryHeaderValue | StringHeaderValue | TimestampHeaderValue | UuidHeaderValue;
+/**
+ * @public
+ */
+interface Int64 {
+    readonly bytes: Uint8Array;
+    valueOf: () => number;
+    toString: () => string;
+}
+/**
+ * A function which deserializes binary event stream message into modeled shape.
+ *
+ * @public
+ */
+interface EventStreamMarshallerDeserFn<StreamType> {
+    <T>(body: StreamType, deserializer: (input: Record<string, Message>) => Promise<T>): AsyncIterable<T>;
+}
+/**
+ * A function that serializes modeled shape into binary stream message.
+ *
+ * @public
+ */
+interface EventStreamMarshallerSerFn<StreamType> {
+    <T>(input: AsyncIterable<T>, serializer: (event: T) => Message): StreamType;
+}
+/**
+ * An interface which provides functions for serializing and deserializing binary event stream
+ * to/from corresponsing modeled shape.
+ *
+ * @public
+ */
+interface EventStreamMarshaller<StreamType = any> {
+    deserialize: EventStreamMarshallerDeserFn<StreamType>;
+    serialize: EventStreamMarshallerSerFn<StreamType>;
+}
+
+/**
+ * A structure shape with the error trait.
+ * https://smithy.io/2.0/spec/behavior-traits.html#smithy-api-retryable-trait
+ *
+ * @public
+ */
+interface RetryableTrait {
+    /**
+     * Indicates that the error is a retryable throttling error.
+     */
+    readonly throttling?: boolean;
+}
+/**
+ * Type that is implemented by all Smithy shapes marked with the
+ * error trait.
+ *
+ * @public
+ * @deprecated
+ */
+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$1;
+}
+/**
+ * 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.
+ *
+ * @public
+ * @deprecated See {@link https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/}
+ */
+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;
+};
+
+/**
+ * @public
+ */
+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
+ */
+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
+ */
+interface RetryToken {
+    /**
+     * Starts at 0 for the initial request, which is not a "retry" by definition.
+     * 1 indicates the first retry.
+     *
+     * @returns the current count of retry.
+     */
+    getRetryCount(): number;
+    /**
+     * RetryStrategies implemented by `@smithy/core` will return tokens with a
+     * delay of zero.
+     *
+     * This is because the RetryStrategy token acquisition methods took over the
+     * task of idling for the delay period. If a user-implemented retry token
+     * contains a delay, the default Smithy retry middleware will still honor it.
+     *
+     * That is to say, you may either sleep within the RetryStrategy methods for acquiring
+     * the token, OR return a token with a retry delay that will cause the retry middleware
+     * to sleep.
+     *
+     * @returns the number of milliseconds to wait before retrying an action.
+     */
+    getRetryDelay(): number;
+    /**
+     * @returns whether the operation which generated this token is long polling.
+     */
+    isLongPoll?(): boolean;
+    /**
+     * Delays that have already been executed by the time the token
+     * is accessible. This is needed for the token handler to understand what has happened.
+     * @internal
+     */
+    $retryLog?: {
+        acquisitionDelay?: number;
+    };
+}
+/**
+ * @public
+ */
+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.
+     *
+     * This method should either delay internally and return a token with 0 delay, OR
+     * do not sleep and return a token with the desired delay duration.
+     */
+    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;
+}
+
+/**
+ * Represents the http options that can be passed to a node http client.
+ * @public
+ */
+interface NodeHttpHandlerOptions {
+    /**
+     * The maximum time in milliseconds that the connection phase of a request
+     * may take before the connection attempt is abandoned.
+     * Defaults to 0, which disables the timeout.
+     */
+    connectionTimeout?: number;
+    /**
+     * The maximum number of milliseconds request & response should take.
+     * Defaults to 0, which disables the timeout.
+     *
+     * If exceeded, a warning will be emitted unless throwOnRequestTimeout=true,
+     * in which case a TimeoutError will be thrown.
+     */
+    requestTimeout?: number;
+    /**
+     * Because requestTimeout was for a long time incorrectly being set as a socket idle timeout,
+     * users must also opt-in for request timeout thrown errors.
+     * Without this setting, a breach of the request timeout will be logged as a warning.
+     */
+    throwOnRequestTimeout?: boolean;
+    /**
+     * The maximum time in milliseconds that a socket may remain idle before it
+     * is closed. Defaults to 0, which means no maximum.
+     *
+     * This does not affect the server, which may still close the connection due to an idle socket.
+     */
+    socketTimeout?: number;
+    /**
+     * Delay before the NodeHttpHandler checks for socket exhaustion,
+     * and emits a warning if the active sockets and enqueued request count is greater than
+     * 2x the maxSockets count.
+     *
+     * Defaults to connectionTimeout + requestTimeout or 3000ms if those are not set.
+     */
+    socketAcquisitionWarningTimeout?: number;
+    /**
+     * You can pass http.Agent or its constructor options.
+     */
+    httpAgent?: Agent | AgentOptions;
+    /**
+     * You can pass https.Agent or its constructor options.
+     */
+    httpsAgent?: Agent$1 | AgentOptions$1;
+    /**
+     * Optional logger.
+     */
+    logger?: Logger;
+}
+/**
+ * Represents the http options that can be passed to a browser http client.
+ * @public
+ */
+interface FetchHttpHandlerOptions {
+    /**
+     * The number of milliseconds a request can take before being automatically
+     * terminated.
+     */
+    requestTimeout?: number;
+    /**
+     * Whether to allow the request to outlive the page. Default value is false.
+     *
+     * There may be limitations to the payload size, number of concurrent requests,
+     * request duration etc. when using keepalive in browsers.
+     *
+     * These may change over time, so look for up to date information about
+     * these limitations before enabling keepalive.
+     */
+    keepAlive?: boolean;
+    /**
+     * A string indicating whether credentials will be sent with the request always, never, or
+     * only when sent to a same-origin URL.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/credentials
+     */
+    credentials?: "include" | "omit" | "same-origin" | undefined | string;
+    /**
+     * Cache settings for fetch.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/cache
+     */
+    cache?: "default" | "force-cache" | "no-cache" | "no-store" | "only-if-cached" | "reload";
+    /**
+     * An optional function that produces additional RequestInit
+     * parameters for each httpRequest.
+     *
+     * This is applied last via merging with Object.assign() and overwrites other values
+     * set from other sources.
+     *
+     * @example
+     * ```js
+     * new Client({
+     *   requestHandler: {
+     *     requestInit(httpRequest) {
+     *       return { cache: "no-store" };
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    requestInit?: (httpRequest: HttpRequest$1) => RequestInit;
+    /**
+     * An optional custom fetch implementation to use in place of the
+     * global fetch function.
+     *
+     * @example
+     * ```js
+     * new Client({
+     *   requestHandler: {
+     *     customFetch: (request) => myFetchImplementation(request)
+     *   }
+     * });
+     * ```
+     */
+    customFetch?: typeof fetch;
+}
+declare global {
+    /**
+     * interface merging stub.
+     */
+    interface RequestInit {
+    }
+}
+
+/**
+ * @internal
+ */
+interface TokenIdentity extends Identity {
+    /**
+     * The literal token string
+     */
+    readonly token: string;
+}
+
+/**
+ * Interface for object requires an Endpoint set.
+ *
+ * @public
+ */
+interface EndpointBearer {
+    endpoint: Provider<Endpoint>;
+}
+/**
+ * @public
+ */
+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>;
+}
+/**
+ * Serde functions from the client config.
+ *
+ * @public
+ */
+interface SerdeFunctions {
+    base64Encoder: Encoder;
+    base64Decoder: Decoder;
+    utf8Encoder: Encoder;
+    utf8Decoder: Decoder;
+    streamCollector: StreamCollector;
+}
+
+/**
+ * The blob Smithy type, in JS as Uint8Array and other representations
+ * such as Buffer, string, or Readable(Stream) depending on circumstances.
+ * @public
+ */
+type BlobSchema = 0b0001_0101;
+/**
+ * @public
+ */
+type StreamingBlobSchema = 0b0010_1010;
+/**
+ * @public
+ */
+type BooleanSchema = 0b0000_0010;
+/**
+ * Includes string and enum Smithy types.
+ * @public
+ */
+type StringSchema = 0b0000_0000;
+/**
+ * Includes all numeric Smithy types except bigInteger and bigDecimal.
+ * byte, short, integer, long, float, double, intEnum.
+ *
+ * @public
+ */
+type NumericSchema = 0b0000_0001;
+/**
+ * @public
+ */
+type BigIntegerSchema = 0b0001_0001;
+/**
+ * @public
+ */
+type BigDecimalSchema = 0b0001_0011;
+/**
+ * @public
+ */
+type DocumentSchema = 0b0000_1111;
+/**
+ * Smithy type timestamp, in JS as native Date object.
+ * @public
+ */
+type TimestampDefaultSchema = 0b0000_0100;
+/**
+ * @public
+ */
+type TimestampDateTimeSchema = 0b0000_0101;
+/**
+ * @public
+ */
+type TimestampHttpDateSchema = 0b0000_0110;
+/**
+ * @public
+ */
+type TimestampEpochSecondsSchema = 0b0000_0111;
+
+/**
+ * @public
+ */
+type StaticSchemaIdSimple = 0;
+/**
+ * @public
+ */
+type StaticSchemaIdList = 1;
+/**
+ * @public
+ */
+type StaticSchemaIdMap = 2;
+/**
+ * @public
+ */
+type StaticSchemaIdStruct = 3;
+/**
+ * @public
+ */
+type StaticSchemaIdUnion = 4;
+/**
+ * @public
+ */
+type StaticSchemaIdError = -3;
+/**
+ * @public
+ */
+type StaticSchemaIdOperation = 9;
+/**
+ * @public
+ */
+type StaticSchema = StaticSimpleSchema | StaticListSchema | StaticMapSchema | StaticStructureSchema | StaticUnionSchema | StaticErrorSchema | StaticOperationSchema;
+/**
+ * @public
+ */
+type ShapeName = string;
+/**
+ * @public
+ */
+type ShapeNamespace = string;
+/**
+ * @public
+ */
+type StaticSimpleSchema = [StaticSchemaIdSimple, ShapeNamespace, ShapeName, SchemaTraits, $SchemaRef];
+/**
+ * @public
+ */
+type StaticListSchema = [StaticSchemaIdList, ShapeNamespace, ShapeName, SchemaTraits, $SchemaRef];
+/**
+ * @public
+ */
+type StaticMapSchema = [StaticSchemaIdMap, ShapeNamespace, ShapeName, SchemaTraits, $SchemaRef, $SchemaRef];
+/**
+ * @public
+ */
+type StaticStructureSchema = [
+    StaticSchemaIdStruct,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[],
+    number?
+];
+/**
+ * @public
+ */
+type StaticUnionSchema = [
+    StaticSchemaIdUnion,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[]
+];
+/**
+ * @public
+ */
+type StaticErrorSchema = [
+    StaticSchemaIdError,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    string[],
+    $SchemaRef[],
+    number?
+];
+/**
+ * @public
+ */
+type StaticOperationSchema = [
+    StaticSchemaIdOperation,
+    ShapeNamespace,
+    ShapeName,
+    SchemaTraits,
+    $SchemaRef,
+    $SchemaRef
+];
+
+/**
+ * A bitvector representing a traits object.
+ *
+ * Vector index to trait:
+ * 0 - httpLabel
+ * 1 - idempotent
+ * 2 - idempotencyToken
+ * 3 - sensitive
+ * 4 - httpPayload
+ * 5 - httpResponseCode
+ * 6 - httpQueryParams
+ *
+ * The singular trait values are enumerated for quick identification, but
+ * combination values are left to the `number` union type.
+ *
+ * @public
+ */
+type TraitBitVector = HttpLabelBitMask | IdempotentBitMask | IdempotencyTokenBitMask | SensitiveBitMask | HttpPayloadBitMask | HttpResponseCodeBitMask | HttpQueryParamsBitMask | number;
+/**
+ * @public
+ */
+type HttpLabelBitMask = 1;
+/**
+ * @public
+ */
+type IdempotentBitMask = 2;
+/**
+ * @public
+ */
+type IdempotencyTokenBitMask = 4;
+/**
+ * @public
+ */
+type SensitiveBitMask = 8;
+/**
+ * @public
+ */
+type HttpPayloadBitMask = 16;
+/**
+ * @public
+ */
+type HttpResponseCodeBitMask = 32;
+/**
+ * @public
+ */
+type HttpQueryParamsBitMask = 64;
+
+/**
+ * A schema is an object or value that describes how to serialize/deserialize data.
+ * @public
+ */
+type $Schema = UnitSchema | SimpleSchema | $MemberSchema | StaticSchema | NormalizedSchema$1;
+/**
+ * Traits attached to schema objects.
+ *
+ * When this is a number, it refers to a pre-allocated
+ * trait combination that is equivalent to one of the
+ * object type's variations.
+ *
+ * @public
+ */
+type SchemaTraits = TraitBitVector | SchemaTraitsObject;
+/**
+ * Simple schemas are those corresponding to simple Smithy types.
+ * @see https://smithy.io/2.0/spec/simple-types.html
+ * @public
+ */
+type SimpleSchema = BlobSchemas | StringSchema | BooleanSchema | NumericSchema | BigIntegerSchema | BigDecimalSchema | DocumentSchema | TimestampSchemas | number;
+/**
+ * Sentinel value for Timestamp schema.
+ * "Default" means unspecified and to use the protocol serializer's default format.
+ *
+ * @public
+ */
+type TimestampSchemas = TimestampDefaultSchema | TimestampDateTimeSchema | TimestampHttpDateSchema | TimestampEpochSecondsSchema;
+/**
+ * Sentinel values for Blob schema.
+ * @public
+ */
+type BlobSchemas = BlobSchema | StreamingBlobSchema;
+/**
+ * Signal value for the Smithy void value. Typically used for
+ * operation input and outputs.
+ *
+ * @public
+ */
+type UnitSchema = "unit";
+/**
+ * See https://smithy.io/2.0/trait-index.html for individual definitions.
+ *
+ * @public
+ */
+type SchemaTraitsObject = {
+    idempotent?: 1;
+    idempotencyToken?: 1;
+    sensitive?: 1;
+    sparse?: 1;
+    /**
+     * timestampFormat is expressed by the schema sentinel values of 4, 5, 6, and 7,
+     * and not contained in trait objects.
+     * @deprecated use schema value.
+     */
+    timestampFormat?: never;
+    httpLabel?: 1;
+    httpHeader?: string;
+    httpQuery?: string;
+    httpPrefixHeaders?: string;
+    httpQueryParams?: 1;
+    httpPayload?: 1;
+    /**
+     * [method, path, statusCode]
+     */
+    http?: [string, string, number];
+    httpResponseCode?: 1;
+    /**
+     * [hostPrefix]
+     */
+    endpoint?: [string];
+    xmlAttribute?: 1;
+    xmlName?: string;
+    /**
+     * [prefix, uri]
+     */
+    xmlNamespace?: [string, string];
+    xmlFlattened?: 1;
+    jsonName?: string;
+    mediaType?: string;
+    error?: "client" | "server";
+    streaming?: 1;
+    eventHeader?: 1;
+    eventPayload?: 1;
+    [traitName: string]: unknown;
+};
+/**
+ * Indicates the schema is a member of a parent Structure schema.
+ * It may also have a set of member traits distinct from its target shape's traits.
+ * @public
+ */
+type $MemberSchema = [$SchemaRef, SchemaTraits];
+/**
+ * Normalization wrapper for various schema data objects.
+ * @public
+ */
+interface NormalizedSchema$1 {
+    getSchema(): $Schema;
+    getName(): string | undefined;
+    isMemberSchema(): boolean;
+    isListSchema(): boolean;
+    isMapSchema(): boolean;
+    isStructSchema(): boolean;
+    isBlobSchema(): boolean;
+    isTimestampSchema(): boolean;
+    isStringSchema(): boolean;
+    isBooleanSchema(): boolean;
+    isNumericSchema(): boolean;
+    isBigIntegerSchema(): boolean;
+    isBigDecimalSchema(): boolean;
+    isStreaming(): boolean;
+    getMergedTraits(): SchemaTraitsObject;
+    getMemberTraits(): SchemaTraitsObject;
+    getOwnTraits(): SchemaTraitsObject;
+    /**
+     * For list/set/map.
+     */
+    getValueSchema(): NormalizedSchema$1;
+    /**
+     * For struct/union.
+     */
+    getMemberSchema(member: string): NormalizedSchema$1 | undefined;
+    structIterator(): Generator<[string, NormalizedSchema$1], undefined, undefined>;
+}
+/**
+ * A schema "reference" is either a schema or a function that
+ * provides a schema. This is useful for lazy loading, and to allow
+ * code generation to define schema out of dependency order.
+ * @public
+ */
+type $SchemaRef = $Schema | (() => $Schema);
+/**
+ * A codec creates serializers and deserializers for some format such as JSON, XML, or CBOR.
+ *
+ * @public
+ */
+interface $Codec<S, D> extends ConfigurableSerdeContext {
+    createSerializer(): $ShapeSerializer<S>;
+    createDeserializer(): $ShapeDeserializer<D>;
+}
+/**
+ * Configuration for codecs. Different protocols may share codecs, but require different behaviors from them.
+ *
+ * @public
+ */
+type CodecSettings = {
+    timestampFormat: {
+        /**
+         * Whether to use member timestamp format traits.
+         */
+        useTrait: boolean;
+        /**
+         * Default timestamp format.
+         */
+        default: TimestampDateTimeSchema | TimestampHttpDateSchema | TimestampEpochSecondsSchema;
+    };
+    /**
+     * Whether to use HTTP binding traits.
+     */
+    httpBindings?: boolean;
+};
+/**
+ * Turns a serialization into a data object.
+ * @public
+ */
+interface $ShapeDeserializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    /**
+     * Optionally async.
+     */
+    read(schema: $Schema, data: SerializationType): any | Promise<any>;
+}
+/**
+ * Turns a data object into a serialization.
+ * @public
+ */
+interface $ShapeSerializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    write(schema: $Schema, value: unknown): void;
+    flush(): SerializationType;
+}
+/**
+ * Allows a protocol, codec, or serde utility to accept the serdeContext
+ * from a client configuration or request/response handlerExecutionContext.
+ *
+ * @public
+ */
+interface ConfigurableSerdeContext {
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}
+
+/**
+ * A schema is an object or value that describes how to serialize/deserialize data.
+ * @internal
+ * @deprecated use $Schema
+ */
+type Schema$1 = UnitSchema | TraitsSchema | SimpleSchema | ListSchema | MapSchema | StructureSchema$1 | MemberSchema | OperationSchema | StaticSchema | NormalizedSchema$1;
+/**
+ * A schema "reference" is either a schema or a function that
+ * provides a schema. This is useful for lazy loading, and to allow
+ * code generation to define schema out of dependency order.
+ * @internal
+ * @deprecated use $SchemaRef
+ */
+type SchemaRef = Schema$1 | (() => Schema$1);
+/**
+ * A schema that has traits.
+ *
+ * @internal
+ * @deprecated use static schema.
+ */
+interface TraitsSchema {
+    namespace: string;
+    name: string;
+    traits: SchemaTraits;
+}
+/**
+ * Indicates the schema is a member of a parent Structure schema.
+ * It may also have a set of member traits distinct from its target shape's traits.
+ * @internal
+ * @deprecated use $MemberSchema
+ */
+type MemberSchema = [SchemaRef, SchemaTraits];
+/**
+ * Schema for the structure aggregate type.
+ * @internal
+ * @deprecated use static schema.
+ */
+interface StructureSchema$1 extends TraitsSchema {
+    memberNames: string[];
+    memberList: SchemaRef[];
+    /**
+     * @deprecated structure member iteration will be linear on the memberNames and memberList arrays.
+     * It can be collected into a hashmap form on an ad-hoc basis, but will not initialize as such.
+     */
+    members?: Record<string, [SchemaRef, SchemaTraits]> | undefined;
+}
+/**
+ * Schema for the list aggregate type.
+ * @internal
+ * @deprecated use static schema.
+ */
+interface ListSchema extends TraitsSchema {
+    valueSchema: SchemaRef;
+}
+/**
+ * Schema for the map aggregate type.
+ * @internal
+ * @deprecated use static schema.
+ */
+interface MapSchema extends TraitsSchema {
+    keySchema: SchemaRef;
+    valueSchema: SchemaRef;
+}
+/**
+ * Schema for an operation.
+ * @internal
+ * @deprecated use StaticOperationSchema or $OperationSchema
+ */
+interface OperationSchema {
+    namespace: string;
+    name: string;
+    traits: SchemaTraits;
+    input: SchemaRef;
+    output: SchemaRef;
+}
+/**
+ * Turns a serialization into a data object.
+ * @internal
+ * @deprecated use $ShapeDeserializer
+ */
+interface ShapeDeserializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    /**
+     * Optionally async.
+     */
+    read(schema: Schema$1, data: SerializationType): any | Promise<any>;
+}
+/**
+ * Turns a data object into a serialization.
+ * @internal
+ * @deprecated use $ShapeSerializer
+ */
+interface ShapeSerializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    write(schema: Schema$1, value: unknown): void;
+    flush(): SerializationType;
+}
+/**
+ * A codec creates serializers and deserializers for some format such as JSON, XML, or CBOR.
+ *
+ * @internal
+ * @deprecated use $Codec
+ */
+interface Codec<S, D> extends ConfigurableSerdeContext {
+    createSerializer(): ShapeSerializer<S>;
+    createDeserializer(): ShapeDeserializer<D>;
+}
+/**
+ * A client protocol defines how to convert a message (e.g. HTTP request/response) to and from a data object.
+ * @internal
+ * @deprecated use $ClientProtocol
+ */
+interface ClientProtocol<Request, Response> extends ConfigurableSerdeContext {
+    /**
+     * @returns the Smithy qualified shape id.
+     */
+    getShapeId(): string;
+    getRequestType(): {
+        new (...args: any[]): Request;
+    };
+    getResponseType(): {
+        new (...args: any[]): Response;
+    };
+    /**
+     * @returns the payload codec if the requests/responses have a symmetric format.
+     * It otherwise may return null.
+     */
+    getPayloadCodec(): Codec<any, any>;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<Request>;
+    updateServiceEndpoint(request: Request, endpoint: EndpointV2): Request;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: Response): Promise<Output>;
+}
+
+type HttpRequestOptions = Partial<HttpMessage> & Partial<URI> & {
+    method?: string;
+};
+
+/**
+ * Use the distinct IHttpRequest interface from \@smithy/types instead.
+ * This should not be used due to
+ * overlapping with the concrete class' name.
+ *
+ * This is not marked deprecated since that would mark the concrete class
+ * deprecated as well.
+ *
+ * @internal
+ */
+interface HttpRequest extends HttpRequest$1 {
+}
+/**
+ * @public
+ */
+declare class HttpRequest implements HttpMessage, URI {
+    method: string;
+    protocol: string;
+    hostname: string;
+    port?: number;
+    path: string;
+    query: QueryParameterBag;
+    headers: HeaderBag;
+    username?: string;
+    password?: string;
+    fragment?: string;
+    body?: any;
+    constructor(options: HttpRequestOptions);
+    /**
+     * Note: this does not deep-clone the body.
+     */
+    static clone(request: HttpRequest$1): HttpRequest;
+    /**
+     * This method only actually asserts that request is the interface {@link IHttpRequest},
+     * and not necessarily this concrete class. Left in place for API stability.
+     *
+     * Do not call instance methods on the input of this function, and
+     * do not assume it has the HttpRequest prototype.
+     */
+    static isInstance(request: unknown): request is HttpRequest;
+    /**
+     * @deprecated use static HttpRequest.clone(request) instead. It's not safe to call
+     * this method because {@link HttpRequest.isInstance} incorrectly
+     * asserts that IHttpRequest (interface) objects are of type HttpRequest (class).
+     */
+    clone(): HttpRequest;
+}
+
+type HttpResponseOptions = Partial<HttpMessage> & {
+    statusCode: number;
+    reason?: string;
+};
+/**
+ * Use the distinct IHttpResponse interface from \@smithy/types instead.
+ * This should not be used due to
+ * overlapping with the concrete class' name.
+ *
+ * This is not marked deprecated since that would mark the concrete class
+ * deprecated as well.
+ *
+ * @internal
+ */
+interface HttpResponse extends HttpResponse$1 {
+}
+/**
+ * @public
+ */
+declare class HttpResponse {
+    statusCode: number;
+    reason?: string;
+    headers: HeaderBag;
+    body?: any;
+    constructor(options: HttpResponseOptions);
+    static isInstance(response: unknown): response is HttpResponse;
+}
+
+/**
+ * Abstract base for class-based Schema except NormalizedSchema.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+declare abstract class Schema implements TraitsSchema {
+    name: string;
+    namespace: string;
+    traits: SchemaTraits;
+    protected abstract readonly symbol: symbol;
+    static assign<T extends Schema>(instance: T, values: Omit<T, "getName" | "symbol">): T;
+    static [Symbol.hasInstance](lhs: unknown): boolean;
+    getName(): string;
+}
+
+/**
+ * A structure schema has a known list of members. This is also used for unions.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+declare class StructureSchema extends Schema implements StructureSchema$1 {
+    static symbol: symbol;
+    name: string;
+    traits: SchemaTraits;
+    memberNames: string[];
+    memberList: SchemaRef[];
+    protected readonly symbol: symbol;
+}
+
+/**
+ * A schema for a structure shape having the error trait. These represent enumerated operation errors.
+ * Because Smithy-TS SDKs use classes for exceptions, whereas plain objects are used for all other data,
+ * and have an existing notion of a XYZServiceBaseException, the ErrorSchema differs from a StructureSchema
+ * by additionally holding the class reference for the corresponding ServiceException class.
+ *
+ * @internal
+ * @deprecated use StaticSchema
+ */
+declare class ErrorSchema extends StructureSchema {
+    static readonly symbol: unique symbol;
+    /**
+     * @deprecated - field unused.
+     */
+    ctor: any;
+    protected readonly symbol: symbol;
+}
+
+/**
+ * Wraps both class instances, numeric sentinel values, and member schema pairs.
+ * Presents a consistent interface for interacting with polymorphic schema representations.
+ *
+ * @public
+ */
+declare class NormalizedSchema implements NormalizedSchema$1 {
+    readonly ref: $SchemaRef;
+    private readonly memberName?;
+    static readonly symbol: unique symbol;
+    protected readonly symbol: symbol;
+    private readonly name;
+    private readonly schema;
+    private readonly _isMemberSchema;
+    private readonly traits;
+    private readonly memberTraits;
+    private normalizedTraits?;
+    /**
+     * @param ref - a polymorphic SchemaRef to be dereferenced/normalized.
+     * @param memberName - optional memberName if this NormalizedSchema should be considered a member schema.
+     */
+    private constructor();
+    static [Symbol.hasInstance](lhs: unknown): lhs is NormalizedSchema;
+    /**
+     * Static constructor that attempts to avoid wrapping a NormalizedSchema within another.
+     */
+    static of(ref: SchemaRef | $SchemaRef): NormalizedSchema;
+    /**
+     * @returns the underlying non-normalized schema.
+     */
+    getSchema(): Exclude<$Schema, $MemberSchema | NormalizedSchema$1>;
+    /**
+     * @param withNamespace - qualifies the name.
+     * @returns e.g. `MyShape` or `com.namespace#MyShape`.
+     */
+    getName(withNamespace?: boolean): string | undefined;
+    /**
+     * @returns the member name if the schema is a member schema.
+     */
+    getMemberName(): string;
+    isMemberSchema(): boolean;
+    /**
+     * boolean methods on this class help control flow in shape serialization and deserialization.
+     */
+    isListSchema(): boolean;
+    isMapSchema(): boolean;
+    /**
+     * To simplify serialization logic, static union schemas are considered a specialization
+     * of structs in the TypeScript typings and JS runtime, as well as static error schemas
+     * which have a different identifier.
+     */
+    isStructSchema(): boolean;
+    isUnionSchema(): boolean;
+    isBlobSchema(): boolean;
+    isTimestampSchema(): boolean;
+    isUnitSchema(): boolean;
+    isDocumentSchema(): boolean;
+    isStringSchema(): boolean;
+    isBooleanSchema(): boolean;
+    isNumericSchema(): boolean;
+    isBigIntegerSchema(): boolean;
+    isBigDecimalSchema(): boolean;
+    isStreaming(): boolean;
+    /**
+     * @returns whether the schema has the idempotencyToken trait.
+     */
+    isIdempotencyToken(): boolean;
+    /**
+     * @returns own traits merged with member traits, where member traits of the same trait key take priority.
+     * This method is cached.
+     */
+    getMergedTraits(): SchemaTraitsObject;
+    /**
+     * @returns only the member traits. If the schema is not a member, this returns empty.
+     */
+    getMemberTraits(): SchemaTraitsObject;
+    /**
+     * @returns only the traits inherent to the shape or member target shape if this schema is a member.
+     * If there are any member traits they are excluded.
+     */
+    getOwnTraits(): SchemaTraitsObject;
+    /**
+     * @returns the map's key's schema. Returns a dummy Document schema if this schema is a Document.
+     *
+     * @throws Error if the schema is not a Map or Document.
+     */
+    getKeySchema(): NormalizedSchema;
+    /**
+     * @returns the schema of the map's value or list's member.
+     * Returns a dummy Document schema if this schema is a Document.
+     *
+     * @throws Error if the schema is not a Map, List, nor Document.
+     */
+    getValueSchema(): NormalizedSchema;
+    /**
+     * @returns the NormalizedSchema for the given member name. The returned instance will return true for `isMemberSchema()`
+     * and will have the member name given.
+     * @param memberName - which member to retrieve and wrap.
+     *
+     * @throws Error if member does not exist or the schema is neither a document nor structure.
+     * Note that errors are assumed to be structures and unions are considered structures for these purposes.
+     */
+    getMemberSchema(memberName: string): NormalizedSchema;
+    /**
+     * This can be used for checking the members as a hashmap.
+     * Prefer the structIterator method for iteration.
+     *
+     * This does NOT return list and map members, it is only for structures.
+     *
+     * @deprecated use (checked) structIterator instead.
+     *
+     * @returns a map of member names to member schemas (normalized).
+     */
+    getMemberSchemas(): Record<string, NormalizedSchema>;
+    /**
+     * @returns member name of event stream or empty string indicating none exists or this
+     * isn't a structure schema.
+     */
+    getEventStreamMember(): string;
+    /**
+     * Allows iteration over members of a structure schema.
+     * Each yield is a pair of the member name and member schema.
+     *
+     * This avoids the overhead of calling Object.entries(ns.getMemberSchemas()).
+     */
+    structIterator(): Generator<[string, NormalizedSchema], undefined, undefined>;
+}
+
+/**
+ * A way to look up schema by their ShapeId values.
+ *
+ * @public
+ */
+declare class TypeRegistry {
+    readonly namespace: string;
+    private schemas;
+    private exceptions;
+    static readonly registries: Map<string, TypeRegistry>;
+    constructor(namespace: string, schemas?: Map<string, Schema$1>, exceptions?: Map<StaticErrorSchema, any>);
+    /**
+     * @param namespace - specifier.
+     * @returns the TypeRegistry for that namespace, creating it if necessary.
+     */
+    static for(namespace: string): TypeRegistry;
+    /**
+     * Copies entries from another instance without changing the namespace of self.
+     * The composition is additive but non-destructive and will not overwrite existing entries.
+     *
+     * @param other - another TypeRegistry.
+     */
+    copyFrom(other: TypeRegistry): void;
+    /**
+     * Adds the given schema to a type registry with the same namespace, and this registry.
+     *
+     * @param shapeId - to be registered.
+     * @param schema - to be registered.
+     */
+    register(shapeId: string, schema: Schema$1): void;
+    /**
+     * @param shapeId - query.
+     * @returns the schema.
+     */
+    getSchema(shapeId: string): Schema$1;
+    /**
+     * Associates an error schema with its constructor.
+     */
+    registerError(es: ErrorSchema | StaticErrorSchema, ctor: any): void;
+    /**
+     * @param es - query.
+     * @returns Error constructor that extends the service's base exception.
+     */
+    getErrorCtor(es: ErrorSchema | StaticErrorSchema): any;
+    /**
+     * The smithy-typescript code generator generates a synthetic (i.e. unmodeled) base exception,
+     * because generated SDKs before the introduction of schemas have the notion of a ServiceBaseException, which
+     * is unique per service/model.
+     *
+     * This is generated under a unique prefix that is combined with the service namespace, and this
+     * method is used to retrieve it.
+     *
+     * The base exception synthetic schema is used when an error is returned by a service, but we cannot
+     * determine what existing schema to use to deserialize it.
+     *
+     * @returns the synthetic base exception of the service namespace associated with this registry instance.
+     */
+    getBaseException(): StaticErrorSchema | undefined;
+    /**
+     * @param predicate - criterion.
+     * @returns a schema in this registry matching the predicate.
+     */
+    find(predicate: (schema: Schema$1) => boolean): number | "unit" | MemberSchema | NormalizedSchema$1 | StaticErrorSchema | StaticListSchema | StaticMapSchema | StaticOperationSchema | StaticSimpleSchema | StaticStructureSchema | StaticUnionSchema | TraitsSchema | undefined;
+    /**
+     * Unloads the current TypeRegistry.
+     */
+    clear(): void;
+    private normalizeShapeId;
+}
+
+/**
+ * Separated module for async mixin of EventStream serde capability.
+ * This is used by the HttpProtocol base class from \@smithy/core/protocols.
+ *
+ * @public
+ */
+declare class EventStreamSerde {
+    private readonly marshaller;
+    private readonly serializer;
+    private readonly deserializer;
+    private readonly serdeContext?;
+    private readonly defaultContentType;
+    private readonly compositeErrorRegistry?;
+    /**
+     * Properties are injected by the HttpProtocol.
+     */
+    constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry, }: {
+        marshaller: EventStreamMarshaller;
+        serializer: ShapeSerializer<string | Uint8Array>;
+        deserializer: ShapeDeserializer<string | Uint8Array>;
+        serdeContext?: SerdeFunctions;
+        defaultContentType: string;
+        compositeErrorRegistry?: TypeRegistry;
+    });
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+        /**
+         * The :event-type header value for the initial message.
+         * Defaults to "initial-request" (client→server).
+         * Server→client should pass "initial-response".
+         */
+        initialMessageType?: string;
+    }): Promise<HttpRequest$1["body"] | Uint8Array>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream for the end-user.
+     */
+    deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType, }: {
+        response: HttpResponse$1;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+        /**
+         * The :event-type header value to match as the initial message.
+         * Defaults to "initial-response" (server→client).
+         * Server-side deserialization of client requests should pass "initial-request".
+         */
+        initialMessageType?: string;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * Reads and returns an event member. For error schemas, resolves the registered
+     * error constructor from the TypeRegistry and wraps the deserialized value
+     * so that it can be thrown as a typed exception instance by the caller.
+     */
+    private readEventMember;
+    /**
+     * @param unionMember - member name within the structure that contains an event stream union.
+     * @param unionSchema - schema of the union.
+     * @param event
+     *
+     * @returns the event body (bytes) and event type (string).
+     */
+    private writeEventBody;
+}
+
+/**
+ * This in practice should be the client config object.
+ * @internal
+ */
+type SerdeContextType = SerdeFunctions & {
+    disableHostPrefix?: boolean;
+};
+/**
+ * @internal
+ */
+declare abstract class SerdeContext implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeContextType;
+    setSerdeContext(serdeContext: SerdeContextType): void;
+}
+
+/**
+ * Abstract base for HTTP-based client protocols.
+ *
+ * @public
+ */
+declare abstract class HttpProtocol extends SerdeContext implements ClientProtocol<HttpRequest$1, HttpResponse$1> {
+    readonly options: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    };
+    /**
+     * An error registry having the namespace of the modeled service,
+     * but combining all error schemas found within the service closure.
+     *
+     * Used to look up error schema during deserialization.
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    protected abstract serializer: ShapeSerializer<string | Uint8Array>;
+    protected abstract deserializer: ShapeDeserializer<string | Uint8Array>;
+    /**
+     * @param options.defaultNamespace - used by various implementing classes.
+     * @param options.errorTypeRegistries - registry instances that contribute to error deserialization.
+     */
+    protected constructor(options: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    abstract getShapeId(): string;
+    abstract getPayloadCodec(): Codec<any, any>;
+    getRequestType(): new (...args: any[]) => HttpRequest$1;
+    getResponseType(): new (...args: any[]) => HttpResponse$1;
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    abstract serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest$1>;
+    updateServiceEndpoint(request: HttpRequest$1, endpoint: EndpointV2 | Endpoint): HttpRequest$1;
+    abstract deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1): Promise<Output>;
+    protected setHostPrefix<Input extends object>(request: HttpRequest$1, operationSchema: OperationSchema, input: Input): void;
+    protected abstract handleError(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, dataObject: any, metadata: ResponseMetadata): Promise<never>;
+    protected deserializeMetadata(output: HttpResponse$1): ResponseMetadata;
+    /**
+     * For a given error short name, a list of preferred namespaces, and a list of preferred registries,
+     * find the error's schema and class.
+     *
+     * @param name - short error shape id.
+     * @param namespaces - must contain '*' to allow matching against an undeclared namespace.
+     * @param registries - in which to look.
+     * @returns matched error schema and constructor, with worst case being the least-descriptive DocumentSchema and native Error.
+     */
+    protected resolveError(name: string, namespaces: string[], registries: TypeRegistry[]): [StaticErrorSchema, any, "modeled" | "synthetic" | "native"];
+    /**
+     * @param eventStream - the iterable provided by the caller.
+     * @param requestSchema - the schema of the event stream container (struct).
+     * @param [initialRequest] - only provided if the initial-request is part of the event stream (RPC).
+     *
+     * @returns a stream suitable for the HTTP body of a request.
+     */
+    protected serializeEventStream({ eventStream, requestSchema, initialRequest, }: {
+        eventStream: AsyncIterable<any>;
+        requestSchema: NormalizedSchema;
+        initialRequest?: any;
+    }): Promise<HttpRequest$1["body"]>;
+    /**
+     * @param response - http response from which to read the event stream.
+     * @param unionSchema - schema of the event stream container (struct).
+     * @param [initialResponseContainer] - provided and written to only if the initial response is part of the event stream (RPC).
+     *
+     * @returns the asyncIterable of the event stream.
+     */
+    protected deserializeEventStream({ response, responseSchema, initialResponseContainer, }: {
+        response: HttpResponse$1;
+        responseSchema: NormalizedSchema;
+        initialResponseContainer?: any;
+    }): Promise<AsyncIterable<{
+        [key: string]: any;
+        $unknown?: unknown;
+    }>>;
+    /**
+     * Loads eventStream capability async (for chunking).
+     */
+    protected loadEventStreamCapability(): Promise<EventStreamSerde>;
+    /**
+     * @returns content-type default header value for event stream events and other documents.
+     */
+    protected getDefaultContentType(): string;
+    /**
+     * For HTTP binding protocols, this method is overridden in {@link HttpBindingProtocol}.
+     *
+     * @deprecated only use this for HTTP binding protocols.
+     */
+    protected deserializeHttpMessage(schema: Schema$1, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, headerBindings: Set<string>, dataObject: any): Promise<string[]>;
+    protected deserializeHttpMessage(schema: Schema$1, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, dataObject: any): Promise<string[]>;
+    protected getEventStreamMarshaller(): EventStreamMarshaller;
+    /**
+     * Returns a platform-specific EventStreamMarshaller.
+     * Prefers user-injected marshaller from serdeContext (via client config),
+     * falls back to the dynamically imported provider.
+     */
+    private resolveEventStreamMarshaller;
+}
+
+/**
+ * Base for HTTP-binding protocols. Downstream examples
+ * include AWS REST JSON and AWS REST XML.
+ *
+ * @public
+ */
+declare abstract class HttpBindingProtocol extends HttpProtocol {
+    /**
+     * @override
+     */
+    protected compositeErrorRegistry: TypeRegistry;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, _input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<HttpRequest$1>;
+    protected serializeQuery(ns: NormalizedSchema, data: any, query: HttpRequest["query"]): void;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1): Promise<Output>;
+    /**
+     * The base method ignores HTTP bindings.
+     *
+     * @deprecated (only this signature) use signature without headerBindings.
+     * @override
+     */
+    protected deserializeHttpMessage(schema: Schema$1, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, headerBindings: Set<string>, dataObject: any): Promise<string[] & {
+        discardResponseBody?: boolean;
+    }>;
+    protected deserializeHttpMessage(schema: Schema$1, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, dataObject: any): Promise<string[] & {
+        discardResponseBody?: boolean;
+    }>;
+}
+
+/**
+ * This deserializer is a dispatcher that decides whether to use a string deserializer
+ * or a codec deserializer based on HTTP traits.
+ *
+ * For example, in a JSON HTTP message, the deserialization of a field will differ depending on whether
+ * it is bound to the HTTP header (string) or body (JSON).
+ *
+ * @public
+ */
+declare class HttpInterceptingShapeDeserializer<CodecShapeDeserializer extends ShapeDeserializer<any>> extends SerdeContext implements ShapeDeserializer<string | Uint8Array> {
+    private codecDeserializer;
+    private stringDeserializer;
+    constructor(codecDeserializer: CodecShapeDeserializer, codecSettings: CodecSettings);
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    read(schema: Schema$1, data: string | Uint8Array): any | Promise<any>;
+}
+
+/**
+ * Serializes a shape to string.
+ *
+ * @public
+ */
+declare class ToStringShapeSerializer extends SerdeContext implements ShapeSerializer<string> {
+    private settings;
+    private stringBuffer;
+    constructor(settings: CodecSettings);
+    write(schema: Schema$1, value: unknown): void;
+    flush(): string;
+}
+
+/**
+ * This serializer decides whether to dispatch to a string serializer or a codec serializer
+ * depending on HTTP binding traits within the given schema.
+ *
+ * For example, a JavaScript array is serialized differently when being written
+ * to a REST JSON HTTP header (comma-delimited string) and a REST JSON HTTP body (JSON array).
+ *
+ * @public
+ */
+declare class HttpInterceptingShapeSerializer<CodecShapeSerializer extends ShapeSerializer<string | Uint8Array>> implements ShapeSerializer<string | Uint8Array>, ConfigurableSerdeContext {
+    private codecSerializer;
+    private stringSerializer;
+    private buffer;
+    constructor(codecSerializer: CodecShapeSerializer, codecSettings: CodecSettings, stringSerializer?: ToStringShapeSerializer);
+    /**
+     * @override
+     */
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    write(schema: Schema$1, value: unknown): void;
+    flush(): string | Uint8Array;
+}
+
+/**
+ * @internal
+ */
+type HttpHandler<HttpHandlerConfig extends object = {}> = RequestHandler<HttpRequest, HttpResponse, HttpHandlerOptions> & {
+    /**
+     * @internal
+     */
+    updateHttpClientConfig(key: keyof HttpHandlerConfig, value: HttpHandlerConfig[typeof key]): void;
+    /**
+     * @internal
+     */
+    httpHandlerConfigs(): HttpHandlerConfig;
+};
+/**
+ * A type representing the accepted user inputs for the `requestHandler` field
+ * of a client's constructor object.
+ * You may provide an instance of an HttpHandler, or alternatively
+ * provide the constructor arguments as an object which will be passed
+ * to the constructor of the default request handler.
+ * The default class constructor to which your arguments will be passed
+ * varies. The Node.js default is the NodeHttpHandler and the browser/react-native
+ * default is the FetchHttpHandler. In rarer cases specific clients may be
+ * configured to use other default implementations such as Websocket or HTTP2.
+ * The fallback type Record<string, unknown> is part of the union to allow
+ * passing constructor params to an unknown requestHandler type.
+ *
+ * @public
+ */
+type HttpHandlerUserInput = HttpHandler | NodeHttpHandlerOptions | FetchHttpHandlerOptions | Record<string, unknown>;
+
+/**
+ * @internal
+ */
+declare class SerdeContextConfig implements ConfigurableSerdeContext {
+    protected serdeContext?: SerdeFunctions;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}
+
+/**
+ * @public
+ */
+type JsonSettings = CodecSettings & {
+    jsonName: boolean;
+    /**
+     * When true, bigInteger and bigDecimal values are serialized as JSON strings
+     * to preserve arbitrary precision (Smithy RPCv2 JSON behavior). When false or
+     * unset, they are serialized as unquoted JSON numbers (AWS JSON 1.0/1.1 behavior).
+     */
+    bigNumberAsString?: boolean;
+};
+
+/**
+ * Codec grouping the v2 serializer and deserializer.
+ * @public
+ */
+declare class JsonCodec2 extends SerdeContextConfig implements $Codec<Uint8Array, string> {
+    readonly settings: JsonSettings;
+    constructor(settings: JsonSettings);
+    createSerializer(): $ShapeSerializer<Uint8Array>;
+    createDeserializer(): $ShapeDeserializer<string>;
+}
+
+/** An output with the parsed response body, including fields this SDK version does not model. */
+type WithRaw<T> = T & {
+    readonly raw?: Record<string, unknown>;
+};
+declare class CaitlynRestJsonProtocol extends HttpBindingProtocol {
+    protected serializer: HttpInterceptingShapeSerializer<$ShapeSerializer<Uint8Array<ArrayBufferLike>>>;
+    protected deserializer: HttpInterceptingShapeDeserializer<$ShapeDeserializer<string>>;
+    private readonly codec;
+    constructor({ defaultNamespace, errorTypeRegistries }: {
+        defaultNamespace: string;
+        errorTypeRegistries?: TypeRegistry[];
+    });
+    getShapeId(): string;
+    getDefaultContentType(): string;
+    getPayloadCodec(): JsonCodec2;
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: Parameters<HttpBindingProtocol['serializeRequest']>[2]): Promise<HttpRequest$1>;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1): Promise<Output>;
+    protected deserializeMetadata(response: HttpResponse$1): ResponseMetadata;
+    protected handleError(_operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: HttpResponse$1, dataObject: Record<string, unknown>, metadata: ResponseMetadata): Promise<never>;
+}
+
+declare const CAITLYN_SDK_USER_AGENT_PREFIX = "caitlyn-sdk-ts";
+/**
+ * Connection errors (PROTOCOL.md 6.5): a call that got no HTTP response, or whose connection failed while the
+ * body was read, fails with `toError(operation, cause)`, the generated `CaitlynConnectionError`, once the retries
+ * are spent. Token requests are not marked: their failures stay sign-in errors.
+ */
+declare function getCaitlynConnectionErrorPlugin(toError: (operation: string, cause: unknown) => Error): Pluggable<any, any>;
+declare class NotSupportedByServer extends Error {
+    readonly operation: string;
+    readonly requires: string;
+    readonly server: string;
+    constructor(operation: string, requires: string, server: string);
+}
+/**
+ * @param options.sdkModel the highest @since in the model: the server release this SDK was generated against
+ * @param options.retrySafeOperations operations that are @readonly, @idempotent or have an @idempotencyToken member
+ * @param options.since `Operation=5.120.0` and `Operation.member=5.124.0` entries from the model's @since traits
+ */
+declare function getCaitlynSdkPlugin(config: {
+    caitlynSdkVersion?: string;
+    customUserAgent?: string;
+}, options: {
+    sdkModel: string;
+    retrySafeOperations: string[];
+    since?: string[];
+}): Pluggable<any, any>;
+
+declare const NO_RETRY: unique symbol;
+declare class CaitlynRetryStrategy implements RetryStrategyV2 {
+    private readonly maxRetryDelayMs;
+    readonly mode = "standard";
+    private readonly maxAttempts;
+    constructor(maxAttempts?: number | Provider<number>, maxRetryDelayMs?: number);
+    acquireInitialRetryToken(): Promise<RetryToken>;
+    refreshRetryTokenForRetry(token: RetryToken, info: RetryErrorInfo): Promise<RetryToken>;
+    recordSuccess(): void;
+}
+
+declare const caitlynEndpointProvider: (params: {
+    endpoint?: string;
+}) => EndpointV2;
+
+/** The tracer every Caitlyn span comes from. */
+declare function caitlynTracer(provider?: TracerProvider): Tracer;
+declare function getCaitlynTelemetryPlugin(provider?: TracerProvider): Pluggable<any, any>;
+
+interface SseSpec {
+    /** SSE `event:` names this SDK knows (the union members' jsonNames). Others are skipped. */
+    readonly known: ReadonlySet<string>;
+    /** The event that ends the stream successfully, and the member finalMessage() returns. */
+    readonly final?: {
+        event: string;
+        member: string;
+    };
+    /** The event carrying RFC 9457 problem details; it ends the stream with a thrown error. */
+    readonly errorEvent?: string;
+    /** Builds the typed error for an error event. */
+    readonly toError: (problem: Record<string, unknown>) => Error;
+}
+/** What opening (or resuming) a stream returns: the command output, with its event body and response metadata. */
+interface SseOpened {
+    readonly events: unknown;
+    readonly $metadata?: {
+        readonly requestId?: string;
+    };
+}
+declare class SseStream<E extends {
+    type: string;
+}, F = never> implements AsyncIterable<E> {
+    private readonly spec;
+    private readonly open;
+    private readonly resume;
+    private readonly signal?;
+    private readonly maxReconnects;
+    private finalValue?;
+    private consumed;
+    private readonly seen;
+    lastEventId?: string;
+    reconnects: number;
+    /** The Caitlyn-Request-Id of the response that opened the stream; set once iteration has started. */
+    requestId?: string;
+    constructor(spec: SseSpec, open: () => Promise<SseOpened>, resume: ((lastEventId: string | undefined) => Promise<SseOpened>) | undefined, signal?: AbortSignal | undefined, maxReconnects?: number);
+    private aborted;
+    [Symbol.asyncIterator](): AsyncGenerator<E>;
+    /** Drains the stream if needed and returns the final event's member. */
+    finalMessage(): Promise<F>;
+}
+
+interface SseMessage {
+    id?: string;
+    event: string;
+    data: string;
+}
+declare function parseSse(body: AsyncIterable<Uint8Array | string>): AsyncGenerator<SseMessage>;
+
+interface UploadSlot {
+    uploadUrl: string;
+    uploadMethod: string;
+    requiredHeaders: Record<string, string>;
+}
+interface UploadMeta {
+    fileName: string;
+    contentType: string;
+    byteSize: number;
+    sha256: string;
+}
+declare function uploadFile<S extends UploadSlot>(file: Blob, fileName: string, reserve: (meta: UploadMeta) => Promise<S>, toError: (problem: Record<string, unknown>) => Error, signal?: AbortSignal, tracer?: Tracer): Promise<S>;
+
+interface AwsCredentials {
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    /** When the credentials stop working; the SDK fetches new ones a minute before. */
+    expiration?: Date;
+}
+type AwsCredentialSource = AwsCredentials | (() => Promise<AwsCredentials> | AwsCredentials);
+interface SignableRequest {
+    method: string;
+    url: URL;
+    headers: Record<string, string>;
+    body: string;
+}
+/**
+ * Signs a request with AWS Signature Version 4 (header form) and returns the headers to send, including
+ * `authorization`, `x-amz-date`, `x-amz-content-sha256` and, for temporary credentials, `x-amz-security-token`.
+ */
+declare function signV4(req: SignableRequest, creds: AwsCredentials, region: string, service: string, now?: Date): Promise<Record<string, string>>;
+/**
+ * The default credential source: AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY (with AWS_SESSION_TOKEN), as AWS
+ * Lambda and CI runners set them; otherwise the container credentials endpoint
+ * (AWS_CONTAINER_CREDENTIALS_FULL_URI or _RELATIVE_URI), as ECS, Fargate and AgentCore runtimes set it.
+ */
+declare function defaultAwsCredentials(fetchFn?: typeof fetch): Promise<AwsCredentials>;
+interface WebIdentityTokenRequest {
+    region: string;
+    audience: string;
+    credentials: AwsCredentials;
+    signingAlgorithm?: 'ES384' | 'RS256';
+    durationSeconds?: number;
+    /** Overrides https://sts.{region}.amazonaws.com/ (tests, FIPS or VPC endpoints). */
+    stsEndpoint?: string;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}
+/** Calls STS GetWebIdentityToken (outbound identity federation) on a regional endpoint and returns the JWT. */
+declare function getWebIdentityToken(r: WebIdentityTokenRequest): Promise<{
+    token: string;
+    expiration?: Date;
+}>;
+
+/** Tokens the `oauth` mode keeps. `expiresAt` is milliseconds since the epoch. */
+interface OAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    scope?: string;
+}
+/** Where the `oauth` mode keeps tokens between processes, for example encrypted on a server. */
+interface TokenStore {
+    load(): Promise<OAuthTokens | undefined> | OAuthTokens | undefined;
+    save(tokens: OAuthTokens): Promise<void> | void;
+    clear(): Promise<void> | void;
+}
+type AuthOptions = {
+    mode: 'token';
+    token: string;
+    /** In a browser, silences the warning that a long-lived token there is exposed (for local testing). */
+    allowBrowserToken?: boolean;
+} | {
+    mode: 'clientCredentials';
+    clientId: string;
+    clientSecret: string;
+    scopes?: string[];
+    resource?: string;
+} | {
+    mode: 'oauth';
+    clientId: string;
+    /** For a confidential client on a server; omit in a browser. */
+    clientSecret?: string;
+    redirectUri?: string;
+    scopes?: string[];
+    resource?: string;
+    /** Default: kept in memory for the life of the client. */
+    tokenStore?: TokenStore;
+} | {
+    mode: 'awsIam';
+    /** The regional STS endpoint to use. Default: AWS_REGION, then AWS_DEFAULT_REGION. */
+    region?: string;
+    /** Default: environment variables, then the container credentials endpoint. Accepts any @aws-sdk provider. */
+    credentials?: AwsCredentialSource;
+    signingAlgorithm?: 'ES384' | 'RS256';
+    /** Lifetime of the AWS-signed token, at most 300 (the default). */
+    durationSeconds?: number;
+    /** The audience the AWS token is minted for. Default: the workspace resource URL. */
+    audience?: string;
+    stsEndpoint?: string;
+} | {
+    mode: 'workloadIdentity';
+    /** Returns the workload's current identity token, for example a GitLab CI id_tokens variable. */
+    token: () => string | Promise<string>;
+    resource?: string;
+} | {
+    mode: 'session';
+    /** A session cookie, for server-side use. In a browser leave it out: the browser sends its own. */
+    cookie?: string;
+    /** Sent as Origin on every write. Default: the workspace URL. */
+    origin?: string;
+};
+/** A sign-in failure: the token endpoint's OAuth error, or a failure to get the identity it exchanges. */
+declare class CaitlynAuthError extends Error {
+    /** The OAuth error code (`invalid_client`, `invalid_grant`…), or `sign_in_required`. */
+    readonly code: string;
+    readonly status?: number | undefined;
+    readonly requestId?: string | undefined;
+    readonly name = "CaitlynAuthError";
+    constructor(message: string, 
+    /** The OAuth error code (`invalid_client`, `invalid_grant`…), or `sign_in_required`. */
+    code: string, status?: number | undefined, requestId?: string | undefined);
+}
+/** The audience of a workspace's tokens: its resource URL, https://<workspace>/api. */
+declare const workspaceAudience: (workspace: string) => string;
+/** A workspace given as a hostname or a URL, as its bare hostname. */
+declare const workspaceHost: (workspace: string) => string;
+/** What `client.auth` offers: the current token, and the `oauth` mode's sign-in steps. */
+declare class AuthSession {
+    readonly options: AuthOptions;
+    /** Where the token endpoint is: the client's endpoint, which an override may move (a proxy, a local app). */
+    readonly endpoint: string;
+    /** The workspace hostname. Like an AWS region, it decides the endpoint and the token audience. */
+    readonly workspace: string;
+    private readonly fetchFn;
+    private cached?;
+    /** The token the server last refused with a 401, so `oauth` never reloads it from the store. */
+    private refused?;
+    private inflight?;
+    private memoryTokens?;
+    readonly tokenEndpoint: string;
+    readonly authorizationEndpoint: string;
+    /** The workspace's resource URL, https://<workspace>/api: the audience every token is bound to. */
+    readonly resource: string;
+    /** https://<workspace>: the default Origin for session writes. */
+    readonly workspaceUrl: string;
+    constructor(options: AuthOptions, 
+    /** Where the token endpoint is: the client's endpoint, which an override may move (a proxy, a local app). */
+    endpoint: string, 
+    /** The workspace hostname. Like an AWS region, it decides the endpoint and the token audience. */
+    workspace: string, fetchFn?: typeof fetch);
+    get mode(): "token" | "clientCredentials" | "oauth" | "awsIam" | "workloadIdentity" | "session";
+    /** The bearer token for the next request: cached, or fetched once however many calls ask at the same time. */
+    token(): Promise<string>;
+    /** Forgets the cached token, so the next call signs in again (done once after a 401). */
+    invalidate(): void;
+    /** Whether a 401 is worth one more try with a new token. */
+    get canRefresh(): boolean;
+    /** Starts sign-in (`oauth` mode): the URL to send the person to, and the state and PKCE verifier to keep. */
+    authorizationUrl(opts?: {
+        state?: string;
+        scopes?: string[];
+        redirectUri?: string;
+    }): Promise<{
+        url: string;
+        state: string;
+        codeVerifier: string;
+    }>;
+    /** Finishes sign-in (`oauth` mode): checks state, exchanges the code and saves the tokens. */
+    handleCallback(p: {
+        code: string;
+        state?: string;
+        expectedState?: string;
+        codeVerifier: string;
+        redirectUri?: string;
+    }): Promise<OAuthTokens>;
+    /** Signs out (`oauth` mode): revokes the refresh token where possible and clears the store. */
+    signOut(): Promise<void>;
+    private oauth;
+    private clientParams;
+    private loadTokens;
+    private saveTokens;
+    private fetchToken;
+    private exchange;
+    private requestToken;
+}
+/**
+ * The generated client's `token` identity provider. It reports the token as already near expiry, so Smithy's
+ * memoisation asks again on every request and AuthSession's own cache (which knows the real expiry, and can
+ * be invalidated after a 401) decides.
+ */
+declare const tokenIdentityProvider: (auth: AuthSession) => () => Promise<TokenIdentity>;
+/** Session headers, and one retry with a new token after a 401. */
+declare function getCaitlynAuthPlugin(auth: AuthSession): Pluggable<any, any>;
+
+interface CaitlynOptions {
+    /**
+     * The workspace hostname, for example "your-company.getcaitlyn.ai". Like an AWS region, it decides where
+     * requests go (https://<workspace>/api) and the audience every token is bound to (https://<workspace>/api).
+     */
+    workspace: string;
+    /** How the client signs in: token, clientCredentials, oauth, awsIam, workloadIdentity or session. */
+    auth: AuthOptions;
+    /** The fetch the sign-in requests use (token endpoint, STS, container credentials). Default: global fetch. */
+    fetch?: typeof fetch;
+    /**
+     * Overrides the base URL the operation paths (/v3/…) and the token endpoint (/oauth/token) are appended to,
+     * for a proxy or a local app. Default: https://{workspace}/api. It never changes the token audience.
+     */
+    endpoint?: string;
+    /**
+     * The HTTP handler API calls go through, for this client only: a `NodeHttpHandler` with your own `https.Agent`
+     * (a private certificate authority, a proxy, keep-alive settings), a `FetchHttpHandler`, any object with
+     * `handle(request)`, or the default handler's options (`{ httpsAgent }` on Node). Default: a handler of the
+     * client's own. Sign-in requests go through `fetch`.
+     */
+    requestHandler?: HttpHandlerUserInput;
+    maxAttempts?: number;
+    /** Longest Retry-After the SDK waits for (default 60 000 ms); above it the call fails at once. */
+    maxRetryDelayMs?: number;
+    telemetry?: {
+        tracerProvider?: TracerProvider;
+        enabled?: boolean;
+    };
+}
+interface CallOptions {
+    signal?: AbortSignal;
+}
+/** The base URL of a workspace's API: its hostname, over HTTPS, with the /api prefix every Caitlyn route has. */
+declare function workspaceEndpoint(workspace: string): string;
+/** The sign-in session for a set of options: what `client.auth` is. */
+declare function createAuth(opts: CaitlynOptions): AuthSession;
+/** The generated client's configuration for a set of options. */
+declare function clientConfig(opts: CaitlynOptions, auth?: AuthSession): {
+    retryStrategy?: CaitlynRetryStrategy | undefined;
+    maxAttempts?: number | undefined;
+    requestHandler?: HttpHandlerUserInput | undefined;
+    /** The workspace this client is for; readable as client.config.workspace. */
+    workspace: string;
+    endpoint: string;
+    token: () => Promise<TokenIdentity>;
+    /** The tracer upload helpers record the byte transfer with (PROTOCOL.md 13); absent with telemetry off. */
+    caitlynTracer: _opentelemetry_api.Tracer | undefined;
+};
+/** One problem with one request member or query parameter, on a 400 VALIDATION_FAILED. */
+interface CaitlynFieldError {
+    pointer?: string;
+    parameter?: string;
+    code: string;
+    detail?: string;
+}
+/** The RFC 9457 fields every Caitlyn error carries (PROTOCOL.md 6.3). */
+interface CaitlynErrorFields {
+    status?: number;
+    code?: string;
+    type?: string;
+    title?: string;
+    detail?: string;
+    requestId?: string;
+    retryAfterSeconds?: number;
+    errors?: CaitlynFieldError[];
+    /** The response body as received, as text, at most its first 8 KiB: the only view of a body that is not problem details (PROTOCOL.md 6.3). */
+    rawBody?: string;
+    /** True when the body was longer than 8 KiB and `rawBody` holds only its first 8 KiB. */
+    rawBodyTruncated?: boolean;
+}
+
+type WaiterState = 'success' | 'failure' | 'retry';
+interface WaiterOptions {
+    /** Stops waiting and throws the signal's reason (use AbortSignal.timeout() for a deadline). */
+    signal?: AbortSignal;
+    /** The longest the waiter waits in total, in milliseconds. Default: no limit beyond the signal. */
+    maxWaitMs?: number;
+    /** Default 2 000 ms (Smithy's default minDelay). */
+    minDelayMs?: number;
+    /** Default 120 000 ms (Smithy's default maxDelay). */
+    maxDelayMs?: number;
+}
+/** A waiter ended in a failure state, or ran out of time. `last` is the last output or error it saw. */
+declare class WaiterError extends Error {
+    readonly reason: 'failure' | 'timeout';
+    readonly last: unknown;
+    readonly attempts: number;
+    readonly name = "WaiterError";
+    constructor(message: string, reason: 'failure' | 'timeout', last: unknown, attempts: number);
+}
+/**
+ * Calls `read` until `accept` says success (returns the output) or failure (throws WaiterError).
+ * `accept` sees either `{output}` or `{error}`; returning undefined for an error rethrows it.
+ */
+declare function waitUntil<T>(name: string, read: (signal?: AbortSignal) => Promise<T>, accept: (r: {
+    output: T;
+    error?: undefined;
+} | {
+    output?: undefined;
+    error: unknown;
+}) => WaiterState | undefined, opts?: WaiterOptions): Promise<T>;
+
+export { AuthSession, CAITLYN_SDK_USER_AGENT_PREFIX, CaitlynAuthError, CaitlynRestJsonProtocol, CaitlynRetryStrategy, NO_RETRY, NotSupportedByServer, SseStream, WaiterError, caitlynEndpointProvider, caitlynTracer, clientConfig, createAuth, defaultAwsCredentials, getCaitlynAuthPlugin, getCaitlynConnectionErrorPlugin, getCaitlynSdkPlugin, getCaitlynTelemetryPlugin, getWebIdentityToken, parseSse, signV4, tokenIdentityProvider, uploadFile, waitUntil, workspaceAudience, workspaceEndpoint, workspaceHost };
+export type { AuthOptions, AwsCredentialSource, AwsCredentials, CaitlynErrorFields, CaitlynFieldError, CaitlynOptions, CallOptions, OAuthTokens, SseMessage, SseOpened, SseSpec, TokenStore, UploadMeta, UploadSlot, WaiterOptions, WaiterState, WithRaw };