@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/types/lib/validation/engine/schema/base.d.ts

@@ -0,0 +1,194 @@
+import * as Compile from './compile.js';
+import * as Errors from './errors.js';
+import * as Extend from './extend.js';
+import * as Manifest from './manifest.js';
+import * as Messages from './messages.js';
+import * as Modify from './modify.js';
+import type { CacheLike, PathKey, Preferences, RootLike, SchemaFlags, SchemaInternals, SchemaRule, SchemaRuleOptions, SchemaTemp } from './model.js';
+import * as Ref from './ref.js';
+import type { State } from './state.js';
+import * as Validator from './validator.js';
+import { Values } from './values.js';
+/**
+ * The terms of a schema (hash of arrays of immutable objects, extended by other types)
+ */
+export type SchemaTerms = {
+    [name: string]: unknown;
+};
+/**
+ * An item of the whens term: a condition, a switch statement, or a schema to concatenate (links)
+ */
+export interface WhenTerm {
+    concat?: Base;
+    ref?: Ref.Ref;
+    is?: Base;
+    then?: Base;
+    otherwise?: Base;
+    switch?: Compile.WhenCase[];
+    break?: boolean;
+}
+/**
+ * An item of the alterations term
+ */
+export interface AlterationTerm {
+    target: string;
+    adjuster: (schema: Base) => Base;
+}
+/**
+ * An item of the externals term
+ */
+export interface ExternalTerm {
+    method: Validator.ExternalMethod;
+    description?: string;
+}
+export interface DefaultOptions {
+    literal?: boolean;
+}
+export interface InnerOptions {
+    single?: boolean;
+    override?: boolean;
+}
+/**
+ * A Standard Schema (https://standardschema.dev) issue
+ */
+export interface StandardIssue {
+    message: string;
+    path?: PathKey[];
+}
+export type StandardResult = {
+    value: unknown;
+} | {
+    issues: StandardIssue[];
+};
+/**
+ * The Standard Schema interface of a schema
+ */
+export interface StandardSchema {
+    version: 1;
+    vendor: 'lakutata';
+    validate(value: unknown): StandardResult | Promise<StandardResult>;
+}
+/**
+ * The base schema: rules, flags, terms and validation shared by all the types
+ */
+export declare class Base implements SchemaInternals {
+    type: string;
+    $_root: RootLike;
+    _definition: Extend.Definition<Base>;
+    _ids: Modify.Ids;
+    _preferences: Preferences | null;
+    _refs: Ref.Manager;
+    _cache: CacheLike | null;
+    _valids: Values | null;
+    _invalids: Values | null;
+    _flags: SchemaFlags;
+    _rules: SchemaRule[];
+    _singleRules: Map<string, SchemaRule>;
+    $_terms: SchemaTerms;
+    $_temp: SchemaTemp;
+    $_super: Record<string, Function>;
+    _super: Record<string, Function>;
+    isImmutable: true;
+    deny: Base['invalid'];
+    disallow: Base['invalid'];
+    equal: Base['valid'];
+    exist: Base['required'];
+    not: Base['invalid'];
+    options: Base['prefs'];
+    preferences: Base['prefs'];
+    constructor(type?: string);
+    _reset(): void;
+    describe(): Manifest.SchemaDescription;
+    allow(...values: unknown[]): this;
+    alter(targets: Record<string, (schema: Base) => Base>): this;
+    artifact(id: unknown): this;
+    cast(to: string | false): this;
+    default(value?: unknown, options?: DefaultOptions): this;
+    description(desc: string): this;
+    empty(schema?: unknown): this;
+    error(err: Error | ((errors: Errors.ErrorItem[]) => Errors.ErrorItem | Errors.ErrorItem[])): this;
+    example(example: unknown, options?: {
+        override?: boolean;
+    }): this;
+    external(method: Validator.ExternalMethod | ExternalTerm, description?: string): this;
+    failover(value?: unknown, options?: DefaultOptions): this;
+    forbidden(): this;
+    id(id?: string): this;
+    invalid(...values: unknown[]): this;
+    label(name: string): this;
+    meta(meta: unknown): this;
+    note(...notes: string[]): this;
+    only(mode?: boolean): this;
+    optional(): this;
+    prefs(prefs: Preferences): this;
+    presence(mode: NonNullable<Preferences['presence']>): this;
+    raw(enabled?: boolean): this;
+    result(mode: 'raw' | 'strip'): this;
+    required(): this;
+    strict(enabled?: boolean): this;
+    strip(enabled?: boolean): this;
+    tag(...tags: string[]): this;
+    unit(name: string): this;
+    valid(...values: unknown[]): this;
+    when(condition: unknown, options?: Compile.WhenOptions | Compile.WhenSwitchCase[]): this;
+    cache(cache?: CacheLike): this;
+    clone(): this;
+    concat(source: Base): this;
+    /**
+     * A new type extending the type of this schema
+     * @param options the type definition, where S is the schema type of the new type
+     */
+    extend<S extends Base = this>(options: Extend.TypeDefinition<S>): S;
+    extract(path: string | string[]): SchemaInternals;
+    fork(paths: string | string[] | (string | string[])[], adjuster: (schema: SchemaInternals) => SchemaInternals): this;
+    isAsync(): boolean;
+    rule(options: Record<string, unknown>): this;
+    get ruleset(): this;
+    get $(): this;
+    tailor(targets: string | string[]): this;
+    tracer(): this;
+    validate(value: unknown, options?: Preferences): Validator.ValidationResult;
+    validateAsync(value: unknown, options?: Preferences): Promise<unknown>;
+    $_addRule(options: string | SchemaRuleOptions): this;
+    $_compile(schema: unknown, options?: Compile.SchemaOptions): Base;
+    $_createError(code: string, value: unknown, local: Errors.ReportLocal | null | undefined, state: State, prefs: Preferences, options?: {
+        flags?: boolean;
+        messages?: Messages.MessagesInput;
+    }): Errors.Report;
+    $_getFlag(name: string): unknown;
+    $_getRule(name: string): SchemaRule | undefined;
+    $_mapLabels(path: string | string[]): string;
+    $_match(value: unknown, state: State, prefs: Preferences, overrides?: {
+        presence?: Preferences['presence'];
+    }): boolean;
+    $_modify(options: Modify.ModifyOptions): this;
+    $_mutateRebuild(): this;
+    $_mutateRegister(schema: unknown, { family, key }?: {
+        family?: number;
+        key?: string | false;
+    }): void;
+    $_property(name: string): unknown;
+    $_reach(path: string[]): SchemaInternals;
+    $_rootReferences(): PathKey[];
+    $_setFlag(name: string, value: unknown, options?: {
+        clone?: boolean;
+    }): this;
+    $_parent(method: string, ...args: unknown[]): unknown;
+    $_validate(value: unknown, state: State, prefs: Preferences): Validator.SchemaResult;
+    _assign<T extends SchemaInternals>(target: T): T;
+    _bare(): this;
+    _default(flag: 'default' | 'failover', value: unknown, options?: DefaultOptions): this;
+    _generate(value: unknown, state: State, prefs: Preferences): {
+        schema: Base;
+        id?: string;
+    };
+    _inner(type: string, values: unknown, options?: InnerOptions): this;
+    _inRuleset(): boolean;
+    _ruleRemove(name: string, options?: {
+        clone?: boolean;
+    }): this;
+    _values(values: unknown[], key: '_valids' | '_invalids'): this;
+    get '~standard'(): StandardSchema;
+}
+declare const base: Base;
+export default base;

package/dist/types/lib/validation/engine/schema/cache.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Keys a cache can store values by
+ */
+export type CacheKey = undefined | null | boolean | number | string;
+export interface CacheOptions {
+    max?: number;
+}
+interface ListNode {
+    key: CacheKey;
+    value: unknown;
+    next: ListNode | null;
+    prev: ListNode | null;
+}
+/**
+ * Doubly linked list of cache nodes (most recently used in head)
+ */
+declare class List {
+    tail: ListNode | null;
+    head: ListNode | null;
+    unshift(node: ListNode): ListNode;
+    first(node: ListNode): void;
+    pop(): ListNode;
+    protected _remove(node: ListNode): ListNode;
+}
+/**
+ * Least Recently Used (LRU) cache
+ */
+export declare class Cache {
+    protected _max: number;
+    protected _map: Map<CacheKey, ListNode>;
+    protected _list: List;
+    constructor(options?: CacheOptions);
+    get length(): number;
+    set(value: unknown, result: unknown): void;
+    get(value: unknown): unknown;
+    protected _compact(): void;
+}
+export declare const provider: {
+    provision(options?: CacheOptions): Cache;
+};
+export {};

package/dist/types/lib/validation/engine/schema/common.d.ts

@@ -0,0 +1,79 @@
+import type { Preferences, SchemaLike } from './model.js';
+/**
+ * Version of the schema format of the validation engine: schemas of engines with another version are not mixed (bump it
+ * when the schema internals change incompatibly)
+ */
+export declare const version: string;
+export declare const defaults: Preferences;
+export declare const symbols: {
+    readonly any: symbol;
+    readonly arraySingle: symbol;
+    readonly deepDefault: symbol;
+    readonly errors: symbol;
+    readonly literal: symbol;
+    readonly override: symbol;
+    readonly parent: symbol;
+    readonly prefs: symbol;
+    readonly ref: symbol;
+    readonly template: symbol;
+    readonly values: symbol;
+};
+export type CompareOperator = '=' | '>' | '<' | '>=' | '<=';
+export declare function assertOptions(options: unknown, keys: string | string[], name?: string): void;
+export declare function checkPreferences(prefs: unknown): void;
+/**
+ * Compare two values with an operator (values of any type are compared like JavaScript does)
+ * @param a
+ * @param b
+ * @param operator
+ */
+export declare function compare(a: unknown, b: unknown, operator: CompareOperator): boolean | undefined;
+/**
+ * The value, or the default value when the value is undefined (upstream: Common.default())
+ * @param value
+ * @param defaultValue
+ */
+export declare function defaultValue<T, D>(value: T | undefined, defaultValue: D): T | D;
+export declare function isIsoDate(date: string): boolean;
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Whether the value is a reference or a template
+ * @param obj
+ */
+export declare function isResolvable(obj: unknown): boolean;
+/**
+ * Whether the value is a schema (of this engine version, or of any engine version with the legacy option)
+ * @param schema
+ * @param options
+ */
+export declare function isSchema(schema: unknown, options?: {
+    legacy?: boolean;
+}): schema is SchemaLike;
+export declare function isValues(obj: unknown): boolean;
+export declare function limit(value: unknown): value is number;
+/**
+ * Merge preferences
+ * @param target
+ * @param source
+ */
+export declare function preferences(target: Preferences | null | undefined, source: Preferences | null | undefined): Preferences;
+/**
+ * Call fn, prefixing the path of a thrown error with the key
+ * @param fn
+ * @param key
+ * @param options
+ */
+export declare function tryWithPath<T>(fn: () => T, key: string | number, options?: {
+    append?: boolean;
+}): T;
+/**
+ * Validate a method argument, returning the error message of an invalid value
+ * @param value
+ * @param label
+ * @param validation a schema, or a predicate with its error message
+ */
+export declare function validateArg(value: unknown, label: string | undefined, { assert, message }: {
+    assert: SchemaLike | ((value: unknown) => unknown);
+    message?: string;
+}): string | undefined;
+export declare function verifyFlat(args: unknown[], method: string): void;

package/dist/types/lib/validation/engine/schema/compile.d.ts

@@ -0,0 +1,81 @@
+import type { RootLike, SchemaInternals } from './model.js';
+import * as Ref from './ref.js';
+export interface SchemaOptions {
+    appendPath?: boolean;
+    override?: boolean;
+}
+export interface CompileOptions {
+    legacy?: boolean;
+}
+/**
+ * A when() switch case, as provided
+ */
+export interface WhenSwitchCase {
+    is?: unknown;
+    then?: unknown;
+    otherwise?: unknown;
+}
+/**
+ * The when() options, as provided
+ */
+export interface WhenOptions {
+    is?: unknown;
+    not?: unknown;
+    then?: unknown;
+    otherwise?: unknown;
+    switch?: WhenSwitchCase[];
+    break?: boolean;
+}
+/**
+ * A compiled single when() condition
+ */
+export interface WhenCondition {
+    ref?: Ref.Ref;
+    is: SchemaInternals;
+    then?: SchemaInternals;
+    otherwise?: SchemaInternals;
+    break?: boolean;
+}
+/**
+ * A compiled when() switch case
+ */
+export interface WhenCase {
+    is: SchemaInternals;
+    then: SchemaInternals;
+    otherwise?: SchemaInternals;
+}
+/**
+ * A compiled when() switch statement
+ */
+export interface WhenSwitch {
+    ref: Ref.Ref;
+    switch: WhenCase[];
+    break?: boolean;
+}
+/**
+ * Compile a schema description (literals, arrays, objects, regular expressions...) into a schema
+ * @param root
+ * @param config
+ * @param options
+ */
+export declare function schema(root: RootLike, config: unknown, options?: SchemaOptions): SchemaInternals;
+/**
+ * A reference, created from its key unless it is one already
+ * @param id
+ * @param options
+ */
+export declare function ref(id: unknown, options?: Ref.RefOptions): Ref.Ref;
+/**
+ * Compile a schema, unless it is compiled already (by this version, or by a legacy one when allowed)
+ * @param root
+ * @param schema
+ * @param options
+ */
+export declare function compile(root: RootLike, schema: unknown, options?: CompileOptions): SchemaInternals;
+/**
+ * Compile when() arguments into a condition or a switch statement
+ * @param schema
+ * @param condition
+ * @param options
+ */
+export declare function when(schema: SchemaInternals, condition: unknown, options?: WhenOptions | WhenSwitchCase[]): WhenCondition | WhenSwitch;

package/dist/types/lib/validation/engine/schema/errors.d.ts

@@ -0,0 +1,94 @@
+import type { Message, Messages } from './messages.js';
+import type { ErrorDetail, PathKey, Preferences, StateLike } from './model.js';
+/**
+ * The schema flags an error report reads
+ */
+export interface ReportFlags {
+    label?: string;
+    [name: string]: unknown;
+}
+/**
+ * Local context of an error report, available to its message template
+ */
+export interface ReportLocal {
+    label?: unknown;
+    value?: unknown;
+    key?: PathKey;
+    [name: string]: unknown;
+}
+/**
+ * A validation error report, rendered lazily into a message
+ */
+export declare class Report {
+    code: string;
+    flags: ReportFlags;
+    messages: Messages | null | undefined;
+    path: PathKey[];
+    prefs: Preferences;
+    state: StateLike;
+    value: unknown;
+    message: string | null;
+    template: Messages | null | undefined;
+    local: ReportLocal;
+    constructor(code: string, value: unknown, local: ReportLocal | null | undefined, flags: ReportFlags, messages: Messages | null | undefined, state: StateLike, prefs: Preferences);
+    _setTemplate(template: Messages | null | undefined): void;
+    toString(): string;
+    _template(messages: Messages | null | undefined, code?: string): Message | null | undefined;
+}
+/**
+ * Render a path for a label ('a.b[0]')
+ * @param path
+ */
+export declare function path(path: PathKey[]): string;
+/**
+ * Find the message of an error code, in the preferred language first
+ * @param value
+ * @param messages
+ * @param code
+ * @param state
+ * @param prefs
+ */
+export declare function template(value: unknown, messages: Messages | null | undefined, code: string, state: StateLike, prefs: Preferences): Message | null | undefined;
+/**
+ * The label of a value in error messages
+ * @param flags
+ * @param state
+ * @param prefs
+ * @param messages
+ */
+export declare function label(flags: ReportFlags, state: StateLike, prefs: Preferences, messages: Messages | null | undefined): unknown;
+/**
+ * An override error (thrown by a custom rule), or an error report
+ */
+export type ErrorItem = Error | Report;
+/**
+ * The validation error, or the override error, of the errors of a validation
+ * @param errors
+ * @param original
+ * @param prefs
+ */
+export declare function process(errors: ErrorItem[] | null | undefined, original: unknown, prefs: Preferences): Error | null;
+/**
+ * The detail of an override error, when override errors are not returned as they are
+ */
+export interface OverrideDetail {
+    message: string;
+    type: 'override';
+    context: {
+        error: Error;
+    };
+}
+export interface ErrorsDetails {
+    override?: Error;
+    message?: string;
+    details?: (ErrorDetail | OverrideDetail)[];
+}
+/**
+ * The message and the details of errors (or the first override error)
+ * @param errors
+ * @param options
+ */
+declare function detailsOf(errors: ErrorItem[], options?: {
+    override?: boolean;
+}): ErrorsDetails;
+export { detailsOf as details };

package/dist/types/lib/validation/engine/schema/extend.d.ts

@@ -0,0 +1,122 @@
+import * as Messages from './messages.js';
+import type { Preferences, SchemaInternals, SchemaLike, SchemaRule, ValidationHelpers, ValidationOutcome } from './model.js';
+import type { State } from './state.js';
+/**
+ * Any method, called with arguments checked by its own implementation
+ */
+export type DefinitionMethod<S> = (this: S, ...args: never[]) => unknown;
+/**
+ * A type method run on the validated value (prepare, coerce, validate)
+ */
+export type TypeMethod<S extends SchemaInternals = SchemaInternals> = (value: unknown, helpers: ValidationHelpers<S>) => ValidationOutcome | undefined | void;
+/**
+ * A rule validation: the validated value, errors, or a report
+ */
+export type RuleMethod<S extends SchemaInternals = SchemaInternals> = (value: unknown, helpers: ValidationHelpers<S>, args: Record<string, unknown>, rule: SchemaRule) => unknown;
+export interface FlagDefinition {
+    default?: unknown;
+    setter?: string;
+    register?: number | false;
+}
+/**
+ * How a term is described: as schemas, as a single schema, as values, or mapped into objects
+ */
+export type TermManifest = 'schema' | 'single' | 'values' | {
+    mapped: {
+        from: string;
+        to: string;
+    };
+};
+export interface TermDefinition {
+    init: unknown;
+    manifest?: TermManifest;
+    register?: number | false;
+}
+export interface RuleArgDefinition {
+    name: string;
+    ref?: boolean;
+    assert?: SchemaLike | ((value: unknown) => unknown);
+    message?: string;
+    normalize?(value: unknown): unknown;
+}
+export interface RuleDefinition<S extends SchemaInternals = SchemaInternals> {
+    method?: DefinitionMethod<S> | false;
+    alias?: string | string[];
+    args?: (string | RuleArgDefinition)[];
+    argsByName?: Map<string, RuleArgDefinition>;
+    validate?: RuleMethod<S>;
+    convert?: boolean;
+    manifest?: boolean;
+    multi?: boolean;
+    priority?: boolean;
+    register?: number | false;
+}
+/**
+ * A rule definition, once extended
+ */
+export interface ExtendedRuleDefinition<S extends SchemaInternals = SchemaInternals> extends RuleDefinition<S> {
+    args?: RuleArgDefinition[];
+}
+export type ModifierMethod = (rule: SchemaRule, value: unknown) => void;
+export interface CastDefinition<S extends SchemaInternals = SchemaInternals> {
+    from(value: unknown): unknown;
+    to(value: unknown, helpers: ValidationHelpers<S>): unknown;
+}
+export interface CoerceDefinition<S extends SchemaInternals = SchemaInternals> {
+    method: TypeMethod<S>;
+    from?: string | string[] | null;
+}
+export interface ManifestDefinition<S extends SchemaInternals = SchemaInternals> {
+    build?(obj: S, desc: Record<string, unknown>): S;
+}
+/**
+ * The definition of a type, as provided to extend()
+ */
+export interface TypeDefinition<S extends SchemaInternals = SchemaInternals> {
+    type: string;
+    base?: S;
+    args?(schema: S, ...args: never[]): S;
+    cast?: Record<string, CastDefinition<S>>;
+    coerce?: TypeMethod<S> | CoerceDefinition<S>;
+    flags?: Record<string, FlagDefinition>;
+    generate?(schema: S, value: unknown, state: State, prefs: Preferences): S | undefined;
+    manifest?: ManifestDefinition<S>;
+    messages?: Messages.MessagesInput;
+    modifiers?: Record<string, ModifierMethod>;
+    overrides?: Record<string, DefinitionMethod<S>>;
+    prepare?: TypeMethod<S>;
+    properties?: Record<string, unknown>;
+    rebuild?(schema: S): void;
+    rules?: Record<string, RuleDefinition<S>>;
+    terms?: Record<string, TermDefinition>;
+    validate?: TypeMethod<S>;
+}
+/**
+ * The definition of a type, once extended (merged with its parent's)
+ */
+export interface Definition<S extends SchemaInternals = SchemaInternals> {
+    type: string;
+    args?(schema: S, ...args: never[]): S;
+    cast: Record<string, CastDefinition<S>>;
+    coerce?: CoerceDefinition<S> & {
+        from?: string[] | null;
+    };
+    flags: Record<string, FlagDefinition>;
+    generate?(schema: S, value: unknown, state: State, prefs: Preferences): S | undefined;
+    manifest: ManifestDefinition<S>;
+    messages: Messages.Messages | null | undefined;
+    modifiers: Record<string, ModifierMethod>;
+    overrides?: Record<string, DefinitionMethod<S>>;
+    prepare?: TypeMethod<S>;
+    properties: Record<string, unknown>;
+    rebuild?(schema: S): void;
+    rules: Record<string, ExtendedRuleDefinition<S>>;
+    terms: Record<string, TermDefinition>;
+    validate?: TypeMethod<S>;
+}
+/**
+ * A new type (a schema with its own prototype), extending the type of a schema
+ * @param from
+ * @param options
+ */
+export declare function type<S extends SchemaInternals>(from: S, options: TypeDefinition<S>): S;

package/dist/types/lib/validation/engine/schema/extensions/bigint.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Derived from the upstream src/index.ts and src/types.ts (see UPSTREAM.md; MIT, see THIRD_PARTY_NOTICES.md)
+ */
+import type * as Ref from '../ref.js';
+import type { Extension, Root } from '../index.js';
+import type { AnySchema } from '../types/any.js';
+/**
+ * The bigint schema
+ * @typeParam T the validated value type (kept for compatibility with the upstream type, which is generic)
+ */
+export interface BigIntSchema<T = bigint> extends AnySchema {
+    greater(limit: bigint | Ref.Ref): this;
+    less(limit: bigint | Ref.Ref): this;
+    max(limit: bigint | Ref.Ref): this;
+    min(limit: bigint | Ref.Ref): this;
+    multiple(base: bigint | Ref.Ref): this;
+    negative(): this;
+    port(): this;
+    positive(): this;
+    sign(sign: 'positive' | 'negative'): this;
+}
+/**
+ * The bigint extension of the root object
+ * @param _engine the root object (extend() requires the factories of the extensions to take it)
+ */
+export declare const bigintExtension: (_engine: Root) => Extension<BigIntSchema>;
+/**
+ * A root object with the bigint type
+ * @param baseEngine
+ */
+export declare const extendBigInt: <T extends Root>(baseEngine: T) => T & {
+    bigint<U = bigint>(): BigIntSchema<U>;
+};

package/dist/types/lib/validation/engine/schema/fastpath.d.ts

@@ -0,0 +1,35 @@
+import type { Base } from './base.js';
+import type { Preferences } from './model.js';
+/**
+ * Returned by a compiled schema when the value must be validated by the interpreter
+ */
+export declare const FALLBACK: unique symbol;
+/**
+ * Returned by a compiled schema when the value is invalid (the interpreter reports an error for it)
+ */
+export declare const INVALID: unique symbol;
+/**
+ * A compiled schema: the validated value, INVALID or FALLBACK
+ */
+export type Compiled = (value: unknown) => unknown;
+/**
+ * Mark the method of a custom rule as pure (deterministic, without side effects, calling only error() of the helpers),
+ * so the fast path can compile the schemas using it (for lakutata's own validators; other custom rules are interpreted)
+ * @param method
+ */
+export declare function pure<T extends Function>(method: T): T;
+/**
+ * The compiled schema for the validation settings (null: validate with the interpreter)
+ * @param schema
+ * @param settings the settings of a validation (defaults merged with the validate() options), which must not change
+ */
+export declare function compiledFor(schema: Base, settings: Preferences): Compiled | null;
+/**
+ * Whether the fast path and the interpreter produced the same value: same primitives (Object.is), and objects with the
+ * same prototype, own keys (in order), property attributes and values, where the input is reused in the same places
+ * @param fast
+ * @param interpreted
+ * @param input the validated value at the same place
+ * @param seen
+ */
+export declare function sameResult(fast: unknown, interpreted: unknown, input: unknown, seen?: Map<object, object>): boolean;

package/dist/types/lib/validation/engine/schema/formats.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A format validator
+ */
+export type FormatValidator = (value: string) => boolean;
+/**
+ * The format validators, by name
+ */
+export declare const formats: Readonly<Record<string, FormatValidator>>;