typebox 1.0.33 → 1.0.35

package/build/cjs/type/action/lowercase.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LowercaseDeferred = LowercaseDeferred;
-exports.Lowercase = Lowercase;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Lowercase action. */
-function LowercaseDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Lowercase', [type], options);
-}
-/** Applies a Lowercase action to the given type. */
-function Lowercase(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, LowercaseDeferred(type, options));
-}

package/build/cjs/type/action/mapped.d.ts

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

package/build/cjs/type/action/mapped.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MappedDeferred = MappedDeferred;
-exports.Mapped = Mapped;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Mapped action. */
-function MappedDeferred(identifier, key, as, property, options = {}) {
-    return (0, deferred_1.Deferred)('Mapped', [identifier, key, as, property], options);
-}
-/** Applies a Mapped action using the given types. */
-function Mapped(identifier, key, as, property, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, MappedDeferred(identifier, key, as, property, options));
-}

package/build/cjs/type/action/module.d.ts

@@ -1,12 +0,0 @@
-import { type TSchemaOptions } from '../types/schema';
-import { type TProperties } from '../types/properties';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/module.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModuleDeferred = ModuleDeferred;
-exports.Module = Module;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Module action. */
-function ModuleDeferred(context, options = {}) {
-    return (0, deferred_1.Deferred)('Module', [context], options);
-}
-/** Applies a Module transformation action to the embedded property types. */
-function Module(context, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, ModuleDeferred(context, options));
-}

package/build/cjs/type/action/non-nullable.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/non-nullable.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NonNullableDeferred = NonNullableDeferred;
-exports.NonNullable = NonNullable;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred NonNullable action. */
-function NonNullableDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('NonNullable', [type], options);
-}
-/** Applies a NonNullable action to the given type. */
-function NonNullable(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, NonNullableDeferred(type, options));
-}

package/build/cjs/type/action/omit.d.ts

@@ -1,14 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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: [...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/build/cjs/type/action/omit.js

@@ -1,18 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OmitDeferred = OmitDeferred;
-exports.Omit = Omit;
-const index_1 = require("../../guard/index");
-const deferred_1 = require("../types/deferred");
-const keys_to_indexer_1 = require("../engine/helpers/keys-to-indexer");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Omit action. */
-function OmitDeferred(type, indexer, options = {}) {
-    return (0, deferred_1.Deferred)('Omit', [type, indexer], options);
-}
-/** Applies a Omit action using the given types. */
-function Omit(type, indexer_or_keys, options = {}) {
-    const indexer = index_1.Guard.IsArray(indexer_or_keys) ? (0, keys_to_indexer_1.KeysToIndexer)(indexer_or_keys) : indexer_or_keys;
-    return (0, instantiate_1.Instantiate)({}, OmitDeferred(type, indexer, options));
-}

package/build/cjs/type/action/options.d.ts

@@ -1,12 +0,0 @@
-import { type TSchema } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/options.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OptionsDeferred = OptionsDeferred;
-exports.Options = Options;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Options action. */
-function OptionsDeferred(type, options) {
-    return (0, deferred_1.Deferred)('Options', [type, options], {});
-}
-/** Applies an Options action to the given type. */
-function Options(type, options) {
-    return (0, instantiate_1.Instantiate)({}, OptionsDeferred(type, options));
-}

package/build/cjs/type/action/parameters.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/parameters.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParametersDeferred = ParametersDeferred;
-exports.Parameters = Parameters;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Parameters action. */
-function ParametersDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Parameters', [type], options);
-}
-/** Applies a Parameters action to the given type. */
-function Parameters(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, ParametersDeferred(type, options));
-}

package/build/cjs/type/action/partial.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/partial.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PartialDeferred = PartialDeferred;
-exports.Partial = Partial;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Partial action. */
-function PartialDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Partial', [type], options);
-}
-/** Applies a Partial action to the given type. */
-function Partial(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, PartialDeferred(type, options));
-}

package/build/cjs/type/action/pick.d.ts

@@ -1,14 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TKeysToIndexer } from '../engine/helpers/keys-to-indexer';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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: [...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/build/cjs/type/action/pick.js

@@ -1,18 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PickDeferred = PickDeferred;
-exports.Pick = Pick;
-const index_1 = require("../../guard/index");
-const deferred_1 = require("../types/deferred");
-const keys_to_indexer_1 = require("../engine/helpers/keys-to-indexer");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Pick action. */
-function PickDeferred(type, indexer, options = {}) {
-    return (0, deferred_1.Deferred)('Pick', [type, indexer], options);
-}
-/** Applies a Pick action using the given types. */
-function Pick(type, indexer_or_keys, options = {}) {
-    const indexer = index_1.Guard.IsArray(indexer_or_keys) ? (0, keys_to_indexer_1.KeysToIndexer)(indexer_or_keys) : indexer_or_keys;
-    return (0, instantiate_1.Instantiate)({}, PickDeferred(type, indexer, options));
-}

package/build/cjs/type/action/required.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/required.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RequiredDeferred = RequiredDeferred;
-exports.Required = Required;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Required action. */
-function RequiredDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Required', [type], options);
-}
-/** Applies a Required action to the given type. */
-function Required(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, RequiredDeferred(type, options));
-}

package/build/cjs/type/action/return-type.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/return-type.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReturnTypeDeferred = ReturnTypeDeferred;
-exports.ReturnType = ReturnType;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred ReturnType action. */
-function ReturnTypeDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('ReturnType', [type], options);
-}
-/** Applies a ReturnType action to the given type. */
-function ReturnType(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, ReturnTypeDeferred(type, options));
-}

package/build/cjs/type/action/uncapitalize.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/uncapitalize.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UncapitalizeDeferred = UncapitalizeDeferred;
-exports.Uncapitalize = Uncapitalize;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Uncapitalize action. */
-function UncapitalizeDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Uncapitalize', [type], options);
-}
-/** Applies a Uncapitalize action to the given type. */
-function Uncapitalize(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, UncapitalizeDeferred(type, options));
-}

package/build/cjs/type/action/uppercase.d.ts

@@ -1,11 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../types/schema';
-import { type TDeferred } from '../types/deferred';
-import { type TInstantiate } from '../engine/instantiate';
-/** 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/build/cjs/type/action/uppercase.js

@@ -1,15 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UppercaseDeferred = UppercaseDeferred;
-exports.Uppercase = Uppercase;
-const deferred_1 = require("../types/deferred");
-const instantiate_1 = require("../engine/instantiate");
-/** Creates a deferred Uppercase action. */
-function UppercaseDeferred(type, options = {}) {
-    return (0, deferred_1.Deferred)('Uppercase', [type], options);
-}
-/** Applies a Uppercase action to the given type. */
-function Uppercase(type, options = {}) {
-    return (0, instantiate_1.Instantiate)({}, UppercaseDeferred(type, options));
-}

package/build/cjs/type/engine/awaited/index.d.ts

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

package/build/cjs/type/engine/awaited/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./instantiate"), exports);

package/build/cjs/type/engine/awaited/instantiate.d.ts

@@ -1,10 +0,0 @@
-import { type TSchema, type TSchemaOptions } from '../../types/schema';
-import { type TProperties } from '../../types/properties';
-import { type TPromise } from '../../types/promise';
-import { type TAwaitedDeferred } from '../../action/awaited';
-import { type TState, type TInstantiateType, type TCanInstantiate } from '../instantiate';
-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/build/cjs/type/engine/awaited/instantiate.js

@@ -1,22 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AwaitedInstantiate = AwaitedInstantiate;
-const index_1 = require("../../../system/memory/index");
-const promise_1 = require("../../types/promise");
-const awaited_1 = require("../../action/awaited");
-const instantiate_1 = require("../instantiate");
-function AwaitedAction(type) {
-    return ((0, promise_1.IsPromise)(type)
-        ? AwaitedAction(type.item)
-        : type);
-}
-function AwaitedImmediate(context, state, type, options) {
-    const instantiatedType = (0, instantiate_1.InstantiateType)(context, state, type);
-    return index_1.Memory.Update(AwaitedAction(instantiatedType), {}, options);
-}
-function AwaitedInstantiate(context, state, type, options) {
-    return ((0, instantiate_1.CanInstantiate)(context, [type])
-        ? AwaitedImmediate(context, state, type, options)
-        : (0, awaited_1.AwaitedDeferred)(type, options));
-}

package/build/cjs/type/engine/call/instantiate.d.ts

@@ -1,20 +0,0 @@
-import { type TSchema } from '../../types/schema';
-import { type TParameter } from '../../types/parameter';
-import { type TCallConstruct } from '../../types/call';
-import { type TRef } from '../../types/ref';
-import { type TGeneric } from '../../types/generic';
-import { type TProperties } from '../../types/properties';
-import { type TState } from '../instantiate';
-import { type TInstantiateType } from '../instantiate';
-import { type TInstantiateTypes } from '../instantiate';
-import { type TResolveTarget } from './resolve-target';
-import { type TResolveArgumentsContext } from './resolve-arguments';
-type TPeek<CallStack extends string[], Result extends string = CallStack extends [infer Left extends string, ...infer _ extends string[]] ? Left : ''> = Result;
-type TDeferredCall<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, DeferredCall extends TSchema = TCallConstruct<Target, InstantiatedArguments>> = DeferredCall;
-type TTailCall<Context extends TProperties, State extends TState, Name extends string, Arguments extends TSchema[], DeferredCall extends TSchema = TDeferredCall<Context, State, TRef<Name>, Arguments>> = DeferredCall;
-type THeadCall<Context extends TProperties, State extends TState, Name extends string, Parameters extends TParameter[], Expression extends TSchema, Arguments extends TSchema[], InstantiatedArguments extends TSchema[] = TInstantiateTypes<Context, State, Arguments>, ArgumentsContext extends TProperties = TResolveArgumentsContext<Context, State, Parameters, InstantiatedArguments>, ReturnType extends TSchema = TInstantiateType<ArgumentsContext, {
-    callstack: [...State['callstack'], Name];
-}, Expression>> = TInstantiateType<Context, State, ReturnType>;
-export type TCallInstantiate<Context extends TProperties, State extends TState, Target extends TSchema, Arguments extends TSchema[], 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> ? TPeek<State['callstack']> extends Name ? TTailCall<Context, State, Name, Arguments> : THeadCall<Context, State, Name, Parameters, Expression, Arguments> : TDeferredCall<Context, State, Target, Arguments>)> = 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/build/cjs/type/engine/call/instantiate.js

@@ -1,41 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CallInstantiate = CallInstantiate;
-const index_1 = require("../../../guard/index");
-const call_1 = require("../../types/call");
-const ref_1 = require("../../types/ref");
-const generic_1 = require("../../types/generic");
-const instantiate_1 = require("../instantiate");
-const instantiate_2 = require("../instantiate");
-// ----------------------------------------------------------------------------
-// Call: Infrastructure
-// ----------------------------------------------------------------------------
-const resolve_target_1 = require("./resolve-target");
-const resolve_arguments_1 = require("./resolve-arguments");
-function Peek(callstack) {
-    return (index_1.Guard.IsGreaterThan(callstack.length, 0) ? callstack[0] : '');
-}
-function DeferredCall(context, state, target, arguments_) {
-    const instantiatedArguments = (0, instantiate_2.InstantiateTypes)(context, state, arguments_);
-    const deferredCall = (0, call_1.CallConstruct)(target, instantiatedArguments);
-    return deferredCall;
-}
-function TailCall(context, state, name, arguments_) {
-    const deferredCall = DeferredCall(context, state, (0, ref_1.Ref)(name), arguments_);
-    return deferredCall;
-}
-function HeadCall(context, state, name, parameters, expression, arguments_) {
-    const instantiatedArguments = (0, instantiate_2.InstantiateTypes)(context, state, arguments_);
-    const argumentsContext = (0, resolve_arguments_1.ResolveArgumentsContext)(context, state, parameters, instantiatedArguments);
-    const returnType = (0, instantiate_1.InstantiateType)(argumentsContext, { callstack: [...state.callstack, name] }, expression);
-    return (0, instantiate_1.InstantiateType)(context, state, returnType);
-}
-function CallInstantiate(context, state, target, arguments_) {
-    const [name, type] = (0, resolve_target_1.ResolveTarget)(context, target, arguments_);
-    return ((0, generic_1.IsGeneric)(type)
-        ? index_1.Guard.IsEqual(Peek(state.callstack), name)
-            ? TailCall(context, state, name, arguments_)
-            : HeadCall(context, state, name, type.parameters, type.expression, arguments_)
-        : DeferredCall(context, state, target, arguments_));
-}

package/build/cjs/type/engine/call/resolve-arguments.d.ts

@@ -1,13 +0,0 @@
-import { Memory } from '../../../system/memory/index';
-import { type TSchema } from '../../types/schema';
-import { type TParameter } from '../../types/parameter';
-import { type TProperties } from '../../types/properties';
-import { type TState, type TInstantiateType } from '../instantiate';
-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/build/cjs/type/engine/call/resolve-arguments.js

@@ -1,42 +0,0 @@
-"use strict";
-// deno-fmt-ignore-file
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResolveArgumentsContext = ResolveArgumentsContext;
-const index_1 = require("../../../system/memory/index");
-const schema_1 = require("../../types/schema");
-const instantiate_1 = require("../instantiate");
-const index_2 = require("../../extends/index");
-const infer_1 = require("../../types/infer");
-const call_1 = require("../../types/call");
-// ------------------------------------------------------------------
-// AssertArgument
-// ------------------------------------------------------------------
-function AssertArgumentExtends(name, type, extends_) {
-    if ((0, infer_1.IsInfer)(type) || (0, call_1.IsCall)(type) || index_2.ExtendsResult.IsExtendsTrueLike((0, index_2.Extends)({}, type, extends_)))
-        return;
-    const cause = { parameter: name, extends: extends_, received: type };
-    // @ts-ignore - no definition for { cause } options 
-    throw new Error('Generic argument does not satify constraint', { cause });
-}
-function BindArgument(context, state, name, extends_, type) {
-    const instantiatedArgument = (0, instantiate_1.InstantiateType)(context, state, type);
-    AssertArgumentExtends(name, instantiatedArgument, extends_);
-    return index_1.Memory.Assign(context, { [name]: instantiatedArgument });
-}
-function BindArguments(context, state, parameterLeft, parameterRight, arguments_) {
-    const instantiatedExtends = (0, instantiate_1.InstantiateType)(context, state, parameterLeft.extends);
-    const instantiatedEquals = (0, instantiate_1.InstantiateType)(context, state, parameterLeft.equals);
-    const [left, ...right] = arguments_;
-    return ((0, schema_1.IsSchema)(left)
-        ? BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, left), state, parameterRight, right)
-        : BindParameters(BindArgument(context, state, parameterLeft['name'], instantiatedExtends, instantiatedEquals), state, parameterRight, []));
-}
-function BindParameters(context, state, parameters, arguments_) {
-    const [left, ...right] = parameters;
-    return ((0, schema_1.IsSchema)(left)
-        ? BindArguments(context, state, left, right, arguments_)
-        : context);
-}
-function ResolveArgumentsContext(context, state, parameters, arguments_) {
-    return BindParameters(context, state, parameters, arguments_);
-}

package/build/cjs/type/engine/call/resolve-target.d.ts

@@ -1,25 +0,0 @@
-import { type TSchema } from '../../types/schema';
-import { type TProperties } from '../../types/properties';
-import { type TGeneric } from '../../types/generic';
-import { type TRef } from '../../types/ref';
-import { type TParameter } from '../../types/parameter';
-import { type TNever } from '../../types/never';
-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 {};