@daniel156161/prism 0.2.76 → 0.2.78

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/guard.d.mts

@@ -0,0 +1,65 @@
+/** 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 all elements from offset satisfy 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 all elements from offset satisfy the callback, visiting every element regardless of failure */
+export declare function EveryAll<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean;
+/** 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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/guard.mjs

@@ -0,0 +1,212 @@
+// 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.IsMaxLengthFast(value, length);
+}
+/** Returns true if the string has at least the given number of graphemes */
+export function IsMinLength(value, length) {
+    return String.IsMinLengthFast(value, length);
+}
+// --------------------------------------------------------------------------
+// Array
+// --------------------------------------------------------------------------
+/** Returns true if all elements from offset satisfy the callback, short-circuiting on the first failure */
+export function Every(value, offset, callback) {
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            return false;
+    }
+    return true;
+}
+/** Returns true if all elements from offset satisfy the callback, visiting every element regardless of failure */
+export function EveryAll(value, offset, callback) {
+    let result = true;
+    for (let index = offset; index < value.length; index++) {
+        if (!callback(value[index], index))
+            result = false;
+    }
+    return result;
+}
+/** 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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/index.d.mts

@@ -0,0 +1,6 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/index.mjs

@@ -0,0 +1,6 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/native.d.mts

@@ -0,0 +1,20 @@
+/** 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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/native.mjs

@@ -0,0 +1,60 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/guard/string.d.mts

@@ -0,0 +1,6 @@
+/** 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 IsMinLengthFast(value: string, minLength: number): boolean;
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export declare function IsMaxLengthFast(value: string, maxLength: number): boolean;

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/guard/string.mjs

@@ -0,0 +1,176 @@
+// --------------------------------------------------------------------------
+// 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 && value[clusterEnd] === '\u200D') {
+        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 (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;
+}
+// --------------------------------------------------------------------------
+// IsMinLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at least a minimum number of grapheme clusters */
+function IsMinLength(value, minLength) {
+    // ----------------------------------------------------------------
+    // Inaccessible via public interface (review)
+    //
+    // deno-coverage-ignore-start
+    // ----------------------------------------------------------------
+    if (minLength === 0)
+        return true; // 0-length
+    // deno-coverage-ignore-stop
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLength
+// --------------------------------------------------------------------------
+/** Checks if a string has at most a maximum number of grapheme clusters */
+function IsMaxLength(value, maxLength) {
+    let count = 0;
+    let index = 0;
+    while (index < value.length) {
+        index = NextGraphemeClusterIndex(value, index);
+        count++;
+        if (count > maxLength)
+            return false;
+    }
+    return true;
+}
+// --------------------------------------------------------------------------
+// IsMinLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for minimum grapheme length, falls back to full check if needed */
+export function IsMinLengthFast(value, minLength) {
+    if (minLength === 0)
+        return true; // 0-length
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMinLength(value, minLength);
+        }
+        index++;
+        if (index >= minLength)
+            return true;
+    }
+    return false;
+}
+// --------------------------------------------------------------------------
+// IsMaxLengthFast
+// --------------------------------------------------------------------------
+/** Fast check for maximum grapheme length, falls back to full check if needed */
+export function IsMaxLengthFast(value, maxLength) {
+    let index = 0;
+    while (index < value.length) {
+        if (IsGraphemeCodePoint(value.charCodeAt(index))) {
+            return IsMaxLength(value, maxLength);
+        }
+        index++;
+        if (index > maxLength)
+            return false;
+    }
+    return true;
+}

package/node_modules/@earendil-works/pi-protocol/node_modules/typebox/build/index.d.mts

@@ -0,0 +1,8 @@
+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/@earendil-works/pi-protocol/node_modules/typebox/build/index.mjs

@@ -0,0 +1,14 @@
+// ------------------------------------------------------------------
+// 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/@earendil-works/pi-protocol/node_modules/typebox/build/schema/build.d.mts

@@ -0,0 +1,39 @@
+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;