@aws/lsp-codewhisperer 0.0.57 → 0.0.59

package/node_modules/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/retry.d.ts

@@ -0,0 +1,133 @@
+import { SdkError } from "./shapes";
+/**
+ * @public
+ */
+export 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
+ */
+export 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
+ */
+export interface RetryBackoffStrategy {
+    /**
+     * @returns the number of milliseconds to wait before retrying an action.
+     */
+    computeNextBackoffDelay(retryAttempt: number): number;
+}
+/**
+ * @public
+ */
+export interface StandardRetryBackoffStrategy extends RetryBackoffStrategy {
+    /**
+     * Sets the delayBase used to compute backoff delays.
+     * @param delayBase -
+     */
+    setDelayBase(delayBase: number): void;
+}
+/**
+ * @public
+ */
+export interface RetryStrategyOptions {
+    backoffStrategy: RetryBackoffStrategy;
+    maxRetriesBase: number;
+}
+/**
+ * @public
+ */
+export interface RetryToken {
+    /**
+     * @returns the current count of retry.
+     */
+    getRetryCount(): number;
+    /**
+     * @returns the number of milliseconds to wait before retrying an action.
+     */
+    getRetryDelay(): number;
+}
+/**
+ * @public
+ */
+export interface StandardRetryToken extends RetryToken {
+    /**
+     * @returns the cost of the last retry attempt.
+     */
+    getRetryCost(): number | undefined;
+}
+/**
+ * @public
+ */
+export 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.
+     */
+    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;
+}
+/**
+ * @public
+ */
+export type ExponentialBackoffJitterType = "DEFAULT" | "NONE" | "FULL" | "DECORRELATED";
+/**
+ * @public
+ */
+export interface ExponentialBackoffStrategyOptions {
+    jitterType: ExponentialBackoffJitterType;
+    backoffScaleValue?: number;
+}

package/node_modules/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/schema/schema.d.ts

@@ -0,0 +1,261 @@
+import type { EndpointV2 } from "../endpoint";
+import type { HandlerExecutionContext } from "../middleware";
+import type { MetadataBearer } from "../response";
+import type { EndpointBearer, SerdeFunctions } from "../serde";
+import type { BigDecimalSchema, BigIntegerSchema, BlobSchema, BooleanSchema, DocumentSchema, NumericSchema, StreamingBlobSchema, StringSchema, TimestampDateTimeSchema, TimestampDefaultSchema, TimestampEpochSecondsSchema, TimestampHttpDateSchema } from "./sentinels";
+import type { TraitBitVector } from "./traits";
+/**
+ * A schema is an object or value that describes how to serialize/deserialize data.
+ * @public
+ */
+export type Schema = UnitSchema | TraitsSchema | SimpleSchema | ListSchema | MapSchema | StructureSchema | MemberSchema | OperationSchema | NormalizedSchema;
+/**
+ * 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
+ */
+export type SchemaTraits = TraitBitVector | SchemaTraitsObject;
+/**
+ * A schema that has traits.
+ *
+ * @public
+ */
+export interface TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+}
+/**
+ * Simple schemas are those corresponding to simple Smithy types.
+ * @see https://smithy.io/2.0/spec/simple-types.html
+ * @public
+ */
+export 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
+ */
+export type TimestampSchemas = TimestampDefaultSchema | TimestampDateTimeSchema | TimestampHttpDateSchema | TimestampEpochSecondsSchema;
+/**
+ * Sentinel values for Blob schema.
+ * @public
+ */
+export type BlobSchemas = BlobSchema | StreamingBlobSchema;
+/**
+ * Signal value for the Smithy void value. Typically used for
+ * operation input and outputs.
+ *
+ * @internal
+ */
+export type UnitSchema = "unit";
+/**
+ * See https://smithy.io/2.0/trait-index.html for individual definitions.
+ *
+ * @public
+ */
+export 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";
+    [traitName: string]: unknown;
+};
+/**
+ * Schema for the structure aggregate type.
+ * @public
+ */
+export interface StructureSchema extends TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+    members: Record<string, [SchemaRef, SchemaTraits]>;
+}
+/**
+ * Schema for the list aggregate type.
+ * @public
+ */
+export interface ListSchema extends TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+    valueSchema: SchemaRef;
+}
+/**
+ * Schema for the map aggregate type.
+ * @public
+ */
+export interface MapSchema extends TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+    keySchema: SchemaRef;
+    valueSchema: SchemaRef;
+}
+/**
+ * @public
+ */
+export type MemberSchema = [SchemaRef, SchemaTraits];
+/**
+ * Schema for an operation.
+ *
+ * @public
+ */
+export interface OperationSchema extends TraitsSchema {
+    name: string;
+    traits: SchemaTraits;
+    input: SchemaRef;
+    output: SchemaRef;
+}
+/**
+ * Normalization wrapper for various schema data objects.
+ * @public
+ */
+export interface NormalizedSchema {
+    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;
+    /**
+     * For struct/union.
+     */
+    getMemberSchema(member: string): NormalizedSchema | undefined;
+    getMemberSchemas(): Record<string, NormalizedSchema>;
+}
+/**
+ * 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
+ */
+export type SchemaRef = Schema | (() => Schema);
+/**
+ * A codec creates serializers and deserializers for some format such as JSON, XML, or CBOR.
+ *
+ * @public
+ */
+export 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
+ */
+export 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
+ */
+export interface ShapeDeserializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    /**
+     * Optionally async.
+     */
+    read(schema: Schema, data: SerializationType): any | Promise<any>;
+}
+/**
+ * Turns a data object into a serialization.
+ * @public
+ */
+export interface ShapeSerializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    write(schema: Schema, value: unknown): void;
+    flush(): SerializationType;
+}
+/**
+ * A client protocol defines how to convert a message (e.g. HTTP request/response) to and from a data object.
+ * @public
+ */
+export 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>;
+}
+/**
+ * Allows a protocol, codec, or serde utility to accept the serdeContext
+ * from a client configuration or request/response handlerExecutionContext.
+ *
+ * @public
+ */
+export interface ConfigurableSerdeContext {
+    setSerdeContext(serdeContext: SerdeFunctions): void;
+}

package/node_modules/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/schema/sentinels.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The blob Smithy type, in JS as Uint8Array and other representations
+ * such as Buffer, string, or Readable(Stream) depending on circumstances.
+ * @public
+ */
+export type BlobSchema = 21;
+/**
+ * @public
+ */
+export type StreamingBlobSchema = 42;
+/**
+ * @public
+ */
+export type BooleanSchema = 2;
+/**
+ * Includes string and enum Smithy types.
+ * @public
+ */
+export type StringSchema = 0;
+/**
+ * Includes all numeric Smithy types except bigInteger and bigDecimal.
+ * byte, short, integer, long, float, double, intEnum.
+ *
+ * @public
+ */
+export type NumericSchema = 1;
+/**
+ * @public
+ */
+export type BigIntegerSchema = 17;
+/**
+ * @public
+ */
+export type BigDecimalSchema = 19;
+/**
+ * @public
+ */
+export type DocumentSchema = 15;
+/**
+ * Smithy type timestamp, in JS as native Date object.
+ * @public
+ */
+export type TimestampDefaultSchema = 4;
+/**
+ * @public
+ */
+export type TimestampDateTimeSchema = 5;
+/**
+ * @public
+ */
+export type TimestampHttpDateSchema = 6;
+/**
+ * @public
+ */
+export type TimestampEpochSecondsSchema = 7;
+/**
+ * Additional bit indicating the type is a list.
+ * @public
+ */
+export type ListSchemaModifier = 64;
+/**
+ * Additional bit indicating the type is a map.
+ * @public
+ */
+export type MapSchemaModifier = 128;

package/node_modules/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/schema/traits.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 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
+ */
+export type TraitBitVector = HttpLabelBitMask | IdempotentBitMask | IdempotencyTokenBitMask | SensitiveBitMask | HttpPayloadBitMask | HttpResponseCodeBitMask | HttpQueryParamsBitMask | number;
+/**
+ * @public
+ */
+export type HttpLabelBitMask = 1;
+/**
+ * @public
+ */
+export type IdempotentBitMask = 2;
+/**
+ * @public
+ */
+export type IdempotencyTokenBitMask = 4;
+/**
+ * @public
+ */
+export type SensitiveBitMask = 8;
+/**
+ * @public
+ */
+export type HttpPayloadBitMask = 16;
+/**
+ * @public
+ */
+export type HttpResponseCodeBitMask = 32;
+/**
+ * @public
+ */
+export type HttpQueryParamsBitMask = 64;

package/node_modules/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/serde.d.ts

@@ -0,0 +1,114 @@
+import { Endpoint } from "./http";
+import { ClientProtocol } from "./schema/schema";
+import { RequestHandler } from "./transfer";
+import { Decoder, Encoder, Provider } from "./util";
+/**
+ * @public
+ *
+ * Interface for object requires an Endpoint set.
+ */
+export interface EndpointBearer {
+    endpoint: Provider<Endpoint>;
+}
+/**
+ * @public
+ */
+export interface StreamCollector {
+    /**
+     * A function that converts a stream into an array of bytes.
+     *
+     * @param stream - The low-level native stream from browser or Nodejs runtime
+     */
+    (stream: any): Promise<Uint8Array>;
+}
+/**
+ * @public
+ *
+ * Request and Response serde util functions and settings for AWS services
+ */
+export interface SerdeContext extends SerdeFunctions, EndpointBearer {
+    requestHandler: RequestHandler<any, any>;
+    disableHostPrefix: boolean;
+    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/@amzn/amazon-q-developer-streaming-client/node_modules/@smithy/types/dist-types/shapes.d.ts

@@ -0,0 +1,82 @@
+import { HttpResponse } from "./http";
+import { 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;
+};