@xfey/tutti 0.1.46 → 0.1.47

package/node_modules/@sinclair/typebox/build/cjs/value/transform/encode.d.ts

@@ -1,23 +0,0 @@
-import { TypeBoxError } from '../../type/error/index';
-import { ValueError } from '../../errors/index';
-import type { TSchema } from '../../type/schema/index';
-export declare class TransformEncodeCheckError extends TypeBoxError {
-    readonly schema: TSchema;
-    readonly value: unknown;
-    readonly error: ValueError;
-    constructor(schema: TSchema, value: unknown, error: ValueError);
-}
-export declare class TransformEncodeError extends TypeBoxError {
-    readonly schema: TSchema;
-    readonly path: string;
-    readonly value: unknown;
-    readonly error: Error;
-    constructor(schema: TSchema, path: string, value: unknown, error: Error);
-}
-/**
- * `[Internal]` Encodes the value and returns the result. This function expects the
- * caller to pass a statically checked value. This function does not check the encoded
- * result, meaning the result should be passed to `Check` before use. Refer to the
- * `Value.Encode()` function for implementation details.
- */
-export declare function TransformEncode(schema: TSchema, references: TSchema[], value: unknown): unknown;

package/node_modules/@sinclair/typebox/build/cjs/value/transform/encode.js

@@ -1,225 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransformEncodeError = exports.TransformEncodeCheckError = void 0;
-exports.TransformEncode = TransformEncode;
-const policy_1 = require("../../system/policy");
-const index_1 = require("../../type/symbols/index");
-const index_2 = require("../../type/error/index");
-const index_3 = require("../../type/keyof/index");
-const index_4 = require("../deref/index");
-const index_5 = require("../check/index");
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-const index_6 = require("../guard/index");
-// ------------------------------------------------------------------
-// KindGuard
-// ------------------------------------------------------------------
-const kind_1 = require("../../type/guard/kind");
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-// prettier-ignore
-class TransformEncodeCheckError extends index_2.TypeBoxError {
-    constructor(schema, value, error) {
-        super(`The encoded value does not match the expected schema`);
-        this.schema = schema;
-        this.value = value;
-        this.error = error;
-    }
-}
-exports.TransformEncodeCheckError = TransformEncodeCheckError;
-// prettier-ignore
-class TransformEncodeError extends index_2.TypeBoxError {
-    constructor(schema, path, value, error) {
-        super(`${error instanceof Error ? error.message : 'Unknown error'}`);
-        this.schema = schema;
-        this.path = path;
-        this.value = value;
-        this.error = error;
-    }
-}
-exports.TransformEncodeError = TransformEncodeError;
-// ------------------------------------------------------------------
-// Encode
-// ------------------------------------------------------------------
-// prettier-ignore
-function Default(schema, path, value) {
-    try {
-        return (0, kind_1.IsTransform)(schema) ? schema[index_1.TransformKind].Encode(value) : value;
-    }
-    catch (error) {
-        throw new TransformEncodeError(schema, path, value, error);
-    }
-}
-// prettier-ignore
-function FromArray(schema, references, path, value) {
-    const defaulted = Default(schema, path, value);
-    return (0, index_6.IsArray)(defaulted)
-        ? defaulted.map((value, index) => Visit(schema.items, references, `${path}/${index}`, value))
-        : defaulted;
-}
-// prettier-ignore
-function FromImport(schema, references, path, value) {
-    const additional = globalThis.Object.values(schema.$defs);
-    const target = schema.$defs[schema.$ref];
-    const result = Default(schema, path, value);
-    return Visit(target, [...references, ...additional], path, result);
-}
-// prettier-ignore
-function FromIntersect(schema, references, path, value) {
-    const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsObject)(value) || (0, index_6.IsValueType)(value))
-        return defaulted;
-    const knownEntries = (0, index_3.KeyOfPropertyEntries)(schema);
-    const knownKeys = knownEntries.map(entry => entry[0]);
-    const knownProperties = { ...defaulted };
-    for (const [knownKey, knownSchema] of knownEntries)
-        if (knownKey in knownProperties) {
-            knownProperties[knownKey] = Visit(knownSchema, references, `${path}/${knownKey}`, knownProperties[knownKey]);
-        }
-    if (!(0, kind_1.IsTransform)(schema.unevaluatedProperties)) {
-        return knownProperties;
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const unevaluatedProperties = schema.unevaluatedProperties;
-    const properties = { ...knownProperties };
-    for (const key of unknownKeys)
-        if (!knownKeys.includes(key)) {
-            properties[key] = Default(unevaluatedProperties, `${path}/${key}`, properties[key]);
-        }
-    return properties;
-}
-// prettier-ignore
-function FromNot(schema, references, path, value) {
-    return Default(schema.not, path, Default(schema, path, value));
-}
-// prettier-ignore
-function FromObject(schema, references, path, value) {
-    const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsObject)(defaulted))
-        return defaulted;
-    const knownKeys = (0, index_3.KeyOfPropertyKeys)(schema);
-    const knownProperties = { ...defaulted };
-    for (const key of knownKeys) {
-        if (!(0, index_6.HasPropertyKey)(knownProperties, key))
-            continue;
-        // if the property value is undefined, but the target is not, nor does it satisfy exact optional 
-        // property policy, then we need to continue. This is a special case for optional property handling 
-        // where a transforms wrapped in a optional modifiers should not run.
-        if ((0, index_6.IsUndefined)(knownProperties[key]) && (!(0, kind_1.IsUndefined)(schema.properties[key]) ||
-            policy_1.TypeSystemPolicy.IsExactOptionalProperty(knownProperties, key)))
-            continue;
-        // encode property
-        knownProperties[key] = Visit(schema.properties[key], references, `${path}/${key}`, knownProperties[key]);
-    }
-    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
-        return knownProperties;
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    const properties = { ...knownProperties };
-    for (const key of unknownKeys)
-        if (!knownKeys.includes(key)) {
-            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
-        }
-    return properties;
-}
-// prettier-ignore
-function FromRecord(schema, references, path, value) {
-    const defaulted = Default(schema, path, value);
-    if (!(0, index_6.IsObject)(value))
-        return defaulted;
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-    const knownKeys = new RegExp(pattern);
-    const knownProperties = { ...defaulted };
-    for (const key of Object.getOwnPropertyNames(value))
-        if (knownKeys.test(key)) {
-            knownProperties[key] = Visit(schema.patternProperties[pattern], references, `${path}/${key}`, knownProperties[key]);
-        }
-    if (!(0, kind_1.IsSchema)(schema.additionalProperties)) {
-        return knownProperties;
-    }
-    const unknownKeys = Object.getOwnPropertyNames(knownProperties);
-    const additionalProperties = schema.additionalProperties;
-    const properties = { ...knownProperties };
-    for (const key of unknownKeys)
-        if (!knownKeys.test(key)) {
-            properties[key] = Default(additionalProperties, `${path}/${key}`, properties[key]);
-        }
-    return properties;
-}
-// prettier-ignore
-function FromRef(schema, references, path, value) {
-    const target = (0, index_4.Deref)(schema, references);
-    const resolved = Visit(target, references, path, value);
-    return Default(schema, path, resolved);
-}
-// prettier-ignore
-function FromThis(schema, references, path, value) {
-    const target = (0, index_4.Deref)(schema, references);
-    const resolved = Visit(target, references, path, value);
-    return Default(schema, path, resolved);
-}
-// prettier-ignore
-function FromTuple(schema, references, path, value) {
-    const value1 = Default(schema, path, value);
-    return (0, index_6.IsArray)(schema.items) ? schema.items.map((schema, index) => Visit(schema, references, `${path}/${index}`, value1[index])) : [];
-}
-// prettier-ignore
-function FromUnion(schema, references, path, value) {
-    // test value against union variants
-    for (const subschema of schema.anyOf) {
-        if (!(0, index_5.Check)(subschema, references, value))
-            continue;
-        const value1 = Visit(subschema, references, path, value);
-        return Default(schema, path, value1);
-    }
-    // test transformed value against union variants
-    for (const subschema of schema.anyOf) {
-        const value1 = Visit(subschema, references, path, value);
-        if (!(0, index_5.Check)(schema, references, value1))
-            continue;
-        return Default(schema, path, value1);
-    }
-    return Default(schema, path, value);
-}
-// prettier-ignore
-function Visit(schema, references, path, value) {
-    const references_ = (0, index_4.Pushref)(schema, references);
-    const schema_ = schema;
-    switch (schema[index_1.Kind]) {
-        case 'Array':
-            return FromArray(schema_, references_, path, value);
-        case 'Import':
-            return FromImport(schema_, references_, path, value);
-        case 'Intersect':
-            return FromIntersect(schema_, references_, path, value);
-        case 'Not':
-            return FromNot(schema_, references_, path, value);
-        case 'Object':
-            return FromObject(schema_, references_, path, value);
-        case 'Record':
-            return FromRecord(schema_, references_, path, value);
-        case 'Ref':
-            return FromRef(schema_, references_, path, value);
-        case 'This':
-            return FromThis(schema_, references_, path, value);
-        case 'Tuple':
-            return FromTuple(schema_, references_, path, value);
-        case 'Union':
-            return FromUnion(schema_, references_, path, value);
-        default:
-            return Default(schema_, path, value);
-    }
-}
-/**
- * `[Internal]` Encodes the value and returns the result. This function expects the
- * caller to pass a statically checked value. This function does not check the encoded
- * result, meaning the result should be passed to `Check` before use. Refer to the
- * `Value.Encode()` function for implementation details.
- */
-function TransformEncode(schema, references, value) {
-    return Visit(schema, references, '', value);
-}

package/node_modules/@sinclair/typebox/build/cjs/value/transform/has.d.ts

@@ -1,3 +0,0 @@
-import type { TSchema } from '../../type/schema/index';
-/** Returns true if this schema contains a transform codec */
-export declare function HasTransform(schema: TSchema, references: TSchema[]): boolean;

package/node_modules/@sinclair/typebox/build/cjs/value/transform/has.js

@@ -1,133 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HasTransform = HasTransform;
-const index_1 = require("../deref/index");
-const index_2 = require("../../type/symbols/index");
-// ------------------------------------------------------------------
-// KindGuard
-// ------------------------------------------------------------------
-const kind_1 = require("../../type/guard/kind");
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-const index_3 = require("../guard/index");
-// prettier-ignore
-function FromArray(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
-}
-// prettier-ignore
-function FromAsyncIterator(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
-}
-// prettier-ignore
-function FromConstructor(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
-}
-// prettier-ignore
-function FromFunction(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.returns, references) || schema.parameters.some((schema) => Visit(schema, references));
-}
-// prettier-ignore
-function FromIntersect(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || (0, kind_1.IsTransform)(schema.unevaluatedProperties) || schema.allOf.some((schema) => Visit(schema, references));
-}
-// prettier-ignore
-function FromImport(schema, references) {
-    const additional = globalThis.Object.getOwnPropertyNames(schema.$defs).reduce((result, key) => [...result, schema.$defs[key]], []);
-    const target = schema.$defs[schema.$ref];
-    return (0, kind_1.IsTransform)(schema) || Visit(target, [...additional, ...references]);
-}
-// prettier-ignore
-function FromIterator(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.items, references);
-}
-// prettier-ignore
-function FromNot(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.not, references);
-}
-// prettier-ignore
-function FromObject(schema, references) {
-    return ((0, kind_1.IsTransform)(schema) ||
-        Object.values(schema.properties).some((schema) => Visit(schema, references)) ||
-        ((0, kind_1.IsSchema)(schema.additionalProperties) && Visit(schema.additionalProperties, references)));
-}
-// prettier-ignore
-function FromPromise(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || Visit(schema.item, references);
-}
-// prettier-ignore
-function FromRecord(schema, references) {
-    const pattern = Object.getOwnPropertyNames(schema.patternProperties)[0];
-    const property = schema.patternProperties[pattern];
-    return (0, kind_1.IsTransform)(schema) || Visit(property, references) || ((0, kind_1.IsSchema)(schema.additionalProperties) && (0, kind_1.IsTransform)(schema.additionalProperties));
-}
-// prettier-ignore
-function FromRef(schema, references) {
-    if ((0, kind_1.IsTransform)(schema))
-        return true;
-    return Visit((0, index_1.Deref)(schema, references), references);
-}
-// prettier-ignore
-function FromThis(schema, references) {
-    if ((0, kind_1.IsTransform)(schema))
-        return true;
-    return Visit((0, index_1.Deref)(schema, references), references);
-}
-// prettier-ignore
-function FromTuple(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || (!(0, index_3.IsUndefined)(schema.items) && schema.items.some((schema) => Visit(schema, references)));
-}
-// prettier-ignore
-function FromUnion(schema, references) {
-    return (0, kind_1.IsTransform)(schema) || schema.anyOf.some((schema) => Visit(schema, references));
-}
-// prettier-ignore
-function Visit(schema, references) {
-    const references_ = (0, index_1.Pushref)(schema, references);
-    const schema_ = schema;
-    if (schema.$id && visited.has(schema.$id))
-        return false;
-    if (schema.$id)
-        visited.add(schema.$id);
-    switch (schema[index_2.Kind]) {
-        case 'Array':
-            return FromArray(schema_, references_);
-        case 'AsyncIterator':
-            return FromAsyncIterator(schema_, references_);
-        case 'Constructor':
-            return FromConstructor(schema_, references_);
-        case 'Function':
-            return FromFunction(schema_, references_);
-        case 'Import':
-            return FromImport(schema_, references_);
-        case 'Intersect':
-            return FromIntersect(schema_, references_);
-        case 'Iterator':
-            return FromIterator(schema_, references_);
-        case 'Not':
-            return FromNot(schema_, references_);
-        case 'Object':
-            return FromObject(schema_, references_);
-        case 'Promise':
-            return FromPromise(schema_, references_);
-        case 'Record':
-            return FromRecord(schema_, references_);
-        case 'Ref':
-            return FromRef(schema_, references_);
-        case 'This':
-            return FromThis(schema_, references_);
-        case 'Tuple':
-            return FromTuple(schema_, references_);
-        case 'Union':
-            return FromUnion(schema_, references_);
-        default:
-            return (0, kind_1.IsTransform)(schema);
-    }
-}
-const visited = new Set();
-/** Returns true if this schema contains a transform codec */
-function HasTransform(schema, references) {
-    visited.clear();
-    return Visit(schema, references);
-}

package/node_modules/@sinclair/typebox/build/cjs/value/transform/index.d.ts

@@ -1,3 +0,0 @@
-export * from './decode';
-export * from './encode';
-export * from './has';

package/node_modules/@sinclair/typebox/build/cjs/value/transform/index.js

@@ -1,20 +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("./decode"), exports);
-__exportStar(require("./encode"), exports);
-__exportStar(require("./has"), exports);

package/node_modules/@sinclair/typebox/build/cjs/value/value/index.d.ts

@@ -1 +0,0 @@
-export * as Value from './value';

package/node_modules/@sinclair/typebox/build/cjs/value/value/index.js

@@ -1,38 +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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = void 0;
-exports.Value = __importStar(require("./value"));

package/node_modules/@sinclair/typebox/build/cjs/value/value/value.d.ts

@@ -1,16 +0,0 @@
-export { Errors, ValueErrorIterator } from '../../errors/index';
-export { Assert } from '../assert/index';
-export { Cast } from '../cast/index';
-export { Check } from '../check/index';
-export { Clean } from '../clean/index';
-export { Clone } from '../clone/index';
-export { Convert } from '../convert/index';
-export { Create } from '../create/index';
-export { Decode } from '../decode/index';
-export { Default } from '../default/index';
-export { Diff, Patch, Edit } from '../delta/index';
-export { Encode } from '../encode/index';
-export { Equal } from '../equal/index';
-export { Hash } from '../hash/index';
-export { Mutate, type Mutable } from '../mutate/index';
-export { Parse } from '../parse/index';

package/node_modules/@sinclair/typebox/build/cjs/value/value/value.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parse = exports.Mutate = exports.Hash = exports.Equal = exports.Encode = exports.Edit = exports.Patch = exports.Diff = exports.Default = exports.Decode = exports.Create = exports.Convert = exports.Clone = exports.Clean = exports.Check = exports.Cast = exports.Assert = exports.ValueErrorIterator = exports.Errors = void 0;
-var index_1 = require("../../errors/index");
-Object.defineProperty(exports, "Errors", { enumerable: true, get: function () { return index_1.Errors; } });
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-var index_2 = require("../assert/index");
-Object.defineProperty(exports, "Assert", { enumerable: true, get: function () { return index_2.Assert; } });
-var index_3 = require("../cast/index");
-Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return index_3.Cast; } });
-var index_4 = require("../check/index");
-Object.defineProperty(exports, "Check", { enumerable: true, get: function () { return index_4.Check; } });
-var index_5 = require("../clean/index");
-Object.defineProperty(exports, "Clean", { enumerable: true, get: function () { return index_5.Clean; } });
-var index_6 = require("../clone/index");
-Object.defineProperty(exports, "Clone", { enumerable: true, get: function () { return index_6.Clone; } });
-var index_7 = require("../convert/index");
-Object.defineProperty(exports, "Convert", { enumerable: true, get: function () { return index_7.Convert; } });
-var index_8 = require("../create/index");
-Object.defineProperty(exports, "Create", { enumerable: true, get: function () { return index_8.Create; } });
-var index_9 = require("../decode/index");
-Object.defineProperty(exports, "Decode", { enumerable: true, get: function () { return index_9.Decode; } });
-var index_10 = require("../default/index");
-Object.defineProperty(exports, "Default", { enumerable: true, get: function () { return index_10.Default; } });
-var index_11 = require("../delta/index");
-Object.defineProperty(exports, "Diff", { enumerable: true, get: function () { return index_11.Diff; } });
-Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return index_11.Patch; } });
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return index_11.Edit; } });
-var index_12 = require("../encode/index");
-Object.defineProperty(exports, "Encode", { enumerable: true, get: function () { return index_12.Encode; } });
-var index_13 = require("../equal/index");
-Object.defineProperty(exports, "Equal", { enumerable: true, get: function () { return index_13.Equal; } });
-var index_14 = require("../hash/index");
-Object.defineProperty(exports, "Hash", { enumerable: true, get: function () { return index_14.Hash; } });
-var index_15 = require("../mutate/index");
-Object.defineProperty(exports, "Mutate", { enumerable: true, get: function () { return index_15.Mutate; } });
-var index_16 = require("../parse/index");
-Object.defineProperty(exports, "Parse", { enumerable: true, get: function () { return index_16.Parse; } });

package/node_modules/@sinclair/typebox/build/esm/compiler/compiler.d.mts

@@ -1,55 +0,0 @@
-import { ValueErrorIterator } from '../errors/index.mjs';
-import { TypeBoxError } from '../type/error/index.mjs';
-import type { TSchema } from '../type/schema/index.mjs';
-import type { Static, StaticDecode, StaticEncode } from '../type/static/index.mjs';
-export type CheckFunction = (value: unknown) => boolean;
-export declare class TypeCheck<T extends TSchema> {
-    private readonly schema;
-    private readonly references;
-    private readonly checkFunc;
-    private readonly code;
-    private readonly hasTransform;
-    constructor(schema: T, references: TSchema[], checkFunc: CheckFunction, code: string);
-    /** Returns the generated assertion code used to validate this type. */
-    Code(): string;
-    /** Returns the schema type used to validate */
-    Schema(): T;
-    /** Returns reference types used to validate */
-    References(): TSchema[];
-    /** Returns an iterator for each error in this value. */
-    Errors(value: unknown): ValueErrorIterator;
-    /** Returns true if the value matches the compiled type. */
-    Check(value: unknown): value is Static<T>;
-    /** Decodes a value or throws if error */
-    Decode<Static = StaticDecode<T>, Result extends Static = Static>(value: unknown): Result;
-    /** Encodes a value or throws if error */
-    Encode<Static = StaticEncode<T>, Result extends Static = Static>(value: unknown): Result;
-}
-export declare class TypeCompilerUnknownTypeError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare class TypeCompilerTypeGuardError extends TypeBoxError {
-    readonly schema: TSchema;
-    constructor(schema: TSchema);
-}
-export declare namespace Policy {
-    function IsExactOptionalProperty(value: string, key: string, expression: string): string;
-    function IsObjectLike(value: string): string;
-    function IsRecordLike(value: string): string;
-    function IsNumberLike(value: string): string;
-    function IsVoidLike(value: string): string;
-}
-export type TypeCompilerLanguageOption = 'typescript' | 'javascript';
-export interface TypeCompilerCodegenOptions {
-    language?: TypeCompilerLanguageOption;
-}
-/** Compiles Types for Runtime Type Checking */
-export declare namespace TypeCompiler {
-    /** Generates the code used to assert this type and returns it as a string */
-    function Code<T extends TSchema>(schema: T, references: TSchema[], options?: TypeCompilerCodegenOptions): string;
-    /** Generates the code used to assert this type and returns it as a string */
-    function Code<T extends TSchema>(schema: T, options?: TypeCompilerCodegenOptions): string;
-    /** Compiles a TypeBox type for optimal runtime type checking. Types must be valid TypeBox types of TSchema */
-    function Compile<T extends TSchema>(schema: T, references?: TSchema[]): TypeCheck<T>;
-}