@entelligentsia/forgecli 0.7.9 → 0.8.4

package/node_modules/@smithy/types/dist-types/shapes.d.ts

@@ -1,23 +1,22 @@
 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.
+ *
+ * @public
  */
 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
+ *
+ * @public
  */
 export interface RetryableTrait {
     /**
@@ -26,10 +25,10 @@ export interface RetryableTrait {
     readonly throttling?: boolean;
 }
 /**
- * @public
- *
  * Type that is implemented by all Smithy shapes marked with the
  * error trait.
+ *
+ * @public
  * @deprecated
  */
 export interface SmithyException {
@@ -55,19 +54,17 @@ export interface SmithyException {
     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.
+ *
+ * @public
+ * @deprecated See {@link https://aws.amazon.com/blogs/developer/service-error-handling-modular-aws-sdk-js/}
  */
 export type SdkError = Error & Partial<SmithyException> & Partial<MetadataBearer> & {
     $metadata?: Partial<MetadataBearer>["$metadata"] & {

package/node_modules/@smithy/types/dist-types/signature.d.ts

@@ -2,10 +2,10 @@ import type { Message } from "./eventStream";
 import type { HttpRequest } from "./http";
 import type { AwsCredentialIdentity } from "./identity/awsCredentialIdentity";
 /**
- * @public
- *
  * A `Date` object, a unix (epoch) timestamp in seconds, or a string that can be
  * understood by the JavaScript `Date` constructor.
+ *
+ * @public
  */
 export type DateInput = number | string | Date;
 /**
@@ -112,10 +112,10 @@ export interface RequestPresigner {
     presign(requestToSign: HttpRequest, options?: RequestPresigningArguments): Promise<HttpRequest>;
 }
 /**
- * @public
- *
  * An object that signs request objects with AWS credentials using one of the
  * AWS authentication protocols.
+ *
+ * @public
  */
 export interface RequestSigner {
     /**

package/node_modules/@smithy/types/dist-types/stream.d.ts

@@ -12,10 +12,10 @@ export interface GetAwsChunkedEncodingStreamOptions {
     streamHasher?: StreamHasher;
 }
 /**
- * @public
- *
  * A function that returns Readable Stream which follows aws-chunked encoding stream.
  * It optionally adds checksum if options are provided.
+ *
+ * @public
  */
 export interface GetAwsChunkedEncodingStream<StreamType = any> {
     (readableStream: StreamType, options: GetAwsChunkedEncodingStreamOptions): StreamType;

package/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-common-types.d.ts

@@ -1,32 +1,28 @@
-import type { Readable } from "stream";
+import type { Readable } from "node: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).
  *
+ * @public
+ * @see https://smithy.io/2.0/spec/simple-types.html#blob
  * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
  */
 export type StreamingBlobTypes = NodeJsRuntimeStreamingBlobTypes | BrowserRuntimeStreamingBlobTypes;
 /**
- * @public
- *
  * Node.js streaming blob type.
+ *
+ * @public
  */
 export type NodeJsRuntimeStreamingBlobTypes = Readable;
 /**
- * @public
- *
  * Browser streaming blob types.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobTypes = ReadableStreamOptionalType | BlobOptionalType;

package/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-input-types.d.ts

@@ -1,60 +1,54 @@
-import type { Readable } from "stream";
+import type { Readable } from "node: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.
+ * 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.
- *
+ * 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.
+ * 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.
+ *
+ * @public
  */
 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.
+ *
+ * @public
  */
 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.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobPayloadInputTypes = string | Uint8Array | ReadableStreamOptionalType | BlobOptionalType;

package/node_modules/@smithy/types/dist-types/streaming-payload/streaming-blob-payload-output-types.d.ts

@@ -1,51 +1,41 @@
-import type { IncomingMessage } from "http";
-import type { Readable } from "stream";
+import type { IncomingMessage } from "node:http";
+import type { Readable } from "node: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.
+ *
+ * @public
+ * @see StreamingPayloadInputTypes for FAQ about mixing types from multiple environments.
  */
 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.
+ *
+ * @public
  */
 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.
+ *
+ * @public
  */
 export type BrowserRuntimeStreamingBlobPayloadOutputTypes = SdkStream<ReadableStreamOptionalType | BlobOptionalType>;

package/node_modules/@smithy/types/dist-types/transfer.d.ts

@@ -24,8 +24,9 @@ export interface RequestHandlerMetadata {
     handlerProtocol: RequestHandlerProtocol | string;
 }
 /**
- * @public
  * Values from ALPN Protocol IDs.
+ *
+ * @public
  * @see https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids
  */
 export declare enum RequestHandlerProtocol {

package/node_modules/@smithy/types/dist-types/transform/client-method-transforms.d.ts

@@ -3,9 +3,9 @@ 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.
+ *
+ * @internal
  */
 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>>;
@@ -14,9 +14,9 @@ export interface NarrowedInvokeFunction<NarrowType, HttpHandlerOptions, InputTyp
     <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.
+ *
+ * @internal
  */
 export interface NarrowedInvokeMethod<NarrowType, HttpHandlerOptions, InputType extends object, OutputType extends MetadataBearer> {
     (input: InputType, options?: HttpHandlerOptions): Promise<Transform<OutputType, StreamingBlobPayloadOutputTypes | undefined, NarrowType>>;

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

@@ -1,5 +1,5 @@
-import type { IncomingMessage } from "http";
-import type { ClientHttp2Stream } from "http2";
+import type { ClientHttp2Stream } from "node:http2";
+import type { IncomingMessage } from "node:http";
 import type { InvokeMethod } from "../client";
 import type { GetOutputType } from "../command";
 import type { HttpHandlerOptions } from "../http";
@@ -9,52 +9,48 @@ import type { StreamingBlobPayloadOutputTypes } from "../streaming-payload/strea
 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>;
  * ```
+ *
+ * @public
  */
 export type NodeJsClient<ClientType extends object> = NarrowPayloadBlobTypes<NodeJsRuntimeStreamingBlobPayloadInputTypes, SdkStream<IncomingMessage>, ClientType>;
 /**
- * @public
  * Variant of NodeJsClient for node:http2.
+ *
+ * @public
  */
 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>;
  * ```
+ *
+ * @public
  */
 export type BrowserClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream>, ClientType>;
 /**
- * @public
- *
  * Variant of BrowserClient for XMLHttpRequest.
+ *
+ * @public
  */
 export type BrowserXhrClient<ClientType extends object> = NarrowPayloadBlobTypes<BrowserRuntimeStreamingBlobPayloadInputTypes, SdkStream<ReadableStream | Blob>, ClientType>;
 /**
- * @public
+ * Narrow a given Client's blob payload outputs to the given type T.
  *
+ * @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 [
@@ -64,9 +60,9 @@ export type NarrowPayloadBlobOutputType<T, ClientType extends object> = {
     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.
+ *
+ * @public
  */
 export type NarrowPayloadBlobTypes<I, O, ClientType extends object> = {
     [key in keyof ClientType]: [ClientType[key]] extends [

package/node_modules/@smithy/types/dist-types/transform/exact.d.ts

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

package/node_modules/@smithy/types/dist-types/transform/no-undefined.d.ts

@@ -2,8 +2,6 @@ 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.
@@ -16,35 +14,37 @@ import type { DocumentType } from "../shapes";
  * ```ts
  * const client = new Client({}) as AssertiveClient<Client>;
  * ```
+ *
+ * @public
  */
 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.
+ *
+ * @public
  */
 export type UncheckedClient<Client extends object> = UncheckedClientOutputTypes<Client>;
 /**
- * @internal
- *
  * Excludes undefined recursively.
+ *
+ * @internal
  */
 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.
+ *
+ * @internal
  */
 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.
+ *
+ * @internal
  */
 type NarrowClientIOTypes<ClientType extends object> = {
     [key in keyof ClientType]: [ClientType[key]] extends [
@@ -54,9 +54,9 @@ type NarrowClientIOTypes<ClientType extends object> = {
     send<Command>(command: Command, options?: any): Promise<NoUndefined<GetOutputType<Command>>>;
 };
 /**
- * @internal
- *
  * Removes undefined from unions and adds yolo output types.
+ *
+ * @internal
  */
 type UncheckedClientOutputTypes<ClientType extends object> = {
     [key in keyof ClientType]: [ClientType[key]] extends [

package/node_modules/@smithy/types/dist-types/transform/type-transform.d.ts

@@ -1,32 +1,37 @@
 /**
- * @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.
+ *
+ * @public
  */
 export type Transform<T, FromType, ToType> = ConditionalRecursiveTransformExact<T, FromType, ToType>;
 /**
- * @internal
- *
  * Returns ToType if T matches exactly with FromType.
+ *
+ * @internal
  */
 type TransformExact<T, FromType, ToType> = [T] extends [FromType] ? ([FromType] extends [T] ? ToType : T) : T;
 /**
- * @internal
+ * Types excluded from recursive transformation to avoid circular references.
  *
+ * @internal
+ */
+type ExcludedTransformTypes = SharedArrayBuffer;
+/**
  * Applies TransformExact to members of an object recursively.
+ *
+ * @internal
  */
-type RecursiveTransformExact<T, FromType, ToType> = T extends Function ? T : T extends object ? {
+type RecursiveTransformExact<T, FromType, ToType> = T extends Function ? T : T extends ExcludedTransformTypes ? 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.
+ *
+ * @internal
  */
 type ConditionalRecursiveTransformExact<T, FromType, ToType> = [T] extends [
     RecursiveTransformExact<T, FromType, ToType>

package/node_modules/@smithy/types/dist-types/uri.d.ts

@@ -1,9 +1,9 @@
 import type { QueryParameterBag } from "./http";
 /**
- * @internal
- *
  * Represents the components parts of a Uniform Resource Identifier used to
  * construct the target location of a Request.
+ *
+ * @internal
  */
 export type URI = {
     protocol: string;