@jjrawlins/cdk-iam-policy-builder-helper 0.0.76 → 0.0.78

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

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/shapes.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/signature.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/stream.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-common-types.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-input-types.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-output-types.d.ts

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/transfer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @public
+ */
+export type RequestHandlerOutput<ResponseType> = {
+    response: ResponseType;
+};
+/**
+ * @public
+ */
+export interface RequestHandler<RequestType, ResponseType, HandlerOptions = {}> {
+    /**
+     * metadata contains information of a handler. For example
+     * 'h2' refers this handler is for handling HTTP/2 requests,
+     * whereas 'h1' refers handling HTTP1 requests
+     */
+    metadata?: RequestHandlerMetadata;
+    destroy?: () => void;
+    handle: (request: RequestType, handlerOptions?: HandlerOptions) => Promise<RequestHandlerOutput<ResponseType>>;
+}
+/**
+ * @public
+ */
+export interface RequestHandlerMetadata {
+    handlerProtocol: RequestHandlerProtocol | string;
+}
+/**
+ * @public
+ * Values from ALPN Protocol IDs.
+ * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
+ */
+export declare enum RequestHandlerProtocol {
+    HTTP_0_9 = "http/0.9",
+    HTTP_1_0 = "http/1.0",
+    TDS_8_0 = "tds/8.0"
+}
+/**
+ * @public
+ */
+export interface RequestContext {
+    destination: URL;
+}

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/transform/client-method-transforms.d.ts

@@ -0,0 +1,26 @@
+import type { CommandIO } from "../command";
+import type { MetadataBearer } from "../response";
+import type { StreamingBlobPayloadOutputTypes } from "../streaming-payload/streaming-blob-payload-output-types";
+import type { Transform } from "./type-transform";
+/**
+ * @internal
+ *
+ * Narrowed version of InvokeFunction used in Client::send.
+ */
+export interface NarrowedInvokeFunction<NarrowType, HttpHandlerOptions, InputTypes extends object, OutputTypes extends MetadataBearer> {
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options: HttpHandlerOptions, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    <InputType extends InputTypes, OutputType extends OutputTypes>(command: CommandIO<InputType, OutputType>, options?: HttpHandlerOptions, cb?: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>> | void;
+}
+/**
+ * @internal
+ *
+ * Narrowed version of InvokeMethod used in aggregated Client methods.
+ */
+export interface NarrowedInvokeMethod<NarrowType, HttpHandlerOptions, InputType extends object, OutputType extends MetadataBearer> {
+    (input: InputType, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;
+    (input: InputType, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    (input: InputType, options: HttpHandlerOptions, cb: (err: unknown, data?: Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>) => void): void;
+    (input: InputType, options?: HttpHandlerOptions, cb?: (err: unknown, data?: OutputType) => void): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>> | void;
+}

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

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

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/transform/exact.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ *
+ * Checks that A and B extend each other.
+ */
+export type Exact<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false;

package/node_modules/@aws-crypto/sha256-browser/node_modules/@smithy/types/dist-types/transform/mutable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @internal
+ */
+export type Mutable<Type> = {
+    -readonly [Property in keyof Type]: Type[Property];
+};