@aws/lsp-codewhisperer 0.0.39 → 0.0.41

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/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/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/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/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/blob/blob-payload-input-types.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/checksum.d.ts

@@ -0,0 +1,63 @@
+import { SourceData } from "./crypto";
+/**
+ * @public
+ *
+ * An object that provides a checksum of data provided in chunks to `update`.
+ * The checksum may be performed incrementally as chunks are received or all
+ * at once when the checksum is finalized, depending on the underlying
+ * implementation.
+ *
+ * It's recommended to compute checksum incrementally to avoid reading the
+ * entire payload in memory.
+ *
+ * A class that implements this interface may accept an optional secret key in its
+ * constructor while computing checksum value, when using HMAC. If provided,
+ * this secret key would be used when computing checksum.
+ */
+export interface Checksum {
+    /**
+     * Constant length of the digest created by the algorithm in bytes.
+     */
+    digestLength?: number;
+    /**
+     * Creates a new checksum object that contains a deep copy of the internal
+     * state of the current `Checksum` object.
+     */
+    copy?(): Checksum;
+    /**
+     * Returns the digest of all of the data passed.
+     */
+    digest(): Promise<Uint8Array>;
+    /**
+     * Allows marking a checksum for checksums that support the ability
+     * to mark and reset.
+     *
+     * @param readLimit - The maximum limit of bytes that can be read
+     *   before the mark position becomes invalid.
+     */
+    mark?(readLimit: number): void;
+    /**
+     * Resets the checksum to its initial value.
+     */
+    reset(): void;
+    /**
+     * Adds a chunk of data for which checksum needs to be computed.
+     * This can be called many times with new data as it is streamed.
+     *
+     * Implementations may override this method which passes second param
+     * which makes Checksum object stateless.
+     *
+     * @param chunk - The buffer to update checksum with.
+     */
+    update(chunk: Uint8Array): void;
+}
+/**
+ * @public
+ *
+ * A constructor for a Checksum that may be used to calculate an HMAC. Implementing
+ * classes should not directly hold the provided key in memory beyond the
+ * lexical scope of the constructor.
+ */
+export interface ChecksumConstructor {
+    new (secret?: SourceData): Checksum;
+}

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/client.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/command.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/connection/config.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/connection/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./config";
+export * from "./manager";
+export * from "./pool";

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/connection/manager.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/connection/pool.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/crypto.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @public
+ */
+export type SourceData = string | ArrayBuffer | ArrayBufferView;
+/**
+ * @public
+ *
+ * An object that provides a hash of data provided in chunks to `update`. The
+ * hash may be performed incrementally as chunks are received or all at once
+ * when the hash is finalized, depending on the underlying implementation.
+ *
+ * @deprecated use {@link Checksum}
+ */
+export interface Hash {
+    /**
+     * Adds a chunk of data to the hash. If a buffer is provided, the `encoding`
+     * argument will be ignored. If a string is provided without a specified
+     * encoding, implementations must assume UTF-8 encoding.
+     *
+     * Not all encodings are supported on all platforms, though all must support
+     * UTF-8.
+     */
+    update(toHash: SourceData, encoding?: "utf8" | "ascii" | "latin1"): void;
+    /**
+     * Finalizes the hash and provides a promise that will be fulfilled with the
+     * raw bytes of the calculated hash.
+     */
+    digest(): Promise<Uint8Array>;
+}
+/**
+ * @public
+ *
+ * A constructor for a hash that may be used to calculate an HMAC. Implementing
+ * classes should not directly hold the provided key in memory beyond the
+ * lexical scope of the constructor.
+ *
+ * @deprecated use {@link ChecksumConstructor}
+ */
+export interface HashConstructor {
+    new (secret?: SourceData): Hash;
+}
+/**
+ * @public
+ *
+ * A function that calculates the hash of a data stream. Determining the hash
+ * will consume the stream, so only replayable streams should be provided to an
+ * implementation of this interface.
+ */
+export interface StreamHasher<StreamType = any> {
+    (hashCtor: HashConstructor, stream: StreamType): Promise<Uint8Array>;
+}
+/**
+ * @public
+ *
+ * A function that returns a promise fulfilled with bytes from a
+ * cryptographically secure pseudorandom number generator.
+ */
+export interface randomValues {
+    (byteLength: number): Promise<Uint8Array>;
+}

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/downlevel-ts3.4/transform/type-transform.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @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> = RecursiveTransformExact<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 : RecursiveTransformExact<T[key], FromType, ToType> : RecursiveTransformExact<T[key], FromType, ToType>;
+} : TransformExact<T, FromType, ToType>;
+export {};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/encode.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoint.d.ts

@@ -0,0 +1,77 @@
+import { AuthScheme } from "./auth/auth";
+/**
+ * @public
+ */
+export interface EndpointPartition {
+    name: string;
+    dnsSuffix: string;
+    dualStackDnsSuffix: string;
+    supportsFIPS: boolean;
+    supportsDualStack: boolean;
+}
+/**
+ * @public
+ */
+export interface EndpointARN {
+    partition: string;
+    service: string;
+    region: string;
+    accountId: string;
+    resourceId: Array<string>;
+}
+/**
+ * @public
+ */
+export declare enum EndpointURLScheme {
+    HTTP = "http",
+    HTTPS = "https"
+}
+/**
+ * @public
+ */
+export interface EndpointURL {
+    /**
+     * The URL scheme such as http or https.
+     */
+    scheme: EndpointURLScheme;
+    /**
+     * The authority is the host and optional port component of the URL.
+     */
+    authority: string;
+    /**
+     * The parsed path segment of the URL.
+     * This value is as-is as provided by the user.
+     */
+    path: string;
+    /**
+     * The parsed path segment of the URL.
+     * This value is guranteed to start and end with a "/".
+     */
+    normalizedPath: string;
+    /**
+     * A boolean indicating whether the authority is an IP address.
+     */
+    isIp: boolean;
+}
+/**
+ * @public
+ */
+export type EndpointObjectProperty = string | boolean | {
+    [key: string]: EndpointObjectProperty;
+} | EndpointObjectProperty[];
+/**
+ * @public
+ */
+export interface EndpointV2 {
+    url: URL;
+    properties?: {
+        authSchemes?: AuthScheme[];
+    } & Record<string, EndpointObjectProperty>;
+    headers?: Record<string, string[]>;
+}
+/**
+ * @public
+ */
+export type EndpointParameters = {
+    [name: string]: undefined | boolean | string | string[];
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/EndpointRuleObject.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/ErrorRuleObject.d.ts

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

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/RuleSetObject.d.ts

@@ -0,0 +1,28 @@
+import { RuleSetRules } from "./TreeRuleObject";
+/**
+ * @public
+ */
+export type DeprecatedObject = {
+    message?: string;
+    since?: string;
+};
+/**
+ * @public
+ */
+export type ParameterObject = {
+    type: "String" | "string" | "Boolean" | "boolean";
+    default?: string | boolean;
+    required?: boolean;
+    documentation?: string;
+    builtIn?: string;
+    deprecated?: DeprecatedObject;
+};
+/**
+ * @public
+ */
+export type RuleSetObject = {
+    version: string;
+    serviceId?: string;
+    parameters: Record<string, ParameterObject>;
+    rules: RuleSetRules;
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/TreeRuleObject.d.ts

@@ -0,0 +1,16 @@
+import { EndpointRuleObject } from "./EndpointRuleObject";
+import { ErrorRuleObject } from "./ErrorRuleObject";
+import { ConditionObject } from "./shared";
+/**
+ * @public
+ */
+export type RuleSetRules = Array<EndpointRuleObject | ErrorRuleObject | TreeRuleObject>;
+/**
+ * @public
+ */
+export type TreeRuleObject = {
+    type: "tree";
+    conditions?: ConditionObject[];
+    rules: RuleSetRules;
+    documentation?: string;
+};

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./EndpointRuleObject";
+export * from "./ErrorRuleObject";
+export * from "./RuleSetObject";
+export * from "./shared";
+export * from "./TreeRuleObject";

package/node_modules/@amzn/codewhisperer-streaming/node_modules/@smithy/types/dist-types/endpoints/shared.d.ts

@@ -0,0 +1,55 @@
+import { Logger } from "../logger";
+/**
+ * @public
+ */
+export type ReferenceObject = {
+    ref: string;
+};
+/**
+ * @public
+ */
+export type FunctionObject = {
+    fn: string;
+    argv: FunctionArgv;
+};
+/**
+ * @public
+ */
+export type FunctionArgv = Array<Expression | boolean | number>;
+/**
+ * @public
+ */
+export type FunctionReturn = string | boolean | number | {
+    [key: string]: FunctionReturn;
+};
+/**
+ * @public
+ */
+export type ConditionObject = FunctionObject & {
+    assign?: string;
+};
+/**
+ * @public
+ */
+export type Expression = string | ReferenceObject | FunctionObject;
+/**
+ * @public
+ */
+export type EndpointParams = Record<string, string | boolean>;
+/**
+ * @public
+ */
+export type EndpointResolverOptions = {
+    endpointParams: EndpointParams;
+    logger?: Logger;
+};
+/**
+ * @public
+ */
+export type ReferenceRecord = Record<string, FunctionReturn>;
+/**
+ * @public
+ */
+export type EvaluateOptions = EndpointResolverOptions & {
+    referenceRecord: ReferenceRecord;
+};