@yaag/cli 0.1.0

package/assets/types/typebox/build/type/action/_remove_immutable.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveImmutableAction } from '../engine/immutable/instantiate_remove.mjs';
+/** Creates a deferred RemoveImmutable action. */
+export type TRemoveImmutableDeferred<Type extends TSchema> = (TDeferred<'RemoveImmutable', [Type]>);
+/** Creates a deferred RemoveImmutable action. */
+export declare function RemoveImmutableDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutableDeferred<Type>;
+/** Applies an RemoveImmutable action to a type. */
+export type TRemoveImmutable<Type extends TSchema> = (TRemoveImmutableAction<Type>);
+/** Applies an RemoveImmutable action to a type. */
+export declare function RemoveImmutable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveImmutable<Type>;

package/assets/types/typebox/build/type/action/_remove_optional.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveOptionalAction } from '../engine/optional/instantiate_remove.mjs';
+/** Creates a deferred RemoveOptional action. */
+export type TRemoveOptionalDeferred<Type extends TSchema> = (TDeferred<'RemoveOptional', [Type]>);
+/** Creates a deferred RemoveOptional action. */
+export declare function RemoveOptionalDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptionalDeferred<Type>;
+/** Applies an RemoveOptional action to a type. */
+export type TRemoveOptional<Type extends TSchema> = (TRemoveOptionalAction<Type>);
+/** Applies an RemoveOptional action to a type. */
+export declare function RemoveOptional<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveOptional<Type>;

package/assets/types/typebox/build/type/action/_remove_readonly.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TRemoveReadonlyAction } from '../engine/readonly/instantiate_remove.mjs';
+/** Creates a deferred RemoveReadonly action. */
+export type TRemoveReadonlyDeferred<Type extends TSchema> = (TDeferred<'RemoveReadonly', [Type]>);
+/** Creates a deferred RemoveReadonly action. */
+export declare function RemoveReadonlyDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonlyDeferred<Type>;
+/** Applies an RemoveReadonly action to a type. */
+export type TRemoveReadonly<Type extends TSchema> = (TRemoveReadonlyAction<Type>);
+/** Applies an RemoveReadonly action to a type. */
+export declare function RemoveReadonly<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRemoveReadonly<Type>;

package/assets/types/typebox/build/type/action/capitalize.d.mts

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

package/assets/types/typebox/build/type/action/conditional.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TConditionalAction } from '../engine/conditional/instantiate.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+/** Creates a deferred Conditional action. */
+export type TConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TDeferred<'Conditional', [Left, Right, True, False]>);
+/** Creates a deferred Conditional action. */
+export declare function ConditionalDeferred<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditionalDeferred<Left, Right, True, False>;
+/** Applies a Conditional action to the given types. */
+export type TConditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema> = (TConditionalAction<{}, TState<[], []>, Left, Right, True, False>);
+/** Applies a Conditional action to the given types. */
+export declare function Conditional<Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(left: Left, right: Right, true_: True, false_: False, options?: TSchemaOptions): TConditional<Left, Right, True, False>;

package/assets/types/typebox/build/type/action/constructor_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 TConstructorParametersAction } from '../engine/constructor_parameters/instantiate.mjs';
+/** Creates a deferred ConstructorParameters action. */
+export type TConstructorParametersDeferred<Type extends TSchema> = (TDeferred<'ConstructorParameters', [Type]>);
+/** Creates a deferred ConstructorParameters action. */
+export declare function ConstructorParametersDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParametersDeferred<Type>;
+/** Applies a ConstructorParameters action to a type. */
+export type TConstructorParameters<Type extends TSchema> = (TConstructorParametersAction<Type>);
+/** Applies a ConstructorParameters action to a type. */
+export declare function ConstructorParameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TConstructorParameters<Type>;

package/assets/types/typebox/build/type/action/evaluate.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TEvaluateAction } from '../engine/evaluate/instantiate.mjs';
+/** Creates a deferred Evaluate action. */
+export type TEvaluateDeferred<Type extends TSchema> = (TDeferred<'Evaluate', [Type]>);
+/** Creates a deferred Evaluate action. */
+export declare function EvaluateDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluateDeferred<Type>;
+/** Applies an Evaluate action to a type. */
+export type TEvaluate<Type extends TSchema> = (TEvaluateAction<Type>);
+/** Applies an Evaluate action to a type. */
+export declare function Evaluate<Type extends TSchema>(type: Type, options?: TSchemaOptions): TEvaluate<Type>;

package/assets/types/typebox/build/type/action/exclude.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TExcludeAction } from '../engine/exclude/instantiate.mjs';
+/** Creates a deferred Exclude action. */
+export type TExcludeDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Exclude', [Left, Right]>);
+/** Creates a deferred Exclude action. */
+export declare function ExcludeDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExcludeDeferred<Left, Right>;
+/** Applies a Exclude action using the given types */
+export type TExclude<Left extends TSchema, Right extends TSchema> = (TExcludeAction<Left, Right>);
+/** Applies a Exclude action using the given types */
+export declare function Exclude<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExclude<Left, Right>;

package/assets/types/typebox/build/type/action/extract.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TExtractAction } from '../engine/extract/instantiate.mjs';
+/** Creates a deferred Extract action. */
+export type TExtractDeferred<Left extends TSchema, Right extends TSchema> = (TDeferred<'Extract', [Left, Right]>);
+/** Creates a deferred Extract action. */
+export declare function ExtractDeferred<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtractDeferred<Left, Right>;
+/** Applies an Extract action using the given types. */
+export type TExtract<Left extends TSchema, Right extends TSchema> = (TExtractAction<Left, Right>);
+/** Applies an Extract action using the given types. */
+export declare function Extract<Left extends TSchema, Right extends TSchema>(left: Left, right: Right, options?: TSchemaOptions): TExtract<Left, Right>;

package/assets/types/typebox/build/type/action/index.d.mts

@@ -0,0 +1,30 @@
+export * from './_add_immutable.mjs';
+export * from './_add_readonly.mjs';
+export * from './_add_optional.mjs';
+export * from './_remove_immutable.mjs';
+export * from './_remove_readonly.mjs';
+export * from './_remove_optional.mjs';
+export * from './capitalize.mjs';
+export * from './conditional.mjs';
+export * from './constructor_parameters.mjs';
+export * from './evaluate.mjs';
+export * from './exclude.mjs';
+export * from './extract.mjs';
+export * from './indexed.mjs';
+export * from './instance_type.mjs';
+export * from './interface.mjs';
+export * from './keyof.mjs';
+export * from './lowercase.mjs';
+export * from './mapped.mjs';
+export * from './module.mjs';
+export * from './non_nullable.mjs';
+export * from './omit.mjs';
+export * from './parameters.mjs';
+export * from './partial.mjs';
+export * from './pick.mjs';
+export * from './readonly_object.mjs';
+export * from './required.mjs';
+export * from './return_type.mjs';
+export * from './uncapitalize.mjs';
+export * from './uppercase.mjs';
+export * from './with.mjs';

package/assets/types/typebox/build/type/action/indexed.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 TIndexAction } from '../engine/indexed/instantiate.mjs';
+/** Creates a deferred Index action. */
+export type TIndexDeferred<Type extends TSchema, Indexer extends TSchema> = (TDeferred<'Index', [Type, Indexer]>);
+/** Creates a deferred Index action. */
+export declare function IndexDeferred<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndexDeferred<Type, Indexer>;
+/** Applies a Index action using the given types. */
+export type TIndex<Type extends TSchema, Indexer extends TSchema> = (TIndexAction<Type, Indexer>);
+/** Applies a Index action using the given types. */
+export declare function Index<Type extends TSchema, Indexer extends PropertyKey[]>(type: Type, indexer: readonly [...Indexer], options?: TSchemaOptions): TIndex<Type, TKeysToIndexer<Indexer>>;
+/** Applies a Index action using the given types. */
+export declare function Index<Type extends TSchema, Indexer extends TSchema>(type: Type, indexer: Indexer, options?: TSchemaOptions): TIndex<Type, Indexer>;

package/assets/types/typebox/build/type/action/instance_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 TInstanceTypeAction } from '../engine/instance_type/instantiate.mjs';
+/** Creates a deferred InstanceType action. */
+export type TInstanceTypeDeferred<Type extends TSchema> = (TDeferred<'InstanceType', [Type]>);
+/** Creates a deferred InstanceType action. */
+export declare function InstanceTypeDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceTypeDeferred<Type>;
+/** Applies a InstanceType action to the given type. */
+export type TInstanceType<Type extends TSchema> = (TInstanceTypeAction<Type>);
+/** Applies a InstanceType action to the given type. */
+export declare function InstanceType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TInstanceType<Type>;

package/assets/types/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 TInterfaceAction } from '../engine/interface/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> = (TInterfaceAction<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/assets/types/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 TKeyOfAction } from '../engine/keyof/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> = (TKeyOfAction<Type>);
+/** Applies a KeyOf action to the given type. */
+export declare function KeyOf<Type extends TSchema>(type: Type, options?: TSchemaOptions): TKeyOf<Type>;

package/assets/types/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 TLowercaseAction } from '../engine/intrinsics/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> = (TLowercaseAction<Type>);
+/** Applies a Lowercase action to the given type. */
+export declare function Lowercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TLowercase<Type>;

package/assets/types/typebox/build/type/action/mapped.d.mts

@@ -0,0 +1,13 @@
+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 TMappedAction } from '../engine/mapped/instantiate.mjs';
+import { type TState } 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> = (TMappedAction<{}, TState<[], []>, 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/assets/types/typebox/build/type/action/module.d.mts

@@ -0,0 +1,13 @@
+import { type TSchemaOptions } from '../types/schema.mjs';
+import { type TProperties } from '../types/properties.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TState } from '../engine/instantiate.mjs';
+import { type TModuleInstantiate } from '../engine/module/instantiate.mjs';
+/** Creates a deferred Module action. */
+export type TModuleDeferred<Declarations extends TProperties> = (TDeferred<'Module', [Declarations]>);
+/** Creates a deferred Module action. */
+export declare function ModuleDeferred<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModuleDeferred<Declarations>;
+/** Creates a Module with the given declarations */
+export type TModule<Declarations extends TProperties> = (TModuleInstantiate<{}, TState<[], []>, Declarations>);
+/** Creates a Module with the given declarations */
+export declare function Module<Declarations extends TProperties>(declarations: Declarations, options?: TSchemaOptions): TModule<Declarations>;

package/assets/types/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 TNonNullableAction } from '../engine/non_nullable/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> = (TNonNullableAction<Type>);
+/** Applies a NonNullable action to the given type. */
+export declare function NonNullable<Type extends TSchema>(type: Type, options?: TSchemaOptions): TNonNullable<Type>;

package/assets/types/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 TOmitAction } from '../engine/omit/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> = (TOmitAction<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/assets/types/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 TParametersAction } from '../engine/parameters/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> = (TParametersAction<Type>);
+/** Applies a Parameters action to the given type. */
+export declare function Parameters<Type extends TSchema>(type: Type, options?: TSchemaOptions): TParameters<Type>;

package/assets/types/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 TPartialAction } from '../engine/partial/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): TPartialDeferred<Type>;
+/** Applies a Partial action to the given type. */
+export type TPartial<Type extends TSchema> = (TPartialAction<Type>);
+/** Applies a Partial action to the given type. */
+export declare function Partial<Type extends TSchema>(type: Type, options?: TSchemaOptions): TPartial<Type>;

package/assets/types/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 TPickAction } from '../engine/pick/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> = (TPickAction<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/assets/types/typebox/build/type/action/readonly_object.d.mts

@@ -0,0 +1,16 @@
+import { type TSchema, type TSchemaOptions } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TReadonlyObjectAction } from '../engine/readonly_object/instantiate.mjs';
+/** Creates a deferred ReadonlyType action. */
+export type TReadonlyObjectDeferred<Type extends TSchema> = (TDeferred<'ReadonlyObject', [Type]>);
+/** Creates a deferred ReadonlyType action. */
+export declare function ReadonlyObjectDeferred<Type extends TSchema>(type: Type, options?: TSchemaOptions): TDeferred<"ReadonlyObject", [Type]>;
+/** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
+export type TReadonlyObject<Type extends TSchema> = (TReadonlyObjectAction<Type>);
+/** This type is an alias for TypeScript's `Readonly<T>` utility type. It will make all properties of a TObject readonly or marks an TArray or TTuple as immutable `readonly T[]`. */
+export declare function ReadonlyObject<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReadonlyObject<Type>;
+/**
+ * This type has been renamed to ReadonlyObject.
+ * @deprecated
+*/
+export declare const ReadonlyType: typeof ReadonlyObject;

package/assets/types/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 TRequiredAction } from '../engine/required/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> = (TRequiredAction<Type>);
+/** Applies a Required action to the given type. */
+export declare function Required<Type extends TSchema>(type: Type, options?: TSchemaOptions): TRequired<Type>;

package/assets/types/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 TReturnTypeAction } from '../engine/return_type/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> = (TReturnTypeAction<Type>);
+/** Applies a ReturnType action to the given type. */
+export declare function ReturnType<Type extends TSchema>(type: Type, options?: TSchemaOptions): TReturnType<Type>;

package/assets/types/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 TUncapitalizeAction } from '../engine/intrinsics/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> = (TUncapitalizeAction<Type>);
+/** Applies a Uncapitalize action to the given type. */
+export declare function Uncapitalize<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUncapitalize<Type>;

package/assets/types/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 TUppercaseAction } from '../engine/intrinsics/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> = (TUppercaseAction<Type>);
+/** Applies a Uppercase action to the given type. */
+export declare function Uppercase<Type extends TSchema>(type: Type, options?: TSchemaOptions): TUppercase<Type>;

package/assets/types/typebox/build/type/action/with.d.mts

@@ -0,0 +1,11 @@
+import { type TSchema } from '../types/schema.mjs';
+import { type TDeferred } from '../types/deferred.mjs';
+import { type TWithAction } from '../engine/with/instantiate.mjs';
+/** Creates a deferred With action. */
+export type TWithDeferred<Type extends TSchema, Options extends TSchema> = (TDeferred<'With', [Type, Options]>);
+/** Creates a deferred With action. */
+export declare function WithDeferred<Type extends TSchema, Options extends TSchema>(type: Type, options: Options): TWithDeferred<Type, Options>;
+/** Applies annotation options to the given type. */
+export type TWith<Type extends TSchema, Options extends TSchema> = (Type & Options);
+/** Applies annotation options to the given type. */
+export declare function With<Type extends TSchema, const Options extends TSchema>(type: Type, options: Options): TWithAction<Type, Options>;

package/assets/types/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/assets/types/typebox/build/type/engine/call/instantiate.d.mts

@@ -0,0 +1,21 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TCallConstruct } from '../../types/call.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TGeneric } from '../../types/generic.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TEvaluateUnion } from '../evaluate/index.mjs';
+import { type TInstantiateType } from '../instantiate.mjs';
+import { type TInstantiateTypes } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+import { type TDistributeArguments } from './distribute_arguments.mjs';
+import { type TResolveTarget } from './resolve_target.mjs';
+import { type TResolveArgumentsContext } from './resolve_arguments.mjs';
+type TPeek<State extends TState, Result extends string = State['callstack'] extends [...infer _ extends string[], infer Top extends string] ? Top : ''> = Result;
+type TIsTailCall<State extends TState, Name extends string, Result extends boolean = TPeek<State> extends Name ? true : false> = Result;
+type TCallDispatch<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, Arguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, TState<[...State['callstack'], Target['$ref']], State['visited']>, Expression>> = TInstantiateType<ArgumentsContext, TState<[], []>, ReturnType>;
+type TCallDistributed<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, DistributedArguments extends TSchema[][], Result extends TSchema[] = []> = (DistributedArguments extends [infer Arguments extends TSchema[], ...infer DistributedArguments extends TSchema[][]] ? TCallDispatch<Context, State, Target, Parameters, Expression, Arguments> extends infer ReturnType extends TSchema ? TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments, [...Result, ReturnType]> : never : Result);
+type TCallImmediate<Context extends TProperties, State extends TState, Target extends TRef, Parameters extends TParameter[], Expression extends TSchema, InstantiatedArguments extends TSchema[], DistributedArguments extends TSchema[][] = TDistributeArguments<Parameters, InstantiatedArguments, Expression>, ReturnTypes extends TSchema[] = TCallDistributed<Context, State, Target, Parameters, Expression, DistributedArguments>, Result extends TSchema = ReturnTypes['length'] extends 1 ? ReturnTypes[0] : TEvaluateUnion<ReturnTypes>> = Result;
+export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, Resolved extends [string, TSchema] = TResolveTarget<Context, Target, Arguments>, Name extends string = Resolved[0], Type extends TSchema = Resolved[1], Result extends TSchema = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TIsTailCall<State, Name> extends true ? TCallConstruct<TRef<Name>, InstantiatedArguments> : TCallImmediate<Context, State, TRef<Name>, Parameters, Expression, InstantiatedArguments> : TCallConstruct<Target, InstantiatedArguments>)> = Result;
+export declare function CallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[]>(context: Context, state: State, target: Target, arguments_: [...Arguments]): TCallInstantiate<Context, State, Target, Arguments>;
+export {};

package/assets/types/typebox/build/type/engine/call/resolve_arguments.d.mts

@@ -0,0 +1,13 @@
+import { Memory } from '../../../system/memory/index.mjs';
+import { type TSchema } from '../../types/schema.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TState, type TInstantiateType } from '../instantiate.mjs';
+type TBindArgument<Context extends TProperties, State extends TState, Name extends string, Extends extends TSchema, Type extends TSchema, InstantiatedArgument extends TSchema = TInstantiateType<Context, State, Type>> = Memory.TAssign<Context, {
+    [_ in Name]: InstantiatedArgument;
+}>;
+type TBindArguments<Context extends TProperties, State extends TState, ParameterLeft extends TParameter, ParameterRight extends TParameter[], Arguments extends TSchema[], InstantiatedExtends extends TSchema = TInstantiateType<Context, State, ParameterLeft['extends']>, InstantiatedEquals extends TSchema = TInstantiateType<Context, State, ParameterLeft['equals']>> = (Arguments extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, Left>, State, ParameterRight, Right> : TBindParameters<TBindArgument<Context, State, ParameterLeft['name'], InstantiatedExtends, InstantiatedEquals>, State, ParameterRight, []>);
+type TBindParameters<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]> = (Parameters extends [infer Left extends TParameter, ...infer Right extends TParameter[]] ? TBindArguments<Context, State, Left, Right, Arguments> : Context);
+export type TResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[], Result extends TProperties = TBindParameters<Context, State, Parameters, Arguments>> = Result;
+export declare function ResolveArgumentsContext<Context extends TProperties, State extends TState, Parameters extends TParameter[], Arguments extends TSchema[]>(context: Context, state: State, parameters: [...Parameters], arguments_: [...Arguments]): TResolveArgumentsContext<Context, State, Parameters, Arguments>;
+export {};

package/assets/types/typebox/build/type/engine/call/resolve_target.d.mts

@@ -0,0 +1,25 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TGeneric } from '../../types/generic.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TParameter } from '../../types/parameter.mjs';
+import { type TNever } from '../../types/never.mjs';
+type TFromNotResolvable = ([
+    '(not-resolvable)',
+    TNever
+]);
+type TFromNotGeneric = ([
+    '(not-generic)',
+    TNever
+]);
+type TFromGeneric<Name extends string, Parameters extends TParameter[], Expression extends TSchema> = ([
+    Name,
+    TGeneric<Parameters, Expression>
+]);
+type TFromRef<Context extends TProperties, Ref extends string, Arguments extends TSchema[]> = (Ref extends keyof Context ? TFromType<Context, Ref, Context[Ref], Arguments> : TFromNotResolvable);
+type TFromType<Context extends TProperties, Name extends string, Type extends TSchema, Arguments extends TSchema[]> = (Type extends TGeneric<infer Parameters extends TParameter[], infer Expression extends TSchema> ? TFromGeneric<Name, Parameters, Expression> : Type extends TRef<infer Ref extends string> ? TFromRef<Context, Ref, Arguments> : TFromNotGeneric);
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export type TResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[], Result extends [string, TSchema] = TFromType<Context, '(anonymous)', Target, Arguments>> = Result;
+/** Resolves a named generic target from the context, or returns TNever if it cannot be resolved or is not generic. */
+export declare function ResolveTarget<Context extends TProperties, Target extends TSchema, Arguments extends TSchema[]>(context: Context, target: Target, arguments_: [...Arguments]): TFromType<Context, '(anonymous)', Target, Arguments>;
+export {};

package/assets/types/typebox/build/type/engine/conditional/index.d.mts

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

package/assets/types/typebox/build/type/engine/conditional/instantiate.d.mts

@@ -0,0 +1,12 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TExtends, ExtendsResult } from '../../extends/index.mjs';
+import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TConditionalDeferred } from '../../action/conditional.mjs';
+type TConditionalOperation<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, ExtendsResult extends ExtendsResult.TResult = TExtends<Context, Left, Right>> = (ExtendsResult extends ExtendsResult.TExtendsUnion<infer InferredContext extends TProperties> ? TUnion<[TInstantiateType<InferredContext, State, True>, TInstantiateType<Context, State, False>]> : ExtendsResult extends ExtendsResult.TExtendsTrue<infer InferredContext extends TProperties> ? TInstantiateType<InferredContext, State, True> : TInstantiateType<Context, State, False>);
+export type TConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, Result extends TSchema = TCanInstantiate<[Left, Right]> extends true ? TConditionalOperation<Context, State, Left, Right, True, False> : TConditionalDeferred<Left, Right, True, False>> = Result;
+export declare function ConditionalAction<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalAction<Context, State, Left, Right, True, False>;
+export type TConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema, InstaniatedLeft extends TSchema = TInstantiateType<Context, State, Left>, InstaniatedRight extends TSchema = TInstantiateType<Context, State, Right>> = TConditionalAction<Context, State, InstaniatedLeft, InstaniatedRight, True, False>;
+export declare function ConditionalInstantiate<Context extends TProperties, State extends TState, Left extends TSchema, Right extends TSchema, True extends TSchema, False extends TSchema>(context: Context, state: State, left: Left, right: Right, true_: True, false_: False, options: TSchemaOptions): TConditionalInstantiate<Context, State, Left, Right, True, False>;
+export {};

package/assets/types/typebox/build/type/engine/constructor_parameters/index.d.mts

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

package/assets/types/typebox/build/type/engine/constructor_parameters/instantiate.d.mts

@@ -0,0 +1,14 @@
+import { type TSchema, type TSchemaOptions } from '../../types/schema.mjs';
+import { type TProperties } from '../../types/properties.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TConstructorParametersDeferred } from '../../action/constructor_parameters.mjs';
+import { type TInstantiateType, type TCanInstantiate } from '../instantiate.mjs';
+import { type TInstantiateElements } from '../instantiate.mjs';
+import { type TState } from '../instantiate.mjs';
+type TConstructorParametersOperation<Type extends TSchema, Parameters extends TSchema[] = Type extends TConstructor ? Type['parameters'] : [], InstantiatedParameters extends TSchema[] = TInstantiateElements<{}, TState<[], []>, Parameters>, Result extends TSchema = TTuple<InstantiatedParameters>> = Result;
+export type TConstructorParametersAction<Type extends TSchema, Result extends TSchema = TCanInstantiate<[Type]> extends true ? TConstructorParametersOperation<Type> : TConstructorParametersDeferred<Type>> = Result;
+export declare function ConstructorParametersAction<Type extends TSchema>(type: Type, options: TSchemaOptions): TConstructorParametersAction<Type>;
+export type TConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema, InstantiatedType extends TSchema = TInstantiateType<Context, State, Type>> = TConstructorParametersAction<InstantiatedType>;
+export declare function ConstructorParametersInstantiate<Context extends TProperties, State extends TState, Type extends TSchema>(context: Context, state: State, type: Type, options: TSchemaOptions): TConstructorParametersInstantiate<Context, State, Type>;
+export {};

package/assets/types/typebox/build/type/engine/cyclic/candidates.d.mts

@@ -0,0 +1,8 @@
+import { type TProperties, type TPropertyKeys } from '../../types/properties.mjs';
+import { type TCyclicCheck } from './check.mjs';
+type TResolveCandidateKeys<Context extends TProperties, Keys extends (keyof Context)[], Result extends (keyof Context)[] = []> = (Keys extends [infer Left extends keyof Context, ...infer Right extends (keyof Context)[]] ? TCyclicCheck<[Left], Context, Context[Left]> extends true ? TResolveCandidateKeys<Context, Right, [...Result, Left]> : TResolveCandidateKeys<Context, Right, Result> : Result);
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export type TCyclicCandidates<Context extends TProperties, Keys extends (keyof Context)[] = TPropertyKeys<Context>, Result extends (keyof Context)[] = TResolveCandidateKeys<Context, Keys>> = Result;
+/** Returns keys for context types that need to be transformed to TCyclic. */
+export declare function CyclicCandidates<Context extends TProperties>(context: Context): TCyclicCandidates<Context>;
+export {};

package/assets/types/typebox/build/type/engine/cyclic/check.d.mts

@@ -0,0 +1,21 @@
+import { type TSchema } from '../../types/schema.mjs';
+import { type TArray } from '../../types/array.mjs';
+import { type TConstructor } from '../../types/constructor.mjs';
+import { type TFunction } from '../../types/function.mjs';
+import { type TIntersect } from '../../types/intersect.mjs';
+import { type TObject } from '../../types/object.mjs';
+import { type TProperties, type TPropertyValues } from '../../types/properties.mjs';
+import { type TRecord } from '../../types/record.mjs';
+import { type TTuple } from '../../types/tuple.mjs';
+import { type TUnion } from '../../types/union.mjs';
+import { type TRef } from '../../types/ref.mjs';
+import { type TInterfaceDeferred } from '../../action/interface.mjs';
+type TFromRef<Stack extends (keyof Context)[], Context extends TProperties, Ref extends (keyof Context)> = Ref extends Stack[number] ? true : TFromType<[...Stack, Ref], Context, Context[Ref]>;
+type TFromProperties<Stack extends (keyof Context)[], Context extends TProperties, Properties extends TProperties, Types extends TSchema[] = TPropertyValues<Properties>> = TFromTypes<Stack, Context, Types>;
+type TFromTypes<Stack extends (keyof Context)[], Context extends TProperties, Types extends TSchema[]> = Types extends [infer Left extends TSchema, ...infer Right extends TSchema[]] ? TFromType<Stack, Context, Left> extends true ? true : TFromTypes<Stack, Context, Right> : false;
+type TFromType<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema> = (Type extends TRef<infer Ref extends string> ? TFromRef<Stack, Context, Ref> : Type extends TArray<infer Type extends TSchema> ? TFromType<Stack, Context, Type> : Type extends TConstructor<infer Parameters extends TSchema[], infer InstanceType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, InstanceType]> : Type extends TFunction<infer Parameters extends TSchema[], infer ReturnType extends TSchema> ? TFromTypes<Stack, Context, [...Parameters, ReturnType]> : Type extends TInterfaceDeferred<TSchema[], infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TIntersect<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TObject<infer Properties extends TProperties> ? TFromProperties<Stack, Context, Properties> : Type extends TUnion<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TTuple<infer Types extends TSchema[]> ? TFromTypes<Stack, Context, Types> : Type extends TRecord<string, infer Type extends TSchema> ? TFromType<Stack, Context, Type> : false);
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export type TCyclicCheck<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema, Result extends boolean = TFromType<Stack, Context, Type>> = Result;
+/** Performs a cyclic check on the given type. Initial key stack can be empty, but faster if specified */
+export declare function CyclicCheck<Stack extends (keyof Context)[], Context extends TProperties, Type extends TSchema>(stack: [...Stack], context: Context, type: Type): TCyclicCheck<Stack, Context, Type>;
+export {};