@sng2c/pi-the-giver 0.1.0 → 0.1.1

package/node_modules/typebox/build/type/action/instance-type.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred InstanceType action. */
+export function InstanceTypeDeferred(type, options = {}) {
+    return Deferred('InstanceType', [type], options);
+}
+/** Applies a InstanceType action to the given type. */
+export function InstanceType(type, options = {}) {
+    return Instantiate({}, InstanceTypeDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/interface.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Interface action. */
+export type TInterfaceDeferred<Heritage extends TSchema[] = TSchema[], Properties extends TProperties = TProperties> = (TDeferred<'Interface', [Heritage, Properties]>);
+/** Creates a deferred Interface action. */
+export declare function InterfaceDeferred<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options?: TSchemaOptions): TInterfaceDeferred<Heritage, Properties>;
+/** Returns true if this value is a deferred Interface action. */
+export declare function IsInterfaceDeferred(value: unknown): value is TInterfaceDeferred;
+/** Creates an Interface using the given heritage and properties. */
+export type TInterface<Heritage extends TSchema[], Properties extends TProperties> = (TInstantiate<{}, TInterfaceDeferred<Heritage, Properties>>);
+/** Creates an Interface using the given heritage and properties. */
+export declare function Interface<Heritage extends TSchema[], Properties extends TProperties>(heritage: [...Heritage], properties: Properties, options?: TSchemaOptions): TInterface<Heritage, Properties>;

package/node_modules/typebox/build/type/action/interface.mjs

@@ -0,0 +1,20 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { IsSchema } from '../types/schema.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Interface action. */
+export function InterfaceDeferred(heritage, properties, options = {}) {
+    return Deferred('Interface', [heritage, properties], options);
+}
+/** Returns true if this value is a deferred Interface action. */
+export function IsInterfaceDeferred(value) {
+    return IsSchema(value)
+        && Guard.HasPropertyKey(value, 'action')
+        && Guard.IsEqual(value.action, 'Interface');
+}
+/** Creates an Interface using the given heritage and properties. */
+export function Interface(heritage, properties, options = {}) {
+    return Instantiate({}, InterfaceDeferred(heritage, properties, options));
+}

package/node_modules/typebox/build/type/action/keyof.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred KeyOf action. */
+export type TKeyOfDeferred<Type extends TSchema> = (TDeferred<'KeyOf', [Type]>);
+/** Creates a deferred KeyOf action. */
+export declare function KeyOfDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOfDeferred<Type>;
+/** Applies a KeyOf action to the given type. */
+export type TKeyOf<Type extends TSchema> = (TInstantiate<{}, TKeyOfDeferred<Type>>);
+/** Applies a KeyOf action to the given type. */
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOf<Type>;

package/node_modules/typebox/build/type/action/keyof.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred KeyOf action. */
+export function KeyOfDeferred(type, options = {}) {
+    return Deferred('KeyOf', [type], options);
+}
+/** Applies a KeyOf action to the given type. */
+export function KeyOf(type, options = {}) {
+    return Instantiate({}, KeyOfDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/lowercase.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Lowercase action. */
+export type TLowercaseDeferred<Type extends TSchema> = (TDeferred<'Lowercase', [Type]>);
+/** Creates a deferred Lowercase action. */
+export declare function LowercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercaseDeferred<Type>;
+/** Applies a Lowercase action to the given type. */
+export type TLowercase<Type extends TSchema> = (TInstantiate<{}, TLowercaseDeferred<Type>>);
+/** Applies a Lowercase action to the given type. */
+export declare function Lowercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercase<Type>;

package/node_modules/typebox/build/type/action/lowercase.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Lowercase action. */
+export function LowercaseDeferred(type, options = {}) {
+    return Deferred('Lowercase', [type], options);
+}
+/** Applies a Lowercase action to the given type. */
+export function Lowercase(type, options = {}) {
+    return Instantiate({}, LowercaseDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/mapped.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TIdentifier } from '../types/identifier.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Mapped action. */
+export type TMappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TDeferred<'Mapped', [Identifier, Type, As, Property]>);
+/** Creates a deferred Mapped action. */
+export declare function MappedDeferred<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMappedDeferred<Identifier, Type, As, Property>;
+/** Applies a Mapped action using the given types. */
+export type TMapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema> = (TInstantiate<{}, TMappedDeferred<Identifier, Type, As, Property>>);
+/** Applies a Mapped action using the given types. */
+export declare function Mapped<Identifier extends TIdentifier, Type extends TSchema, As extends TSchema, Property extends TSchema>(identifier: Identifier, type: Type, as: As, property: Property, options?: TSchemaOptions): TMapped<Identifier, Type, As, Property>;

package/node_modules/typebox/build/type/action/mapped.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Mapped action. */
+export function MappedDeferred(identifier, type, as, property, options = {}) {
+    return Deferred('Mapped', [identifier, type, as, property], options);
+}
+/** Applies a Mapped action using the given types. */
+export function Mapped(identifier, type, as, property, options = {}) {
+    return Instantiate({}, MappedDeferred(identifier, type, as, property, options));
+}

package/node_modules/typebox/build/type/action/module.d.mts

@@ -0,0 +1,12 @@
+import { type TSchemaOptions } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Module action. */
+export type TModuleDeferred<Context extends TProperties> = (TDeferred<'Module', [Context]>);
+/** Creates a deferred Module action. */
+export declare function ModuleDeferred<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModuleDeferred<Context>;
+/** Applies a Module transformation action to the embedded property types. */
+export type TModule<Context extends TProperties> = (TInstantiate<{}, TModuleDeferred<Context>>);
+/** Applies a Module transformation action to the embedded property types. */
+export declare function Module<Context extends TProperties>(context: Context, options?: TSchemaOptions): TModule<Context>;

package/node_modules/typebox/build/type/action/module.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Module action. */
+export function ModuleDeferred(context, options = {}) {
+    return Deferred('Module', [context], options);
+}
+/** Applies a Module transformation action to the embedded property types. */
+export function Module(context, options = {}) {
+    return Instantiate({}, ModuleDeferred(context, options));
+}

package/node_modules/typebox/build/type/action/non-nullable.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred NonNullable action. */
+export type TNonNullableDeferred<Type extends TSchema> = (TDeferred<'NonNullable', [Type]>);
+/** Creates a deferred NonNullable action. */
+export declare function NonNullableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullableDeferred<Type>;
+/** Applies a NonNullable action to the given type. */
+export type TNonNullable<Type extends TSchema> = (TInstantiate<{}, TNonNullableDeferred<Type>>);
+/** Applies a NonNullable action to the given type. */
+export declare function NonNullable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullable<Type>;

package/node_modules/typebox/build/type/action/non-nullable.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred NonNullable action. */
+export function NonNullableDeferred(type, options = {}) {
+    return Deferred('NonNullable', [type], options);
+}
+/** Applies a NonNullable action to the given type. */
+export function NonNullable(type, options = {}) {
+    return Instantiate({}, NonNullableDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/omit.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Omit action. */
+export type TOmitDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Omit', [Type, Indexer]>);
+/** Creates a deferred Omit action. */
+export declare function OmitDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmitDeferred<Type, Indexer>;
+/** Applies a Omit action using the given types. */
+export type TOmit<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TOmitDeferred<Type, Indexer>>);
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TOmit<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Omit action using the given types. */
+export declare function Omit<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TOmit<Type, Indexer>;

package/node_modules/typebox/build/type/action/omit.mjs

@@ -0,0 +1,15 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Omit action. */
+export function OmitDeferred(type, indexer, options = {}) {
+    return Deferred('Omit', [type, indexer], options);
+}
+/** Applies a Omit action using the given types. */
+export function Omit(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return Instantiate({}, OmitDeferred(type, indexer, options));
+}

package/node_modules/typebox/build/type/action/options.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Options action. */
+export type TOptionsDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'Options', [Type, Options]>);
+/** Creates a deferred Options action. */
+export declare function OptionsDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsDeferred<Type, Options>;
+export type TOptionsConstruct<Type extends TSchema, Options extends TSchema> = (TInstantiate<{}, TOptionsDeferred<Type, Options>>);
+/** Applies an Options action to the given type. */
+export type TOptions<Type extends TSchema, Options extends TSchema> = (Type & Options);
+/** Applies an Options action to the given type. */
+export declare function Options<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TOptionsConstruct<Type, Options>;

package/node_modules/typebox/build/type/action/options.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Options action. */
+export function OptionsDeferred(type, options) {
+    return Deferred('Options', [type, options], {});
+}
+/** Applies an Options action to the given type. */
+export function Options(type, options) {
+    return Instantiate({}, OptionsDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/parameters.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Parameters action. */
+export type TParametersDeferred<Type extends TSchema> = (TDeferred<'Parameters', [Type]>);
+/** Creates a deferred Parameters action. */
+export declare function ParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParametersDeferred<Type>;
+/** Applies a Parameters action to the given type. */
+export type TParameters<Type extends TSchema> = (TInstantiate<{}, TParametersDeferred<Type>>);
+/** Applies a Parameters action to the given type. */
+export declare function Parameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParameters<Type>;

package/node_modules/typebox/build/type/action/parameters.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Parameters action. */
+export function ParametersDeferred(type, options = {}) {
+    return Deferred('Parameters', [type], options);
+}
+/** Applies a Parameters action to the given type. */
+export function Parameters(type, options = {}) {
+    return Instantiate({}, ParametersDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/partial.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Partial action. */
+export type TPartialDeferred<Type extends TSchema> = (TDeferred<'Partial', [Type]>);
+/** Creates a deferred Partial action. */
+export declare function PartialDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Partial", [Type]>;
+/** Applies a Partial action to the given type. */
+export type TPartial<Type extends TSchema> = (TInstantiate<{}, TPartialDeferred<Type>>);
+/** Applies a Partial action to the given type. */
+export declare function Partial<Type extends TSchema>(type: Type, options?: TSchemaOptions): TPartial<Type>;

package/node_modules/typebox/build/type/action/partial.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Partial action. */
+export function PartialDeferred(type, options = {}) {
+    return Deferred('Partial', [type], options);
+}
+/** Applies a Partial action to the given type. */
+export function Partial(type, options = {}) {
+    return Instantiate({}, PartialDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/pick.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export type TPickDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Pick', [Type, Indexer]>);
+/** Creates a deferred Pick action. */
+export declare function PickDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPickDeferred<Type, Indexer>;
+/** Applies a Pick action using the given types. */
+export type TPick<Type extends TSchema, Indexer extends TSchema> = (TInstantiate<{}, TPickDeferred<Type, Indexer>>);
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TPick<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Pick action using the given types. */
+export declare function Pick<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TPick<Type, Indexer>;

package/node_modules/typebox/build/type/action/pick.mjs

@@ -0,0 +1,15 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Guard } from '../../guard/index.mjs';
+import { Deferred } from '../types/deferred.mjs';
+import { KeysToIndexer } from '../engine/helpers/keys-to-indexer.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Pick action. */
+export function PickDeferred(type, indexer, options = {}) {
+    return Deferred('Pick', [type, indexer], options);
+}
+/** Applies a Pick action using the given types. */
+export function Pick(type, indexer_or_keys, options = {}) {
+    const indexer = Guard.IsArray(indexer_or_keys) ? KeysToIndexer(indexer_or_keys) : indexer_or_keys;
+    return Instantiate({}, PickDeferred(type, indexer, options));
+}

package/node_modules/typebox/build/type/action/readonly-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export type TReadonlyTypeDeferred<Type extends TSchema> = (TDeferred<'ReadonlyType', [Type]>);
+/** Creates a deferred ReadonlyType action. */
+export declare function ReadonlyTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"ReadonlyType", [Type]>;
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export type TReadonlyType<Type extends TSchema> = (TInstantiate<{}, TReadonlyTypeDeferred<Type>>);
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export declare function ReadonlyType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyType<Type>;

package/node_modules/typebox/build/type/action/readonly-type.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export function ReadonlyTypeDeferred(type, options = {}) {
+    return Deferred('ReadonlyType', [type], options);
+}
+/** This type is an alias for the TypeScript `Readonly<T>` utility type. */
+export function ReadonlyType(type, options = {}) {
+    return Instantiate({}, ReadonlyTypeDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/required.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Required action. */
+export type TRequiredDeferred<Type extends TSchema> = (TDeferred<'Required', [Type]>);
+/** Creates a deferred Required action. */
+export declare function RequiredDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"Required", [Type]>;
+/** Applies a Required action to the given type. */
+export type TRequired<Type extends TSchema> = (TInstantiate<{}, TRequiredDeferred<Type>>);
+/** Applies a Required action to the given type. */
+export declare function Required<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRequired<Type>;

package/node_modules/typebox/build/type/action/required.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Required action. */
+export function RequiredDeferred(type, options = {}) {
+    return Deferred('Required', [type], options);
+}
+/** Applies a Required action to the given type. */
+export function Required(type, options = {}) {
+    return Instantiate({}, RequiredDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/return-type.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReturnType action. */
+export type TReturnTypeDeferred<Type extends TSchema> = (TDeferred<'ReturnType', [Type]>);
+/** Creates a deferred ReturnType action. */
+export declare function ReturnTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnTypeDeferred<Type>;
+/** Applies a ReturnType action to the given type. */
+export type TReturnType<Type extends TSchema> = (TInstantiate<{}, TReturnTypeDeferred<Type>>);
+/** Applies a ReturnType action to the given type. */
+export declare function ReturnType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnType<Type>;

package/node_modules/typebox/build/type/action/return-type.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred ReturnType action. */
+export function ReturnTypeDeferred(type, options = {}) {
+    return Deferred('ReturnType', [type], options);
+}
+/** Applies a ReturnType action to the given type. */
+export function ReturnType(type, options = {}) {
+    return Instantiate({}, ReturnTypeDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/uncapitalize.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uncapitalize action. */
+export type TUncapitalizeDeferred<Type extends TSchema> = (TDeferred<'Uncapitalize', [Type]>);
+/** Creates a deferred Uncapitalize action. */
+export declare function UncapitalizeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalizeDeferred<Type>;
+/** Applies a Uncapitalize action to the given type. */
+export type TUncapitalize<Type extends TSchema> = (TInstantiate<{}, TUncapitalizeDeferred<Type>>);
+/** Applies a Uncapitalize action to the given type. */
+export declare function Uncapitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;

package/node_modules/typebox/build/type/action/uncapitalize.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uncapitalize action. */
+export function UncapitalizeDeferred(type, options = {}) {
+    return Deferred('Uncapitalize', [type], options);
+}
+/** Applies a Uncapitalize action to the given type. */
+export function Uncapitalize(type, options = {}) {
+    return Instantiate({}, UncapitalizeDeferred(type, options));
+}

package/node_modules/typebox/build/type/action/uppercase.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TInstantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uppercase action. */
+export type TUppercaseDeferred<Type extends TSchema> = (TDeferred<'Uppercase', [Type]>);
+/** Creates a deferred Uppercase action. */
+export declare function UppercaseDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercaseDeferred<Type>;
+/** Applies a Uppercase action to the given type. */
+export type TUppercase<Type extends TSchema> = (TInstantiate<{}, TUppercaseDeferred<Type>>);
+/** Applies a Uppercase action to the given type. */
+export declare function Uppercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercase<Type>;

package/node_modules/typebox/build/type/action/uppercase.mjs

@@ -0,0 +1,12 @@
+// deno-lint-ignore-file ban-types
+// deno-fmt-ignore-file
+import { Deferred } from '../types/deferred.mjs';
+import { Instantiate } from '../engine/instantiate.mjs';
+/** Creates a deferred Uppercase action. */
+export function UppercaseDeferred(type, options = {}) {
+    return Deferred('Uppercase', [type], options);
+}
+/** Applies a Uppercase action to the given type. */
+export function Uppercase(type, options = {}) {
+    return Instantiate({}, UppercaseDeferred(type, options));
+}

package/node_modules/typebox/build/type/engine/awaited/index.d.mts

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/typebox/build/type/engine/awaited/index.mjs

@@ -0,0 +1 @@
+export * from './instantiate.mjs';

package/node_modules/typebox/build/type/engine/awaited/instantiate.d.mts

@@ -0,0 +1,10 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TPromise } from '../../types/promise.mjs';
+import { type TAwaitedDeferred } from '../../action/awaited.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+type TAwaitedAction<Type extends TSchema> = (Type extends TPromise<infer Type extends TSchema> ? TAwaitedAction<Type> : Type);
+type TAwaitedImmediate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiateType extends TSchema = TInstantiateType<Context, State, Type>> = TAwaitedAction<InstantiateType>;
+export type TAwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema> = TCanInstantiate<Context, [Type]> extends true ? TAwaitedImmediate<Context, State, Type> : TAwaitedDeferred<Type>;
+export declare function AwaitedInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TAwaitedInstantiate<Context, State, Type>;
+export {};

package/node_modules/typebox/build/type/engine/awaited/instantiate.mjs

@@ -0,0 +1,19 @@
+// deno-fmt-ignore-file
+import { Memory } from '../../../system/memory/index.mjs';
+import { IsPromise } from '../../types/promise.mjs';
+import { AwaitedDeferred } from '../../action/awaited.mjs';
+import { InstantiateType, CanInstantiate } from '../instantiate.mjs';
+function AwaitedAction(type) {
+    return (IsPromise(type)
+        ? AwaitedAction(type.item)
+        : type);
+}
+function AwaitedImmediate(context, state, type, options) {
+    const instantiatedType = InstantiateType(context, state, type);
+    return Memory.Update(AwaitedAction(instantiatedType), {}, options);
+}
+export function AwaitedInstantiate(context, state, type, options) {
+    return (CanInstantiate(context, [type])
+        ? AwaitedImmediate(context, state, type, options)
+        : AwaitedDeferred(type, options));
+}

package/node_modules/typebox/build/type/engine/call/distribute-arguments.d.mts

@@ -0,0 +1,15 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TDeferred } from '../../types/deferred.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+type TCollectDistributionNames<Expression extends TSchema, Result extends string[] = []> = (Expression extends TDeferred<'Conditional', [infer Left extends TSchema, infer _Right extends TSchema, infer True extends TSchema, infer False extends TSchema]> ? Left extends TRef ? TCollectDistributionNames<True, TCollectDistributionNames<False, [...Result, Left['$ref']]>> : TCollectDistributionNames<True, TCollectDistributionNames<False, Result>> : Expression extends TDeferred<'Mapped', [infer _Identifier extends TSchema, infer Type extends TSchema, infer _As extends TSchema, infer _Property extends TSchema]> ? (Type extends TDeferred<'KeyOf', [infer Ref extends TRef]> ? [...Result, Ref['$ref']] : Result) : Result);
+type TBuildDistributionArray<Parameters extends TParameter[], Names extends string[], Result extends boolean[] = []> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? Left['name'] extends Names[number] ? TBuildDistributionArray<Right, Names, [...Result, true]> : TBuildDistributionArray<Right, Names, [...Result, false]> : Result);
+type TZipDistributionArray<Arguments extends TSchema[], DistributionArray extends boolean[], Result extends [boolean, TSchema][] = []> = (Arguments extends [infer ArgumentLeft extends TSchema, ...infer ArgumentRight extends TSchema[]] ? DistributionArray extends [infer BooleanLeft extends boolean, ...infer BooleanRight extends boolean[]] ? TZipDistributionArray<ArgumentRight, BooleanRight, [...Result, [BooleanLeft, ArgumentLeft]]> : Result : Result);
+type TExpand<Type extends TSchema> = (Type extends TUnion<infer Types extends TSchema[]> ? [...Types] : [Type]);
+type TAppend<Current extends TSchema[][], Type extends TSchema, Result extends TSchema[][] = []> = (Current extends [infer Left extends TSchema[], ...infer Right extends TSchema[][]] ? TAppend<Right, Type, [...Result, [...Left, Type]]> : Result);
+type TCross<Current extends TSchema[][], Variants extends TSchema[], Result extends TSchema[][] = []> = (Variants extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TCross<Current, Right, [...Result, ...TAppend<Current, Left>]> : Result);
+type TDistribute<ZippedArguments extends [boolean, TSchema][], Result extends TSchema[][] = [[]]> = (ZippedArguments extends [infer Left extends [boolean, TSchema], ...infer Right extends [boolean, TSchema][]] ? Left[0] extends true ? TDistribute<Right, TCross<Result, TExpand<Left[1]>>> : TDistribute<Right, TCross<Result, [Left[1]]>> : Result);
+export type TDistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema, DistributionNames extends string[] = TCollectDistributionNames<Expression>, DistributionArray extends boolean[] = TBuildDistributionArray<Parameters, DistributionNames>, ZippedArguments extends [boolean, TSchema][] = TZipDistributionArray<Arguments, DistributionArray>, Result extends TSchema[][] = (Expression extends TDeferred<'Conditional', TSchema[]> ? TDistribute<ZippedArguments> : Expression extends TDeferred<'Mapped', TSchema[]> ? TDistribute<ZippedArguments> : [Arguments])> = Result;
+export declare function DistributeArguments<Parameters extends TParameter[], Arguments extends TSchema[], Expression extends TSchema>(parameters: [...Parameters], arguments_: [...Arguments], expression: Expression): TDistributeArguments<Parameters, Arguments, Expression>;
+export {};

package/node_modules/typebox/build/type/engine/call/distribute-arguments.mjs

@@ -0,0 +1,59 @@
+// deno-fmt-ignore-file
+import { Guard } from '../../../guard/index.mjs';
+import { IsUnion } from '../../types/union.mjs';
+import { IsDeferred } from '../../types/deferred.mjs';
+import { IsRef } from '../../types/ref.mjs';
+function CollectDistributionNames(expression, result = []) {
+    return (
+    // Conditional
+    IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? IsRef(expression.parameters[0])
+            ? CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], [...result, expression.parameters[0]['$ref']]))
+            : CollectDistributionNames(expression.parameters[2], CollectDistributionNames(expression.parameters[3], result))
+        // Mapped
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? (IsDeferred(expression.parameters[1]) && Guard.IsEqual(expression.parameters[1].action, 'KeyOf') && IsRef(expression.parameters[1].parameters[0]) ? [...result, expression.parameters[1].parameters[0]['$ref']] :
+                result) : result);
+}
+function BuildDistributionArray(parameters, names) {
+    return parameters.reduce((result, left) => [...result, names.includes(left.name)], []);
+}
+function ZipDistributionArray(arguments_, distributionArray, result = []) {
+    const [argumentLeft, ...argumentRight] = arguments_;
+    const [booleanLeft, ...booleanRight] = distributionArray;
+    return (Guard.IsGreaterThan(arguments_.length, 0)
+        ? Guard.IsGreaterThan(distributionArray.length, 0)
+            ? ZipDistributionArray(argumentRight, booleanRight, [...result, [booleanLeft, argumentLeft]])
+            : result
+        : result);
+}
+function Expand(type) {
+    return (IsUnion(type)
+        ? [...type.anyOf]
+        : [type]);
+}
+function Append(current, type) {
+    return current.reduce((result, left) => [...result, [...left, type]], []);
+}
+function Cross(current, variants) {
+    return variants.reduce((result, left) => {
+        return [...result, ...Append(current, left)];
+    }, []);
+}
+function Distribute(zipped) {
+    return zipped.reduce((result, left) => {
+        return Guard.IsEqual(left[0], true)
+            ? Cross(result, Expand(left[1]))
+            : Cross(result, [left[1]]); // - no-expansion
+    }, [[]]);
+}
+export function DistributeArguments(parameters, arguments_, expression) {
+    const distributionNames = CollectDistributionNames(expression);
+    const distributionArray = BuildDistributionArray(parameters, distributionNames);
+    const zippedArguments = ZipDistributionArray(arguments_, distributionArray);
+    return (IsDeferred(expression) && Guard.IsEqual(expression.action, 'Conditional')
+        ? Distribute(zippedArguments)
+        : IsDeferred(expression) && Guard.IsEqual(expression.action, 'Mapped')
+            ? Distribute(zippedArguments)
+            : [arguments_]);
+}