pi-proactive 0.2.0-beta.3 → 0.2.0-beta.4

package/node_modules/typebox/build/guard/guard.d.mts

@@ -1,71 +0,0 @@
-/** Returns true if this value is an array */
-export declare function IsArray(value: unknown): value is unknown[];
-/** Returns true if this value is bigint */
-export declare function IsBigInt(value: unknown): value is bigint;
-/** Returns true if this value is a boolean */
-export declare function IsBoolean(value: unknown): value is boolean;
-/** Returns true if this value is a constructor */
-export declare function IsConstructor(value: unknown): value is new (...args: never[]) => unknown;
-/** Returns true if this value is a function */
-export declare function IsFunction(value: unknown): value is globalThis.Function;
-/** Returns true if this value is integer */
-export declare function IsInteger(value: unknown): value is number;
-/** Returns true if this value is null */
-export declare function IsNull(value: unknown): value is null;
-/** Returns true if this value is number */
-export declare function IsNumber(value: unknown): value is number;
-/** Returns true if this value is an object but not an array */
-export declare function IsObjectNotArray(value: unknown): value is Record<PropertyKey, unknown>;
-/** Returns true if this value is an object */
-export declare function IsObject(value: unknown): value is Record<PropertyKey, unknown>;
-/** Returns true if this value is string */
-export declare function IsString(value: unknown): value is string;
-/** Returns true if this value is symbol */
-export declare function IsSymbol(value: unknown): value is symbol;
-/** Returns true if this value is undefined */
-export declare function IsUndefined(value: unknown): value is undefined;
-export declare function IsEqual(left: unknown, right: unknown): boolean;
-export declare function IsGreaterThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsLessThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsLessEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsGreaterEqualThan<Type extends number | bigint>(left: Type, right: Type): boolean;
-export declare function IsMultipleOf(dividend: bigint | number, divisor: bigint | number): boolean;
-/** Returns true if the value appears to be an instance of a class. */
-export declare function IsClassInstance(value: unknown): boolean;
-export declare function IsValueLike(value: unknown): value is bigint | boolean | null | number | string | undefined;
-/** Returns the number of grapheme clusters in the string */
-export declare function GraphemeCount(value: string): number;
-/** Returns true if the string has at most the given number of graphemes */
-export declare function IsMaxLength(value: string, length: number): boolean;
-/** Returns true if the string has at least the given number of graphemes */
-export declare function IsMinLength(value: string, length: number): boolean;
-/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
-export declare function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
-export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if some element satisfies the callback, short-circuiting on the first success */
-export declare function Some<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
-/** Returns true if some element satisfies the callback, using exhaustive enumeration */
-export declare function SomeAll<T>(value: T[], callback: (value: T, index: number) => boolean): boolean;
-/** Returns the count of elements that satisfy the callback */
-export declare function Counted(value: unknown[], callback: (value: unknown, index: number) => boolean): number;
-/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export declare function ShiftLeft<T, True extends (left: T, right: T[]) => unknown, False extends () => unknown>(array: T[], true_: True, false_: False): ReturnType<True> | ReturnType<False>;
-/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
-export declare function IsUnsafePropertyKey(key: PropertyKey): boolean;
-/** Returns true if this value has this property key */
-export declare function HasPropertyKey<Key extends PropertyKey>(value: object, key: Key): value is {
-    [_ in Key]: unknown;
-};
-/** Returns object entries as `[RegExp, Value][]` */
-export declare function EntriesRegExp<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [RegExp, Value][];
-/** Returns object entries as `[string, Value][]` */
-export declare function Entries<Value extends unknown = unknown>(value: Record<PropertyKey, Value>): [string, Value][];
-/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
-export declare function Keys(value: Record<PropertyKey, unknown>): string[];
-/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
-export declare function Symbols(value: Record<PropertyKey, unknown>): symbol[];
-/** Returns the property values for the given object via `Object.values()` */
-export declare function Values(value: Record<PropertyKey, unknown>): unknown[];
-/** Returns true if left and right values are structurally equal */
-export declare function IsDeepEqual(left: unknown, right: unknown): boolean;

package/node_modules/typebox/build/guard/guard.mjs

@@ -1,221 +0,0 @@
-// deno-fmt-ignore-file
-import * as String from './string.mjs';
-// --------------------------------------------------------------------------
-// Guards
-// --------------------------------------------------------------------------
-/** Returns true if this value is an array */
-export function IsArray(value) {
-    return Array.isArray(value);
-}
-/** Returns true if this value is bigint */
-export function IsBigInt(value) {
-    return IsEqual(typeof value, 'bigint');
-}
-/** Returns true if this value is a boolean */
-export function IsBoolean(value) {
-    return IsEqual(typeof value, 'boolean');
-}
-/** Returns true if this value is a constructor */
-export function IsConstructor(value) {
-    if (IsUndefined(value) || !IsFunction(value))
-        return false;
-    const result = Function.prototype.toString.call(value);
-    if (/^class\s/.test(result))
-        return true;
-    if (/\[native code\]/.test(result))
-        return true;
-    return false;
-}
-/** Returns true if this value is a function */
-export function IsFunction(value) {
-    return IsEqual(typeof value, 'function');
-}
-/** Returns true if this value is integer */
-export function IsInteger(value) {
-    return Number.isInteger(value);
-}
-/** Returns true if this value is null */
-export function IsNull(value) {
-    return IsEqual(value, null);
-}
-/** Returns true if this value is number */
-export function IsNumber(value) {
-    return Number.isFinite(value);
-}
-/** Returns true if this value is an object but not an array */
-export function IsObjectNotArray(value) {
-    return IsObject(value) && !IsArray(value);
-}
-/** Returns true if this value is an object */
-export function IsObject(value) {
-    return IsEqual(typeof value, 'object') && !(IsNull(value));
-}
-/** Returns true if this value is string */
-export function IsString(value) {
-    return IsEqual(typeof value, 'string');
-}
-/** Returns true if this value is symbol */
-export function IsSymbol(value) {
-    return IsEqual(typeof value, 'symbol');
-}
-/** Returns true if this value is undefined */
-export function IsUndefined(value) {
-    return IsEqual(value, undefined);
-}
-// --------------------------------------------------------------------------
-// Relational
-// --------------------------------------------------------------------------
-export function IsEqual(left, right) {
-    return left === right;
-}
-export function IsGreaterThan(left, right) {
-    return left > right;
-}
-export function IsLessThan(left, right) {
-    return left < right;
-}
-export function IsLessEqualThan(left, right) {
-    return left <= right;
-}
-export function IsGreaterEqualThan(left, right) {
-    return left >= right;
-}
-// --------------------------------------------------------------------------
-// MultipleOf
-// --------------------------------------------------------------------------
-export function IsMultipleOf(dividend, divisor) {
-    if (IsBigInt(dividend) || IsBigInt(divisor)) {
-        return BigInt(dividend) % BigInt(divisor) === 0n;
-    }
-    const tolerance = 1e-10;
-    if (!IsNumber(dividend))
-        return true;
-    if (IsInteger(dividend) && (1 / divisor) % 1 === 0)
-        return true;
-    const mod = dividend % divisor;
-    return Math.min(Math.abs(mod), Math.abs(mod - divisor), Math.abs(mod + divisor)) < tolerance;
-}
-// ------------------------------------------------------------------
-// IsClassInstance
-// ------------------------------------------------------------------
-/** Returns true if the value appears to be an instance of a class. */
-export function IsClassInstance(value) {
-    if (!IsObject(value))
-        return false;
-    const proto = globalThis.Object.getPrototypeOf(value);
-    if (IsNull(proto))
-        return false;
-    return IsEqual(typeof proto.constructor, 'function') &&
-        !(IsEqual(proto.constructor, globalThis.Object) ||
-            IsEqual(proto.constructor.name, 'Object'));
-}
-// ------------------------------------------------------------------
-// IsValueLike
-// ------------------------------------------------------------------
-export function IsValueLike(value) {
-    return IsBigInt(value) ||
-        IsBoolean(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsString(value) ||
-        IsUndefined(value);
-}
-// --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in the string */
-export function GraphemeCount(value) {
-    return String.GraphemeCount(value);
-}
-/** Returns true if the string has at most the given number of graphemes */
-export function IsMaxLength(value, length) {
-    return String.IsMaxLength(value, length);
-}
-/** Returns true if the string has at least the given number of graphemes */
-export function IsMinLength(value, length) {
-    return String.IsMinLength(value, length);
-}
-// --------------------------------------------------------------------------
-// Array
-// --------------------------------------------------------------------------
-/** Returns true if every element from offset satisfies the callback, short-circuiting on the first failure */
-export function Every(value, offset, callback) {
-    return value.every((item, index) => (index < offset) || callback(item, index));
-}
-/** Returns true if every element from offset satisfies the callback, using exhaustive enumeration */
-export function EveryAll(value, offset, callback) {
-    let result = true;
-    value.forEach((item, index) => { if ((index >= offset) && !callback(item, index))
-        result = false; });
-    return result;
-}
-/** Returns true if some element satisfies the callback, short-circuiting on the first success */
-export function Some(value, callback) {
-    return value.some((value, index) => callback(value, index));
-}
-/** Returns true if some element satisfies the callback, using exhaustive enumeration */
-export function SomeAll(value, callback) {
-    let result = false;
-    value.forEach((item, index) => { if (callback(item, index))
-        result = true; });
-    return result;
-}
-/** Returns the count of elements that satisfy the callback */
-export function Counted(value, callback) {
-    return value.reduce((result, value, index) => callback(value, index) ? ++result : result, 0);
-}
-/** Shifts the left-most element from an array and dispatches to the true arm, or the false arm if empty */
-export function ShiftLeft(array, true_, false_) {
-    return (IsEqual(array.length, 0) ? false_() : true_(array[0], array.slice(1)));
-}
-// --------------------------------------------------------------------------
-// Object
-// --------------------------------------------------------------------------
-/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
-export function IsUnsafePropertyKey(key) {
-    return IsEqual(key, '__proto__') || IsEqual(key, 'constructor') || IsEqual(key, 'prototype');
-}
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-    return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
-}
-/** Returns object entries as `[RegExp, Value][]` */
-export function EntriesRegExp(value) {
-    return Keys(value).map((key) => [new RegExp(`^${key}$`), value[key]]);
-}
-/** Returns object entries as `[string, Value][]` */
-export function Entries(value) {
-    return Object.entries(value);
-}
-/** Returns property keys for this object via `Object.getOwnPropertyNames({ ... })` */
-export function Keys(value) {
-    return Object.getOwnPropertyNames(value);
-}
-/** Returns the property keys for this object via `Object.getOwnPropertySymbols({ ... })` */
-export function Symbols(value) {
-    return Object.getOwnPropertySymbols(value);
-}
-/** Returns the property values for the given object via `Object.values()` */
-export function Values(value) {
-    return Object.values(value);
-}
-// ------------------------------------------------------------------
-// IsDeepEqual
-// ------------------------------------------------------------------
-function DeepEqualObject(left, right) {
-    if (!IsObject(right))
-        return false;
-    const keys = Keys(left);
-    return IsEqual(keys.length, Keys(right).length) &&
-        keys.every((key) => IsDeepEqual(left[key], right[key]));
-}
-function DeepEqualArray(left, right) {
-    return IsArray(right) && IsEqual(left.length, right.length) &&
-        left.every((_, index) => IsDeepEqual(left[index], right[index]));
-}
-/** Returns true if left and right values are structurally equal */
-export function IsDeepEqual(left, right) {
-    return (IsArray(left) ? DeepEqualArray(left, right) :
-        IsObject(left) ? DeepEqualObject(left, right) :
-            IsEqual(left, right));
-}

package/node_modules/typebox/build/guard/index.d.mts

@@ -1,6 +0,0 @@
-export * as EmitGuard from './emit.mjs';
-export * as GlobalsGuard from './globals.mjs';
-export * as NativeGuard from './native.mjs';
-import * as Guard from './guard.mjs';
-export * as Guard from './guard.mjs';
-export default Guard;

package/node_modules/typebox/build/guard/index.mjs

@@ -1,6 +0,0 @@
-export * as EmitGuard from './emit.mjs';
-export * as GlobalsGuard from './globals.mjs';
-export * as NativeGuard from './native.mjs';
-import * as Guard from './guard.mjs';
-export * as Guard from './guard.mjs';
-export default Guard;

package/node_modules/typebox/build/guard/native.d.mts

@@ -1,20 +0,0 @@
-/** Returns true if this value is a F32 */
-export declare function IsF32(value: unknown): value is number;
-/** Returns true if this value is a F64 */
-export declare function IsF64(value: unknown): value is number;
-/** Returns true if this value is a U8 */
-export declare function IsU8(value: unknown): value is number;
-/** Returns true if this value is a U16 */
-export declare function IsU16(value: unknown): value is number;
-/** Returns true if this value is a U32 */
-export declare function IsU32(value: unknown): value is number;
-/** Returns true if this value is a U64 */
-export declare function IsU64(value: unknown): value is number;
-/** Returns true if this value is a I8 */
-export declare function IsI8(value: unknown): value is number;
-/** Returns true if this value is a I16 */
-export declare function IsI16(value: unknown): value is number;
-/** Returns true if this value is a I32 */
-export declare function IsI32(value: unknown): value is number;
-/** Returns true if this value is a I64 */
-export declare function IsI64(value: unknown): value is number | bigint;

package/node_modules/typebox/build/guard/native.mjs

@@ -1,60 +0,0 @@
-import * as Guard from './guard.mjs';
-// --------------------------------------------------------------------------
-// Native
-// --------------------------------------------------------------------------
-/** Returns true if this value is a F32 */
-export function IsF32(value) {
-    return Guard.IsNumber(value) &&
-        Guard.IsEqual(value, Math.fround(value));
-}
-/** Returns true if this value is a F64 */
-export function IsF64(value) {
-    return Guard.IsNumber(value);
-}
-/** Returns true if this value is a U8 */
-export function IsU8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 255);
-}
-/** Returns true if this value is a U16 */
-export function IsU16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 65535);
-}
-/** Returns true if this value is a U32 */
-export function IsU32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0) &&
-        Guard.IsLessEqualThan(value, 4294967295);
-}
-/** Returns true if this value is a U64 */
-export function IsU64(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, 0);
-}
-/** Returns true if this value is a I8 */
-export function IsI8(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -128) &&
-        Guard.IsLessEqualThan(value, 127);
-}
-/** Returns true if this value is a I16 */
-export function IsI16(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -32768) &&
-        Guard.IsLessEqualThan(value, 32767);
-}
-/** Returns true if this value is a I32 */
-export function IsI32(value) {
-    return Guard.IsInteger(value) &&
-        Guard.IsGreaterEqualThan(value, -2147483648) &&
-        Guard.IsLessEqualThan(value, 2147483647);
-}
-/** Returns true if this value is a I64 */
-export function IsI64(value) {
-    return Guard.IsBigInt(value) &&
-        Guard.IsGreaterEqualThan(value, BigInt('-9223372036854775808')) &&
-        Guard.IsLessEqualThan(value, BigInt('9223372036854775807'));
-}

package/node_modules/typebox/build/guard/string.d.mts

@@ -1,6 +0,0 @@
-/** Returns the number of grapheme clusters in a string */
-export declare function GraphemeCount(value: string): number;
-/** Fast check for minimum grapheme length, falls back to full check if needed */
-export declare function IsMinLength(value: string, minLength: number): boolean;
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export declare function IsMaxLength(value: string, maxLength: number): boolean;

package/node_modules/typebox/build/guard/string.mjs

@@ -1,168 +0,0 @@
-// --------------------------------------------------------------------------
-// IsBetween
-// --------------------------------------------------------------------------
-function IsBetween(value, min, max) {
-    return value >= min && value <= max;
-}
-// --------------------------------------------------------------------------
-// IsZeroWidthJoiner
-// --------------------------------------------------------------------------
-function IsZeroWidthJoiner(value) {
-    return (value === 0x200D);
-}
-// --------------------------------------------------------------------------
-// IsHighSurrogate
-// --------------------------------------------------------------------------
-function IsHighSurrogate(value) {
-    return IsBetween(value, 0xD800, 0xDBFF);
-}
-// --------------------------------------------------------------------------
-// IsRegionalIndicator
-// --------------------------------------------------------------------------
-function IsRegionalIndicator(value) {
-    return IsBetween(value, 0x1F1E6, 0x1F1FF);
-}
-// --------------------------------------------------------------------------
-// IsVariationSelector
-// --------------------------------------------------------------------------
-function IsVariationSelector(value) {
-    return IsBetween(value, 0xFE00, 0xFE0F);
-}
-// --------------------------------------------------------------------------
-// IsCombiningMark
-// --------------------------------------------------------------------------
-function IsCombiningMark(value) {
-    return (IsBetween(value, 0x0300, 0x036F) ||
-        IsBetween(value, 0x1AB0, 0x1AFF) ||
-        IsBetween(value, 0x1DC0, 0x1DFF) ||
-        IsBetween(value, 0xFE20, 0xFE2F));
-}
-// --------------------------------------------------------------------------
-// CodePointLength
-// --------------------------------------------------------------------------
-function CodePointLength(value) {
-    return value > 0xFFFF ? 2 : 1;
-}
-// --------------------------------------------------------------------------
-// ConsumeModifiers (helper)
-// --------------------------------------------------------------------------
-function ConsumeModifiers(value, index) {
-    while (index < value.length) {
-        const point = value.codePointAt(index);
-        if (IsCombiningMark(point) || IsVariationSelector(point)) {
-            index += CodePointLength(point);
-        }
-        else {
-            break;
-        }
-    }
-    return index;
-}
-// --------------------------------------------------------------------------
-// NextGraphemeClusterIndex
-// --------------------------------------------------------------------------
-function NextGraphemeClusterIndex(value, clusterStart) {
-    const startCP = value.codePointAt(clusterStart);
-    let clusterEnd = clusterStart + CodePointLength(startCP);
-    // Consume combining marks & variation selectors
-    clusterEnd = ConsumeModifiers(value, clusterEnd);
-    // Handle multi-ZWJ sequences
-    while (clusterEnd < value.length - 1 && IsZeroWidthJoiner(value.codePointAt(clusterEnd))) {
-        const nextCP = value.codePointAt(clusterEnd + 1);
-        clusterEnd += 1 + CodePointLength(nextCP);
-        clusterEnd = ConsumeModifiers(value, clusterEnd);
-    }
-    // Handle regional indicator pairs (flags)
-    if (IsRegionalIndicator(startCP) &&
-        clusterEnd < value.length &&
-        IsRegionalIndicator(value.codePointAt(clusterEnd))) {
-        clusterEnd += CodePointLength(value.codePointAt(clusterEnd));
-    }
-    return clusterEnd;
-}
-// --------------------------------------------------------------------------
-// IsGraphemeCodePoint
-// --------------------------------------------------------------------------
-function IsGraphemeCodePoint(value) {
-    return ((value >= 0x0300) && ( // above special range
-    IsHighSurrogate(value) ||
-        IsCombiningMark(value) ||
-        IsVariationSelector(value) ||
-        IsZeroWidthJoiner(value)));
-}
-// --------------------------------------------------------------------------
-// GraphemeCount
-// --------------------------------------------------------------------------
-/** Returns the number of grapheme clusters in a string */
-export function GraphemeCount(value) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        count++;
-    }
-    return count;
-}
-// --------------------------------------------------------------------------
-// IsMinLengthSegmented
-// --------------------------------------------------------------------------
-/** Checks if a string has at least a minimum number of grapheme clusters */
-function IsMinLengthSegmented(value, minLength) {
-    // if (minLength === 0) return true // 0-length (unreachable)
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        if ((++count) >= minLength)
-            return true;
-    }
-    return false;
-}
-// --------------------------------------------------------------------------
-// IsMaxLengthSegmented
-// --------------------------------------------------------------------------
-/** Checks if a string has at most a maximum number of grapheme clusters */
-function IsMaxLengthSegmented(value, maxLength) {
-    let count = 0;
-    let index = 0;
-    while (index < value.length) {
-        index = NextGraphemeClusterIndex(value, index);
-        if ((++count) > maxLength)
-            return false;
-    }
-    return true;
-}
-// --------------------------------------------------------------------------
-// IsMinLengthFast
-// --------------------------------------------------------------------------
-/** Fast check for minimum grapheme length, falls back to full check if needed */
-export function IsMinLength(value, minLength) {
-    if (minLength === 0)
-        return true; // 0-length
-    if (value.length < minLength)
-        return false; // length is upper bound on grapheme count
-    let index = 0;
-    while (true) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMinLengthSegmented(value, minLength);
-        }
-        if ((++index) >= minLength)
-            return true;
-    }
-}
-// --------------------------------------------------------------------------
-// IsMaxLengthFast
-// --------------------------------------------------------------------------
-/** Fast check for maximum grapheme length, falls back to full check if needed */
-export function IsMaxLength(value, maxLength) {
-    if (value.length <= maxLength)
-        return true; // length is upper bound on grapheme count
-    let index = 0;
-    while (true) {
-        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
-            return IsMaxLengthSegmented(value, maxLength);
-        }
-        if ((++index) > maxLength)
-            return false;
-    }
-}

package/node_modules/typebox/build/index.d.mts

@@ -1,8 +0,0 @@
-export * from './type/action/index.mjs';
-export * from './type/engine/index.mjs';
-export * from './type/extends/index.mjs';
-export * from './type/script/index.mjs';
-export * from './type/types/index.mjs';
-export * as Type from './typebox.mjs';
-import * as Type from './typebox.mjs';
-export default Type;

package/node_modules/typebox/build/index.mjs

@@ -1,14 +0,0 @@
-// ------------------------------------------------------------------
-// Standard
-// ------------------------------------------------------------------
-export * from './type/action/index.mjs';
-export * from './type/engine/index.mjs';
-export * from './type/extends/index.mjs';
-export * from './type/script/index.mjs';
-export * from './type/types/index.mjs';
-// ------------------------------------------------------------------
-// TypeBox
-// ------------------------------------------------------------------
-export * as Type from './typebox.mjs';
-import * as Type from './typebox.mjs';
-export default Type;

package/node_modules/typebox/build/schema/build.d.mts

@@ -1,39 +0,0 @@
-import * as Engine from './engine/index.mjs';
-import * as Schema from './types/index.mjs';
-export type CheckFunction = (value: unknown) => boolean;
-export declare class EvaluateResult {
-    private readonly isAccelerated;
-    private readonly code;
-    private readonly check;
-    constructor(isAccelerated: boolean, code: string, check: CheckFunction);
-    IsAccelerated(): boolean;
-    Code(): string;
-    Check(value: unknown): boolean;
-}
-export declare class BuildResult {
-    private readonly context;
-    private readonly schema;
-    private readonly external;
-    private readonly functions;
-    private readonly entry;
-    private readonly useUnevaluated;
-    constructor(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema, external: Engine.TExternal, functions: string[], entry: string, useUnevaluated: boolean);
-    /** Returns the Context used for this build */
-    Context(): Record<PropertyKey, Schema.XSchema>;
-    /** Returns the Schema used for this build */
-    Schema(): Schema.XSchema;
-    /** Returns true if this build requires a Unevaluated context */
-    UseUnevaluated(): boolean;
-    /** Returns external variables */
-    External(): Engine.TExternal;
-    /** Returns check functions */
-    Functions(): string[];
-    /** Return entry function call. */
-    Entry(): string;
-    /** Evaluates the build into a validation function */
-    Evaluate(): EvaluateResult;
-}
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(schema: Schema.XSchema): BuildResult;
-/** Builds a schema into a optimized runtime validator */
-export declare function Build(context: Record<PropertyKey, Schema.XSchema>, schema: Schema.XSchema): BuildResult;