typebox 0.0.1 → 1.0.0

package/build/schema/engine/minimum.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMinimum(context, schema, value) {
+    return E.IsGreaterEqualThan(value, E.Constant(schema.minimum));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMinimum(context, schema, value) {
+    return G.IsGreaterEqualThan(value, schema.minimum);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMinimum(context, schemaPath, instancePath, schema, value) {
+    return CheckMinimum(context, schema, value) || context.AddError({
+        keyword: 'minimum',
+        schemaPath: `${schemaPath}/minimum`,
+        instancePath,
+        params: { comparison: '>=', limit: schema.minimum }
+    });
+}

package/build/schema/engine/multipleOf.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildMultipleOf(context: BuildContext, schema: S.XMultipleOf, value: string): string;
+export declare function CheckMultipleOf(context: CheckContext, schema: S.XMultipleOf, value: number | bigint): boolean;
+export declare function ErrorMultipleOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XMultipleOf, value: number | bigint): boolean;

package/build/schema/engine/multipleOf.mjs

@@ -0,0 +1,25 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildMultipleOf(context, schema, value) {
+    return E.MultipleOf(value, E.Constant(schema.multipleOf));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckMultipleOf(context, schema, value) {
+    return G.IsMultipleOf(value, schema.multipleOf);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorMultipleOf(context, schemaPath, instancePath, schema, value) {
+    return CheckMultipleOf(context, schema, value) || context.AddError({
+        keyword: 'multipleOf',
+        schemaPath: `${schemaPath}/multipleOf`,
+        instancePath,
+        params: { multipleOf: schema.multipleOf }
+    });
+}

package/build/schema/engine/not.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildNot(context: BuildContext, schema: S.XNot, value: string): string;
+export declare function CheckNot(context: CheckContext, schema: S.XNot, value: unknown): boolean;
+export declare function ErrorNot(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XNot, value: unknown): boolean;

package/build/schema/engine/not.mjs

@@ -0,0 +1,36 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema } from './schema.mjs';
+import { Reducer } from './_reducer.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildNotUnevaluated(context, schema, value) {
+    return Reducer(context, [schema.not], value, E.Not(E.IsEqual(E.Member('results', 'length'), E.Constant(1))));
+}
+function BuildNotFast(context, schema, value) {
+    return E.Not(BuildSchema(context, schema.not, value));
+}
+export function BuildNot(context, schema, value) {
+    return context.UseUnevaluated() ? BuildNotUnevaluated(context, schema, value) : BuildNotFast(context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckNot(context, schema, value) {
+    const condition = context.Clone();
+    const isSchema = !CheckSchema(condition, schema.not, value);
+    const isNot = isSchema && context.Merge([condition]);
+    return isNot;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorNot(context, schemaPath, instancePath, schema, value) {
+    return CheckNot(context, schema, value) || context.AddError({
+        keyword: 'not',
+        schemaPath: `${schemaPath}/not`,
+        instancePath,
+        params: {},
+    });
+}

package/build/schema/engine/oneOf.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildOneOf(context: BuildContext, schema: S.XOneOf, value: string): string;
+export declare function CheckOneOf(context: CheckContext, schema: S.XOneOf, value: unknown): boolean;
+export declare function ErrorOneOf(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XOneOf, value: unknown): boolean;

package/build/schema/engine/oneOf.mjs

@@ -0,0 +1,58 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+import { Reducer } from './_reducer.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+function BuildOneOfUnevaluated(context, schema, value) {
+    return Reducer(context, schema.oneOf, value, E.IsEqual(E.Member('results', 'length'), E.Constant(1)));
+}
+function BuildOneOfFast(context, schema, value) {
+    const results = E.ArrayLiteral(schema.oneOf.map((schema) => BuildSchema(context, schema, value)));
+    const count = E.Call(E.Member(results, 'reduce'), [
+        E.ArrowFunction(['count', 'result'], E.Ternary(E.IsEqual('result', E.Constant(true)), E.PrefixIncrement('count'), 'count')),
+        E.Constant(0),
+    ]);
+    return E.IsEqual(count, E.Constant(1));
+}
+export function BuildOneOf(context, schema, value) {
+    return context.UseUnevaluated() ? BuildOneOfUnevaluated(context, schema, value) : BuildOneOfFast(context, schema, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckOneOf(context, schema, value) {
+    const passedContexts = schema.oneOf.reduce((result, schema) => {
+        const nextContext = context.Clone();
+        return CheckSchema(nextContext, schema, value) ? [...result, nextContext] : result;
+    }, []);
+    return G.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorOneOf(context, schemaPath, instancePath, schema, value) {
+    const failedContexts = [];
+    const passingSchemas = [];
+    const passedContexts = schema.oneOf.reduce((result, schema, index) => {
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const nextSchemaPath = `${schemaPath}/oneOf/${index}`;
+        const isSchema = ErrorSchema(nextContext, nextSchemaPath, instancePath, schema, value);
+        if (isSchema)
+            passingSchemas.push(index);
+        if (!isSchema)
+            failedContexts.push(nextContext);
+        return isSchema ? [...result, nextContext] : result;
+    }, []);
+    const isOneOf = G.IsEqual(passedContexts.length, 1) && context.Merge(passedContexts);
+    if (!isOneOf && G.IsEqual(passingSchemas.length, 0))
+        failedContexts.forEach(failed => failed.GetErrors().forEach(error => context.AddError(error)));
+    return isOneOf || context.AddError({
+        keyword: 'oneOf',
+        schemaPath: `${schemaPath}/oneOf`,
+        instancePath,
+        params: { passingSchemas },
+    });
+}

package/build/schema/engine/pattern.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildPattern(context: BuildContext, schema: S.XPattern, value: string): string;
+export declare function CheckPattern(context: CheckContext, schema: S.XPattern, value: string): boolean;
+export declare function ErrorPattern(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPattern, value: string): boolean;

package/build/schema/engine/pattern.mjs

@@ -0,0 +1,28 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildPattern(context, schema, value) {
+    const regexp = V.CreateExternalVariable(G.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern);
+    return E.Call(E.Member(regexp, 'test'), [value]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckPattern(context, schema, value) {
+    const regexp = G.IsString(schema.pattern) ? new RegExp(schema.pattern) : schema.pattern;
+    return regexp.test(value);
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorPattern(context, schemaPath, instancePath, schema, value) {
+    return CheckPattern(context, schema, value) || context.AddError({
+        keyword: 'pattern',
+        schemaPath: `${schemaPath}/pattern`,
+        instancePath,
+        params: { pattern: schema.pattern }
+    });
+}

package/build/schema/engine/patternProperties.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildPatternProperties(context: BuildContext, schema: S.XPatternProperties, value: string): string;
+export declare function CheckPatternProperties(context: CheckContext, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPatternProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPatternProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/patternProperties.mjs

@@ -0,0 +1,42 @@
+// deno-fmt-ignore-file
+import * as V from './_externals.mjs';
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildPatternProperties(context, schema, value) {
+    return E.ReduceAnd(G.Entries(schema.patternProperties).map(([pattern, schema]) => {
+        const regexp = V.CreateExternalVariable(new RegExp(pattern));
+        const notKey = E.Not(E.Call(E.Member(regexp, 'test'), ['key']));
+        const isSchema = BuildSchema(context, schema, 'value');
+        const addKey = context.AddKey('key');
+        const guarded = context.UseUnevaluated() ? E.Or(notKey, E.And(isSchema, addKey)) : E.Or(notKey, isSchema);
+        return E.Call(E.Member(E.Entries(value), 'every'), [E.ArrowFunction(['[key, value]'], guarded)]);
+    }));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckPatternProperties(context, schema, value) {
+    return G.Every(G.Entries(schema.patternProperties), ([pattern, schema]) => {
+        const regexp = new RegExp(pattern);
+        return G.Every(G.Entries(value), ([key, value]) => {
+            return !regexp.test(key) || CheckSchema(context, schema, value) && context.AddKey(key);
+        });
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorPatternProperties(context, schemaPath, instancePath, schema, value) {
+    return G.EveryAll(G.Entries(schema.patternProperties), ([pattern, schema]) => {
+        const nextSchemaPath = `${schemaPath}/patternProperties/${pattern}`;
+        const regexp = new RegExp(pattern);
+        return G.EveryAll(G.Entries(value), ([key, value]) => {
+            const nextInstancePath = `${instancePath}/${key}`;
+            const notKey = !regexp.test(key);
+            return notKey || ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value) && context.AddKey(key);
+        });
+    });
+}

package/build/schema/engine/prefixItems.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildPrefixItems(context: BuildContext, schema: S.XPrefixItems, value: string): string;
+export declare function CheckPrefixItems(context: CheckContext, schema: S.XPrefixItems, value: unknown[]): boolean;
+export declare function ErrorPrefixItems(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPrefixItems, value: unknown[]): boolean;

package/build/schema/engine/prefixItems.mjs

@@ -0,0 +1,35 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildPrefixItems(context, schema, value) {
+    return E.ReduceAnd(schema.prefixItems.map((schema, index) => {
+        const isLength = E.IsGreaterEqualThan(E.Constant(index), E.Member(value, 'length'));
+        const isSchema = BuildSchema(context, schema, `value[${index}]`);
+        const addIndex = context.AddIndex(E.Constant(index));
+        const guarded = context.UseUnevaluated() ? E.And(isSchema, addIndex) : isSchema;
+        return E.Or(isLength, guarded);
+    }));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckPrefixItems(context, schema, value) {
+    return G.IsEqual(value.length, 0) || G.Every(schema.prefixItems, (schema, index) => {
+        return G.IsGreaterEqualThan(index, value.length)
+            || (CheckSchema(context, schema, value[index]) && context.AddIndex(index));
+    });
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorPrefixItems(context, schemaPath, instancePath, schema, value) {
+    return G.IsEqual(value.length, 0) || G.EveryAll(schema.prefixItems, (schema, index) => {
+        const nextSchemaPath = `${schemaPath}/prefixItems/${index}`;
+        const nextInstancePath = `${instancePath}/${index}`;
+        return G.IsGreaterEqualThan(index, value.length)
+            || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[index]) && context.AddIndex(index));
+    });
+}

package/build/schema/engine/properties.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildProperties(context: BuildContext, schema: S.XProperties, value: string): string;
+export declare function CheckProperties(context: CheckContext, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorProperties(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XProperties, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/properties.mjs

@@ -0,0 +1,41 @@
+// deno-fmt-ignore-file
+import { Guard as G, EmitGuard as E } from '../../guard/index.mjs';
+import * as S from '../types/index.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildProperties(context, schema, value) {
+    const required = S.IsRequired(schema) ? schema.required : [];
+    const everyKey = G.Entries(schema.properties).map(([key, schema]) => {
+        const notKey = E.Not(E.HasPropertyKey(value, E.Constant(key)));
+        const isSchema = BuildSchema(context, schema, E.Member(value, key));
+        const addKey = context.AddKey(E.Constant(key));
+        // optimization: E.Or(notKey, E.And(isSchema, addKey))
+        const guarded = context.UseUnevaluated() ? E.And(isSchema, addKey) : isSchema;
+        return !required.includes(key) ? E.Or(notKey, guarded) : guarded;
+    });
+    return E.ReduceAnd(everyKey);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckProperties(context, schema, value) {
+    const isProperties = G.Every(G.Entries(schema.properties), ([key, schema]) => {
+        return !G.HasPropertyKey(value, key)
+            || (CheckSchema(context, schema, value[key]) && context.AddKey(key));
+    });
+    return isProperties;
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorProperties(context, schemaPath, instancePath, schema, value) {
+    const isProperties = G.EveryAll(G.Entries(schema.properties), ([key, schema]) => {
+        const nextSchemaPath = `${schemaPath}/properties/${key}`;
+        const nextInstancePath = `${instancePath}/${key}`;
+        return !G.HasPropertyKey(value, key)
+            || (ErrorSchema(context, nextSchemaPath, nextInstancePath, schema, value[key]) && context.AddKey(key));
+    });
+    return isProperties;
+}

package/build/schema/engine/propertyNames.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildPropertyNames(context: BuildContext, schema: S.XPropertyNames, value: string): string;
+export declare function CheckPropertyNames(context: CheckContext, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorPropertyNames(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XPropertyNames, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/propertyNames.mjs

@@ -0,0 +1,37 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+import { AccumulatedErrorContext } from './_context.mjs';
+import { BuildSchema, CheckSchema, ErrorSchema } from './schema.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildPropertyNames(context, schema, value) {
+    return E.Call(E.Member(E.Keys(value), 'every'), [E.ArrowFunction(['key'], BuildSchema(context, schema.propertyNames, 'key'))]);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckPropertyNames(context, schema, value) {
+    return G.Every(G.Keys(value), (key) => CheckSchema(context, schema.propertyNames, key));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorPropertyNames(context, schemaPath, instancePath, schema, value) {
+    const propertyNames = [];
+    const isPropertyNames = G.EveryAll(G.Keys(value), (key) => {
+        const nextInstancePath = `${instancePath}/${key}`;
+        const nextSchemaPath = `${schemaPath}/propertyNames`;
+        const nextContext = new AccumulatedErrorContext(context.GetContext(), context.GetSchema());
+        const isPropertyName = ErrorSchema(nextContext, nextSchemaPath, nextInstancePath, schema.propertyNames, key);
+        if (!isPropertyName)
+            propertyNames.push(key);
+        return isPropertyName;
+    });
+    return isPropertyNames || context.AddError({
+        keyword: 'propertyNames',
+        schemaPath: `${schemaPath}/propertyNames`,
+        instancePath: instancePath,
+        params: { propertyNames }
+    });
+}

package/build/schema/engine/ref.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildRef(context: BuildContext, schema: S.XRef, value: string): string;
+export declare function CheckRef(context: CheckContext, schema: S.XRef, value: unknown): boolean;
+export declare function ErrorRef(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRef, value: unknown): boolean;

package/build/schema/engine/ref.mjs

@@ -0,0 +1,43 @@
+// deno-fmt-ignore-file
+import * as F from './_functions.mjs';
+import * as S from '../types/index.mjs';
+import { Guard as G } from '../../guard/index.mjs';
+import { CheckSchema, ErrorSchema } from './schema.mjs';
+import { Deref } from '../deref/index.mjs';
+// ------------------------------------------------------------------
+// Resolve
+// ------------------------------------------------------------------
+function Resolve(context, schema) {
+    // note: it is safe to coerce to XSchema here as it wouldn't be possible
+    // to enter a ref resolution if the root schema was boolean.
+    const schemaRoot = context.GetSchema();
+    // contextual schema
+    const schemaContext = context.GetContext();
+    if (G.HasPropertyKey(schemaContext, schema.$ref)) {
+        return schemaContext[schema.$ref];
+    }
+    // inline referential schema
+    const dereferenced = Deref(schemaRoot, { $ref: schema.$ref });
+    return S.IsSchemaLike(dereferenced) ? dereferenced : false;
+}
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildRef(context, schema, value) {
+    const target = Resolve(context, schema);
+    return F.CreateFunction(context, target, value);
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckRef(context, schema, value) {
+    const target = Resolve(context, schema);
+    return (S.IsSchemaLike(target) && CheckSchema(context, target, value));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorRef(context, schemaPath, instancePath, schema, value) {
+    const target = Resolve(context, schema);
+    return (S.IsSchemaLike(target) && ErrorSchema(context, '#', instancePath, target, value));
+}

package/build/schema/engine/required.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildRequired(context: BuildContext, schema: S.XRequired, value: string): string;
+export declare function CheckRequired(context: CheckContext, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;
+export declare function ErrorRequired(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XRequired, value: Record<PropertyKey, unknown>): boolean;

package/build/schema/engine/required.mjs

@@ -0,0 +1,32 @@
+// deno-fmt-ignore-file
+import { EmitGuard as E, Guard as G } from '../../guard/index.mjs';
+// ------------------------------------------------------------------
+// Build
+// ------------------------------------------------------------------
+export function BuildRequired(context, schema, value) {
+    return E.ReduceAnd(schema.required.map((key) => E.HasPropertyKey(value, E.Constant(key))));
+}
+// ------------------------------------------------------------------
+// Check
+// ------------------------------------------------------------------
+export function CheckRequired(context, schema, value) {
+    return G.Every(schema.required, (key) => G.HasPropertyKey(value, key));
+}
+// ------------------------------------------------------------------
+// Error
+// ------------------------------------------------------------------
+export function ErrorRequired(context, schemaPath, instancePath, schema, value) {
+    const requiredProperties = [];
+    const isRequired = G.EveryAll(schema.required, (key) => {
+        const hasKey = G.HasPropertyKey(value, key);
+        if (!hasKey)
+            requiredProperties.push(key);
+        return hasKey;
+    });
+    return isRequired || context.AddError({
+        keyword: 'required',
+        schemaPath: `${schemaPath}/required`,
+        instancePath,
+        params: { requiredProperties }
+    });
+}

package/build/schema/engine/schema.d.mts

@@ -0,0 +1,5 @@
+import * as S from '../types/index.mjs';
+import { BuildContext, CheckContext, ErrorContext } from './_context.mjs';
+export declare function BuildSchema(context: BuildContext, schema: S.XSchemaLike, value: string): string;
+export declare function CheckSchema(context: CheckContext, schema: S.XSchemaLike, value: unknown): boolean;
+export declare function ErrorSchema(context: ErrorContext, schemaPath: string, instancePath: string, schema: S.XSchemaLike, value: unknown): boolean;