typesea 0.1.0

package/dist/plan/schema-predicate.js

@@ -0,0 +1,277 @@
+/**
+ * @file schema-predicate.ts
+ * @brief Schema-specialized predicate kernels for validation plans.
+ */
+import { NumberCheckTag, ObjectModeTag, PresenceTag, SchemaTag, StringCheckTag } from "../kind/index.js";
+import { UUID_PATTERN, resolveLazySchema } from "../schema/index.js";
+import { findDiscriminatedUnionCase, hasObjectKey, isDataPropertyDescriptor, isPlainRecord, readOwnDataProperty } from "../evaluate/shared.js";
+/**
+ * @brief execute schema kernel.
+ */
+export function executeSchemaKernel(schema, value, state, runChild) {
+    switch (schema.tag) {
+        case SchemaTag.Unknown:
+            return true;
+        case SchemaTag.Never:
+            return false;
+        case SchemaTag.String:
+            return isStringSchema(schema, value);
+        case SchemaTag.Number:
+            return isNumberSchema(schema, value);
+        case SchemaTag.BigInt:
+            return typeof value === "bigint";
+        case SchemaTag.Symbol:
+            return typeof value === "symbol";
+        case SchemaTag.Boolean:
+            return typeof value === "boolean";
+        case SchemaTag.Literal:
+            return Object.is(value, schema.value);
+        case SchemaTag.Array:
+            return isArraySchema(schema.item, value, state, runChild);
+        case SchemaTag.Tuple:
+            return isTupleSchema(schema.items, value, state, runChild);
+        case SchemaTag.Record:
+            return isRecordSchema(schema.value, value, state, runChild);
+        case SchemaTag.Object:
+            return isObjectSchema(schema, value, state, runChild);
+        case SchemaTag.Union:
+            return isUnionSchema(schema.options, value, state, runChild);
+        case SchemaTag.Intersection:
+            return runChild(schema.left, value, state) &&
+                runChild(schema.right, value, state);
+        case SchemaTag.Optional:
+        case SchemaTag.Undefinedable:
+            return value === undefined || runChild(schema.inner, value, state);
+        case SchemaTag.Nullable:
+            return value === null || runChild(schema.inner, value, state);
+        case SchemaTag.DiscriminatedUnion:
+            return isDiscriminatedUnionSchema(schema.key, schema.cases, value, state, runChild);
+        case SchemaTag.Brand:
+            return runChild(schema.inner, value, state);
+        case SchemaTag.Lazy:
+            return runChild(resolveLazySchema(schema, state.resolving), value, state);
+        case SchemaTag.Refine:
+            return runChild(schema.inner, value, state) &&
+                isStrictTrue(schema.predicate(value));
+    }
+}
+/**
+ * @brief is string schema.
+ */
+function isStringSchema(schema, value) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            return false;
+        }
+        switch (check.tag) {
+            case StringCheckTag.Min:
+                if (value.length < check.value) {
+                    return false;
+                }
+                break;
+            case StringCheckTag.Max:
+                if (value.length > check.value) {
+                    return false;
+                }
+                break;
+            case StringCheckTag.Regex:
+                check.regex.lastIndex = 0;
+                if (!check.regex.test(value)) {
+                    return false;
+                }
+                check.regex.lastIndex = 0;
+                break;
+            case StringCheckTag.Uuid:
+                UUID_PATTERN.lastIndex = 0;
+                if (!UUID_PATTERN.test(value)) {
+                    return false;
+                }
+                UUID_PATTERN.lastIndex = 0;
+                break;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is number schema.
+ */
+function isNumberSchema(schema, value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return false;
+    }
+    const checks = schema.checks;
+    for (let index = 0; index < checks.length; index += 1) {
+        const check = checks[index];
+        if (check === undefined) {
+            return false;
+        }
+        switch (check.tag) {
+            case NumberCheckTag.Integer:
+                if (!Number.isInteger(value)) {
+                    return false;
+                }
+                break;
+            case NumberCheckTag.Gte:
+                if (value < check.value) {
+                    return false;
+                }
+                break;
+            case NumberCheckTag.Lte:
+                if (value > check.value) {
+                    return false;
+                }
+                break;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is array schema.
+ */
+function isArraySchema(item, value, state, runChild) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const property = readArrayIndexDataProperty(value, index);
+        if (property === null ||
+            !runChild(item, property === undefined ? undefined : property.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is tuple schema.
+ */
+function isTupleSchema(items, value, state, runChild) {
+    if (!Array.isArray(value) || value.length !== items.length) {
+        return false;
+    }
+    for (let index = 0; index < items.length; index += 1) {
+        const item = items[index];
+        const property = readArrayIndexDataProperty(value, index);
+        if (item === undefined ||
+            property === null ||
+            !runChild(item, property === undefined ? undefined : property.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief read array index data property.
+ */
+function readArrayIndexDataProperty(value, index) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+    if (descriptor === undefined) {
+        return undefined;
+    }
+    if (!isDataPropertyDescriptor(descriptor)) {
+        return null;
+    }
+    return descriptor;
+}
+/**
+ * @brief is record schema.
+ */
+function isRecordSchema(item, value, state, runChild) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined) {
+            return false;
+        }
+        const property = readOwnDataProperty(value, key);
+        if (property === undefined || !runChild(item, property.value, state)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is object schema.
+ */
+function isObjectSchema(schema, value, state, runChild) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const record = value;
+    const entries = schema.entries;
+    let allRequired = true;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry === undefined) {
+            return false;
+        }
+        if (entry.presence === PresenceTag.Optional) {
+            allRequired = false;
+        }
+        const property = readOwnDataProperty(record, entry.key);
+        if (property === undefined) {
+            if (entry.presence === PresenceTag.Optional &&
+                !Object.prototype.hasOwnProperty.call(record, entry.key)) {
+                continue;
+            }
+            return false;
+        }
+        if (!runChild(entry.schema, property.value, state)) {
+            return false;
+        }
+    }
+    if (schema.mode === ObjectModeTag.Strict) {
+        if (allRequired) {
+            return Object.getOwnPropertyNames(record).length === entries.length &&
+                Object.getOwnPropertySymbols(record).length === 0;
+        }
+        const keys = Reflect.ownKeys(record);
+        for (let index = 0; index < keys.length; index += 1) {
+            const key = keys[index];
+            if (typeof key !== "string" || !hasObjectKey(schema.keyLookup, key)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * @brief is union schema.
+ */
+function isUnionSchema(options, value, state, runChild) {
+    for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        if (option !== undefined && runChild(option, value, state)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @brief is discriminated union schema.
+ */
+function isDiscriminatedUnionSchema(key, cases, value, state, runChild) {
+    if (!isPlainRecord(value)) {
+        return false;
+    }
+    const discriminantProperty = readOwnDataProperty(value, key);
+    if (discriminantProperty === undefined ||
+        typeof discriminantProperty.value !== "string") {
+        return false;
+    }
+    const selected = findDiscriminatedUnionCase(cases, discriminantProperty.value);
+    return selected !== undefined && runChild(selected, value, state);
+}
+/**
+ * @brief is strict true.
+ */
+function isStrictTrue(value) {
+    return value === true;
+}

package/dist/plan/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @file types.ts
+ * @brief Optimized validation plan contracts.
+ */
+import type { Graph } from "../ir/index.js";
+import type { Schema } from "../schema/index.js";
+/**
+ * @brief validation plan.
+ * @details Binds one immutable schema object to the optimized Sea-of-Nodes graph
+ * that is used by runtime boolean validation and generated predicate emission.
+ * @invariant The graph is already lowered, optimized, validated, and frozen.
+ */
+export interface ValidationPlan {
+    readonly schema: Schema;
+    readonly graph: Graph;
+    readonly tracksRecursion: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/plan/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/plan/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC"}

package/dist/plan/types.js

@@ -0,0 +1,5 @@
+/**
+ * @file types.ts
+ * @brief Optimized validation plan contracts.
+ */
+export {};

package/dist/result/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @brief result.
+ */
+export type Result<TValue, TError> = Ok<TValue> | Err<TError>;
+/**
+ * @brief ok.
+ */
+export interface Ok<TValue> {
+    readonly ok: true;
+    readonly value: TValue;
+}
+/**
+ * @brief err.
+ */
+export interface Err<TError> {
+    readonly ok: false;
+    readonly error: TError;
+}
+/**
+ * @brief ok.
+ */
+export declare function ok<TValue>(value: TValue): Result<TValue, never>;
+/**
+ * @brief err.
+ */
+export declare function err<TError>(error: TError): Result<never, TError>;
+//# sourceMappingURL=index.d.ts.map

package/dist/result/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/result/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,IAC7B,EAAE,CAAC,MAAM,CAAC,GACV,GAAG,CAAC,MAAM,CAAC,CAAC;AAEhB;;GAEG;AACH,MAAM,WAAW,EAAE,CAAC,MAAM;IACxB,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAClB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,GAAG,CAAC,MAAM;IACzB,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,wBAAgB,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAM/D;AAED;;GAEG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,CAMhE"}

package/dist/result/index.js

@@ -0,0 +1,20 @@
+/**
+ * @brief ok.
+ */
+export function ok(value) {
+    const result = {
+        ok: true,
+        value
+    };
+    return Object.freeze(result);
+}
+/**
+ * @brief err.
+ */
+export function err(error) {
+    const result = {
+        ok: false,
+        error
+    };
+    return Object.freeze(result);
+}

package/dist/schema/common.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @file schema/common.ts
+ * @brief Private schema shape predicates.
+ */
+import type { ObjectKeyLookup } from "./types.js";
+/**
+ * @brief is record.
+ */
+export declare function isRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+/**
+ * @brief is unknown array.
+ */
+export declare function isUnknownArray(value: unknown): value is readonly unknown[];
+/**
+ * @brief is plain reg exp.
+ */
+export declare function isPlainRegExp(value: unknown): value is RegExp;
+/**
+ * @brief is string array.
+ */
+export declare function isStringArray(value: unknown): value is readonly string[];
+/**
+ * @brief is object key lookup.
+ */
+export declare function isObjectKeyLookup(value: unknown, keys: readonly string[]): value is ObjectKeyLookup;
+/**
+ * @brief includes string.
+ */
+export declare function includesString(values: readonly string[], value: string): boolean;
+//# sourceMappingURL=common.d.ts.map

package/dist/schema/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/schema/common.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAKnF;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,OAAO,EAAE,CAE1E;AAyBD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAO7D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,MAAM,EAAE,CAUxE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,KAAK,IAAI,eAAe,CAqB1B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAOhF"}

package/dist/schema/common.js

@@ -0,0 +1,102 @@
+/**
+ * @file schema/common.ts
+ * @brief Private schema shape predicates.
+ */
+/**
+ * @brief is record.
+ */
+export function isRecord(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        hasOnlyDataProperties(value);
+}
+/**
+ * @brief is unknown array.
+ */
+export function isUnknownArray(value) {
+    return Array.isArray(value) && hasOnlyDataProperties(value);
+}
+/**
+ * @brief has only data properties.
+ * @details Rejects accessor descriptors before schema internals read fields by key.
+ * @returns True when every own property is backed by a data slot.
+ */
+function hasOnlyDataProperties(value) {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const descriptorMap = descriptors;
+    const keys = Reflect.ownKeys(descriptors);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined) {
+            continue;
+        }
+        const descriptor = descriptorMap[key];
+        if (descriptor === undefined ||
+            !Object.prototype.hasOwnProperty.call(descriptor, "value")) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is plain reg exp.
+ */
+export function isPlainRegExp(value) {
+    return value instanceof RegExp &&
+        Object.getPrototypeOf(value) === RegExp.prototype &&
+        !Object.prototype.hasOwnProperty.call(value, "exec") &&
+        !Object.prototype.hasOwnProperty.call(value, "test") &&
+        !Object.prototype.hasOwnProperty.call(value, "source") &&
+        !Object.prototype.hasOwnProperty.call(value, "flags");
+}
+/**
+ * @brief is string array.
+ */
+export function isStringArray(value) {
+    if (!isUnknownArray(value)) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (typeof value[index] !== "string") {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief is object key lookup.
+ */
+export function isObjectKeyLookup(value, keys) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const present = Object.keys(value);
+    if (present.length !== keys.length) {
+        return false;
+    }
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined || value[key] !== true) {
+            return false;
+        }
+    }
+    for (let index = 0; index < present.length; index += 1) {
+        const key = present[index];
+        if (key === undefined || !includesString(keys, key)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @brief includes string.
+ */
+export function includesString(values, value) {
+    for (let index = 0; index < values.length; index += 1) {
+        if (values[index] === value) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/schema/freeze.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @file schema/freeze.ts
+ * @brief Schema freezing and collection hardening.
+ */
+import type { Schema } from "./types.js";
+/**
+ * @brief freeze schema.
+ */
+export declare function freezeSchema(schema: Schema): Schema;
+//# sourceMappingURL=freeze.d.ts.map

package/dist/schema/freeze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"freeze.d.ts","sourceRoot":"","sources":["../../src/schema/freeze.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAGV,MAAM,EAGP,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/schema/freeze.js

@@ -0,0 +1,163 @@
+/**
+ * @file schema/freeze.ts
+ * @brief Schema freezing and collection hardening.
+ */
+import { SchemaTag, StringCheckTag } from "../kind/index.js";
+import { isPlainRegExp } from "./common.js";
+/**
+ * @brief freeze schema.
+ */
+export function freezeSchema(schema) {
+    return freezeSchemaInner(schema, new WeakSet());
+}
+/**
+ * @brief freeze schema inner.
+ */
+function freezeSchemaInner(schema, frozen) {
+    if (frozen.has(schema)) {
+        return schema;
+    }
+    frozen.add(schema);
+    switch (schema.tag) {
+        case SchemaTag.String:
+            freezeStringChecks(schema.checks, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Number:
+            freezeArray(schema.checks, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Array:
+            freezeSchemaInner(schema.item, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Tuple:
+            freezeSchemaArray(schema.items, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Record:
+            freezeSchemaInner(schema.value, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Object:
+            freezeObjectEntries(schema.entries, frozen);
+            Object.freeze(schema.keys);
+            Object.freeze(schema.keyLookup);
+            return Object.freeze(schema);
+        case SchemaTag.Union:
+            freezeSchemaArray(schema.options, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Intersection:
+            freezeSchemaInner(schema.left, frozen);
+            freezeSchemaInner(schema.right, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Optional:
+        case SchemaTag.Undefinedable:
+        case SchemaTag.Nullable:
+            freezeSchemaInner(schema.inner, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.DiscriminatedUnion:
+            freezeDiscriminatedUnionCases(schema.cases, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Brand:
+            freezeSchemaInner(schema.inner, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Refine:
+            freezeSchemaInner(schema.inner, frozen);
+            return Object.freeze(schema);
+        case SchemaTag.Unknown:
+        case SchemaTag.Never:
+        case SchemaTag.BigInt:
+        case SchemaTag.Symbol:
+        case SchemaTag.Boolean:
+        case SchemaTag.Literal:
+        case SchemaTag.Lazy:
+            return Object.freeze(schema);
+    }
+}
+/**
+ * @brief freeze array.
+ */
+function freezeArray(values, frozen) {
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value !== undefined && !frozen.has(value)) {
+            frozen.add(value);
+            Object.freeze(value);
+        }
+    }
+    Object.freeze(values);
+}
+/**
+ * @brief freeze string checks.
+ */
+function freezeStringChecks(values, frozen) {
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value === undefined || frozen.has(value)) {
+            continue;
+        }
+        if (value.tag === StringCheckTag.Regex) {
+            freezeRegexCheck(value);
+        }
+        frozen.add(value);
+        Object.freeze(value);
+    }
+    Object.freeze(values);
+}
+/**
+ * @brief freeze regex check.
+ */
+function freezeRegexCheck(check) {
+    const regex = check.regex;
+    if (!isPlainRegExp(regex)) {
+        throw new TypeError("regex check must use a plain RegExp");
+    }
+    if (Object.isFrozen(check)) {
+        if (Object.isExtensible(regex)) {
+            throw new TypeError("frozen regex check must contain a non-extensible RegExp");
+        }
+        return;
+    }
+    const cloned = new RegExp(regex.source, regex.flags);
+    Object.preventExtensions(cloned);
+    Object.defineProperty(check, "regex", {
+        configurable: false,
+        enumerable: true,
+        value: cloned,
+        writable: false
+    });
+}
+/**
+ * @brief freeze schema array.
+ */
+function freezeSchemaArray(values, frozen) {
+    for (let index = 0; index < values.length; index += 1) {
+        const value = values[index];
+        if (value !== undefined) {
+            freezeSchemaInner(value, frozen);
+        }
+    }
+    Object.freeze(values);
+}
+/**
+ * @brief freeze object entries.
+ */
+function freezeObjectEntries(entries, frozen) {
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (entry !== undefined) {
+            freezeSchemaInner(entry.schema, frozen);
+            Object.freeze(entry);
+        }
+    }
+    Object.freeze(entries);
+}
+/**
+ * @brief freeze discriminated union cases.
+ */
+function freezeDiscriminatedUnionCases(cases, frozen) {
+    for (let index = 0; index < cases.length; index += 1) {
+        const unionCase = cases[index];
+        if (unionCase !== undefined) {
+            freezeSchemaInner(unionCase.schema, frozen);
+            Object.freeze(unionCase);
+        }
+    }
+    Object.freeze(cases);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file schema/index.ts
+ * @brief Schema module aggregate.
+ */
+export type { ArraySchema, BigIntSchema, BooleanSchema, BrandSchema, DiscriminatedUnionCase, DiscriminatedUnionSchema, IntersectionSchema, LazySchema, LiteralSchema, LiteralValue, NeverSchema, NullableSchema, NumberCheck, NumberGteCheck, NumberIntegerCheck, NumberLteCheck, NumberSchema, ObjectEntry, ObjectKeyLookup, ObjectSchema, OptionalSchema, RecordSchema, RefineSchema, Schema, StringCheck, StringMaxCheck, StringMinCheck, StringRegexCheck, StringSchema, StringUuidCheck, SymbolSchema, TupleSchema, UndefinedableSchema, UnionSchema, UnknownSchema } from "./types.js";
+export { UUID_PATTERN } from "./types.js";
+export { isLiteralValue } from "./literal.js";
+export { isSchemaValue } from "./validate.js";
+export { freezeSchema } from "./freeze.js";
+export { resolveLazySchema } from "./lazy.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,YAAY,EACV,WAAW,EACX,YAAY,EACZ,aAAa,EACb,WAAW,EACX,sBAAsB,EACtB,wBAAwB,EACxB,kBAAkB,EAClB,UAAU,EACV,aAAa,EACb,YAAY,EACZ,WAAW,EACX,cAAc,EACd,WAAW,EACX,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,WAAW,EACX,eAAe,EACf,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,MAAM,EACN,WAAW,EACX,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC"}