@aws/lsp-codewhisperer 0.0.94 → 0.0.95

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-output-types.d.ts

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

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/transfer.d.ts

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

package/node_modules/@amazon/elastic-gumby-frontend-client/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/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/transform/client-payload-blob-type-narrow.d.ts

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

package/node_modules/@amazon/elastic-gumby-frontend-client/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/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/transform/no-undefined.d.ts

@@ -0,0 +1,68 @@
+import type { InvokeMethod, InvokeMethodOptionalArgs } from "../client";
+import type { GetOutputType } from "../command";
+import type { DocumentType } from "../shapes";
+/**
+ * @public
+ *
+ * This type is intended as a type helper for generated clients.
+ * When initializing client, cast it to this type by passing
+ * the client constructor type as the type parameter.
+ *
+ * It will then recursively remove "undefined" as a union type from all
+ * input and output shapes' members. Note, this does not affect
+ * any member that is optional (?) such as outputs with no required members.
+ *
+ * @example
+ * ```ts
+ * const client = new Client({}) as AssertiveClient<Client>;
+ * ```
+ */
+export type AssertiveClient<Client extends object> = NarrowClientIOTypes<Client>;
+/**
+ * @public
+ *
+ * This is similar to AssertiveClient but additionally changes all
+ * output types to (recursive) Required<T> so as to bypass all output nullability guards.
+ */
+export type UncheckedClient<Client extends object> = UncheckedClientOutputTypes<Client>;
+/**
+ * @internal
+ *
+ * Excludes undefined recursively.
+ */
+export type NoUndefined<T> = T extends Function ? T : T extends DocumentType ? T : [T] extends [object] ? {
+    [key in keyof T]: NoUndefined<T[key]>;
+} : Exclude<T, undefined>;
+/**
+ * @internal
+ *
+ * Excludes undefined and optional recursively.
+ */
+export type RecursiveRequired<T> = T extends Function ? T : T extends DocumentType ? T : [T] extends [object] ? {
+    [key in keyof T]-?: RecursiveRequired<T[key]>;
+} : Exclude<T, undefined>;
+/**
+ * @internal
+ *
+ * Removes undefined from unions.
+ */
+type NarrowClientIOTypes<ClientType extends object> = {
+    [key in keyof ClientType]: [ClientType[key]] extends [
+        InvokeMethodOptionalArgs<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethodOptionalArgs<NoUndefined<FunctionInputTypes>, NoUndefined<FunctionOutputTypes>> : [ClientType[key]] extends [InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>] ? InvokeMethod<NoUndefined<FunctionInputTypes>, NoUndefined<FunctionOutputTypes>> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<NoUndefined<GetOutputType<Command>>>;
+};
+/**
+ * @internal
+ *
+ * Removes undefined from unions and adds yolo output types.
+ */
+type UncheckedClientOutputTypes<ClientType extends object> = {
+    [key in keyof ClientType]: [ClientType[key]] extends [
+        InvokeMethodOptionalArgs<infer FunctionInputTypes, infer FunctionOutputTypes>
+    ] ? InvokeMethodOptionalArgs<NoUndefined<FunctionInputTypes>, RecursiveRequired<FunctionOutputTypes>> : [ClientType[key]] extends [InvokeMethod<infer FunctionInputTypes, infer FunctionOutputTypes>] ? InvokeMethod<NoUndefined<FunctionInputTypes>, RecursiveRequired<FunctionOutputTypes>> : ClientType[key];
+} & {
+    send<Command>(command: Command, options?: any): Promise<RecursiveRequired<NoUndefined<GetOutputType<Command>>>>;
+};
+export {};

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/transform/type-transform.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @public
+ *
+ * Transforms any members of the object T having type FromType
+ * to ToType. This applies only to exact type matches.
+ *
+ * This is for the case where FromType is a union and only those fields
+ * matching the same union should be transformed.
+ */
+export type Transform<T, FromType, ToType> = ConditionalRecursiveTransformExact<T, FromType, ToType>;
+/**
+ * @internal
+ *
+ * Returns ToType if T matches exactly with FromType.
+ */
+type TransformExact<T, FromType, ToType> = [T] extends [FromType] ? ([FromType] extends [T] ? ToType : T) : T;
+/**
+ * @internal
+ *
+ * Applies TransformExact to members of an object recursively.
+ */
+type RecursiveTransformExact<T, FromType, ToType> = T extends Function ? T : T extends object ? {
+    [key in keyof T]: [T[key]] extends [FromType] ? [FromType] extends [T[key]] ? ToType : ConditionalRecursiveTransformExact<T[key], FromType, ToType> : ConditionalRecursiveTransformExact<T[key], FromType, ToType>;
+} : TransformExact<T, FromType, ToType>;
+/**
+ * @internal
+ *
+ * Same as RecursiveTransformExact but does not assign to an object
+ * unless there is a matching transformed member.
+ */
+type ConditionalRecursiveTransformExact<T, FromType, ToType> = [T] extends [
+    RecursiveTransformExact<T, FromType, ToType>
+] ? [RecursiveTransformExact<T, FromType, ToType>] extends [T] ? T : RecursiveTransformExact<T, FromType, ToType> : RecursiveTransformExact<T, FromType, ToType>;
+export {};

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/abort-handler.d.ts

@@ -0,0 +1,7 @@
+import { AbortSignal as DeprecatedAbortSignal } from "./abort";
+/**
+ * @public
+ */
+export interface AbortHandler {
+    (this: AbortSignal | DeprecatedAbortSignal, ev: any): any;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/abort.d.ts

@@ -0,0 +1,50 @@
+import { AbortHandler } from "./abort-handler";
+/**
+ * @public
+ */
+export { AbortHandler };
+/**
+ * @public
+ * @deprecated use platform (global) type for AbortSignal.
+ *
+ * Holders of an AbortSignal object may query if the associated operation has
+ * been aborted and register an onabort handler.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
+ */
+export interface AbortSignal {
+    /**
+     * 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;
+}
+/**
+ * @public
+ * @deprecated use platform (global) type for AbortController.
+ *
+ * The AWS SDK uses a Controller/Signal model to allow for cooperative
+ * cancellation of asynchronous operations. When initiating such an operation,
+ * the caller can create an AbortController and then provide linked signal to
+ * subtasks. This allows a single source to communicate to multiple consumers
+ * that an action has been aborted without dictating how that cancellation
+ * should be handled.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortController
+ */
+export interface AbortController {
+    /**
+     * An object that reports whether the action associated with this
+     * `AbortController` has been cancelled.
+     */
+    readonly signal: AbortSignal;
+    /**
+     * Declares the operation associated with this AbortController to have been
+     * cancelled.
+     */
+    abort(): void;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpApiKeyAuth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+export declare enum HttpApiKeyAuthLocation {
+    HEADER = "header",
+    QUERY = "query"
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpAuthScheme.d.ts

@@ -0,0 +1,49 @@
+import { Identity, IdentityProvider } from "../identity/identity";
+import { HandlerExecutionContext } from "../middleware";
+import { HttpSigner } from "./HttpSigner";
+import { IdentityProviderConfig } from "./IdentityProviderConfig";
+/**
+ * ID for {@link HttpAuthScheme}
+ * @internal
+ */
+export type HttpAuthSchemeId = string;
+/**
+ * Interface that defines an HttpAuthScheme
+ * @internal
+ */
+export interface HttpAuthScheme {
+    /**
+     * ID for an HttpAuthScheme, typically the absolute shape ID of a Smithy auth trait.
+     */
+    schemeId: HttpAuthSchemeId;
+    /**
+     * Gets the IdentityProvider corresponding to an HttpAuthScheme.
+     */
+    identityProvider(config: IdentityProviderConfig): IdentityProvider<Identity> | undefined;
+    /**
+     * HttpSigner corresponding to an HttpAuthScheme.
+     */
+    signer: HttpSigner;
+}
+/**
+ * Interface that defines the identity and signing properties when selecting
+ * an HttpAuthScheme.
+ * @internal
+ */
+export 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
+ */
+export interface SelectedHttpAuthScheme {
+    httpAuthOption: HttpAuthOption;
+    identity: Identity;
+    signer: HttpSigner;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpAuthSchemeProvider.d.ts

@@ -0,0 +1,20 @@
+import { HandlerExecutionContext } from "../middleware";
+import { HttpAuthOption } from "./HttpAuthScheme";
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeParameters {
+    operation?: string;
+}
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeProvider<TParameters extends HttpAuthSchemeParameters> {
+    (authParameters: TParameters): HttpAuthOption[];
+}
+/**
+ * @internal
+ */
+export interface HttpAuthSchemeParametersProvider<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    (config: TConfig, context: TContext, input: TInput): Promise<TParameters>;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/HttpSigner.d.ts

@@ -0,0 +1,41 @@
+import { HttpRequest, HttpResponse } from "../http";
+import { Identity } from "../identity/identity";
+/**
+ * @internal
+ */
+export interface ErrorHandler {
+    (signingProperties: Record<string, unknown>): <E extends Error>(error: E) => never;
+}
+/**
+ * @internal
+ */
+export interface SuccessHandler {
+    (httpResponse: HttpResponse | unknown, signingProperties: Record<string, unknown>): void;
+}
+/**
+ * Interface to sign identity and signing properties.
+ * @internal
+ */
+export 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, identity: Identity, signingProperties: Record<string, unknown>): Promise<HttpRequest>;
+    /**
+     * 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;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/IdentityProviderConfig.d.ts

@@ -0,0 +1,14 @@
+import { Identity, IdentityProvider } from "../identity/identity";
+import { HttpAuthSchemeId } from "./HttpAuthScheme";
+/**
+ * Interface to get an IdentityProvider for a specified HttpAuthScheme
+ * @internal
+ */
+export interface IdentityProviderConfig {
+    /**
+     * Get the IdentityProvider for a specified HttpAuthScheme.
+     * @param schemeId schemeId of the HttpAuthScheme
+     * @returns IdentityProvider or undefined if HttpAuthScheme is not found
+     */
+    getIdentityProvider(schemeId: HttpAuthSchemeId): IdentityProvider<Identity> | undefined;
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/auth.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @internal
+ *
+ * Authentication schemes represent a way that the service will authenticate the customer’s identity.
+ */
+export 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>;
+}
+/**
+ * @internal
+ * @deprecated
+ */
+export 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;
+}
+/**
+ * @internal
+ * @deprecated
+ */
+export declare enum HttpAuthLocation {
+    HEADER = "header",
+    QUERY = "query"
+}

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/auth/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./auth";
+export * from "./HttpApiKeyAuth";
+export * from "./HttpAuthScheme";
+export * from "./HttpAuthSchemeProvider";
+export * from "./HttpSigner";
+export * from "./IdentityProviderConfig";

package/node_modules/@amazon/elastic-gumby-frontend-client/node_modules/@smithy/types/dist-types/ts3.4/blob/blob-payload-input-types.d.ts

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