schema-dsl 1.2.4 → 2.0.0

package/dist/index.d.cts

@@ -0,0 +1,1145 @@
+import { V as Validator } from './Validator-C7GsVQOH.cjs';
+export { C as CacheManager } from './Validator-C7GsVQOH.cjs';
+import { J as JSONSchema, V as ValidationResult, E as ErrorMessages, a as ValidationErrorItem, P as Plugin, H as HookFn, b as ErrorCodeMap, D as DslConfigOptions } from './plugin-CIKtTMtS.cjs';
+export { C as CacheConfig, C as CacheOptions, I as I18nConfig, S as SchemaIOOptions, c as ValidateOptions, d as ValidatorOptions } from './plugin-CIKtTMtS.cjs';
+import { I as IConditionalBuilder, D as DslBuilder, a as IDslBuilder, b as DslDefinition, c as DslConditionMarker } from './DslBuilder-DQDN0ZxZ.cjs';
+export { d as DslErrorNamespace, e as DslField, f as DslFn, g as DslIfFn, h as DslInput } from './DslBuilder-DQDN0ZxZ.cjs';
+import { EventEmitter } from 'node:events';
+import { Ajv } from 'ajv';
+
+/**
+ * JSONSchemaCore — v1 compatibility facade.
+ *
+ * The v2 internals have been split into DslParser / SchemaCompiler / Validator; this class
+ * restores the commonly-used chainable entry points from the v1 public API so that users
+ * who import from the main entry point do not encounter errors.
+ */
+declare class JSONSchemaCore {
+    schema: JSONSchema;
+    constructor(schema?: JSONSchema);
+    type(typeName: string): this;
+    property(name: string, schema: JSONSchema): this;
+    properties(properties: Record<string, JSONSchema>): this;
+    required(fields: string[] | string): this;
+    format(formatName: string): this;
+    pattern(pattern: RegExp | string): this;
+    items(schema: JSONSchema): this;
+    toSchema(): JSONSchema;
+    getSchema(): JSONSchema;
+    validate(data: unknown): ReturnType<Validator['validate']>;
+}
+
+/**
+ * ConditionalBuilder — chainable condition builder.
+ *
+ * v2 fixes:
+ *   C-03: assert() throws ValidationError instead of plain Error
+ *   C-Y01: elseIf semantics correct
+ *   C-Y02: build() as toSchema() alias (IConditionalBuilder interface compat)
+ */
+
+type ConditionFn = (data: unknown) => boolean;
+declare class ConditionalBuilder implements IConditionalBuilder {
+    private _conditions;
+    private _elseSchema;
+    constructor();
+    if(conditionFn: ConditionFn | string): this;
+    and(conditionFn: ConditionFn): this;
+    /**
+     * require(field) — v1 compat: require the specified field to be truthy.
+     * Equivalent to .and(data => Boolean(data[field])).
+     * BC-5 fix.
+     */
+    require(field: string): this;
+    or(conditionFn: ConditionFn): this;
+    elseIf(conditionFn: ConditionFn): this;
+    message(msg: string): this;
+    then(schema: string | JSONSchema | null): this;
+    else(schema: string | JSONSchema | null): this;
+    /**
+     * Produce a schema object carrying serialisable conditional metadata plus non-enumerable runtime state.
+     */
+    toSchema(): JSONSchema;
+    /**
+     * build() — alias for toSchema() (IConditionalBuilder interface compat).
+     */
+    build(): JSONSchema;
+    private readonly _validatorCache;
+    private static readonly _VALIDATOR_CACHE_MAX;
+    validate(data: unknown, options?: Record<string, unknown>): ValidationResult<unknown>;
+    validateAsync(data: unknown, options?: Record<string, unknown>): Promise<ValidationResult<unknown>>;
+    /**
+     * assert() — synchronous assertion; throws ValidationError on failure (fixes C-03: v1 threw plain Error).
+     * Evaluates conditions synchronously without going through Validator (which is async).
+     */
+    assert(data: unknown, options?: Record<string, unknown>): unknown;
+    check(data: unknown): boolean;
+    static start(conditionFn: ConditionFn | string): ConditionalBuilder;
+    private _evaluateCondition;
+    private _getValidator;
+    private _getConstructorOptions;
+    private _getValidatorCacheKey;
+    private _normalizeOptionValue;
+}
+
+/**
+ * ObjectDslBuilder — v1 compat: dsl(object) returns a chainable builder.
+ *
+ * BC-2 fix: in v1, the schema returned by dsl({...}) / parseObject() supported .strict() /
+ * .requireAll() and other chain decorators, and implemented the toSchema() duck-type interface
+ * (Validator passes through internal schema). After v2 refactor, parseObject() returned plain
+ * JSONSchema, losing all chain API. This class wraps the DslParser.parseObject() result and
+ * exposes v1-equivalent chain methods:
+ *   - toSchema()     — return internal JSONSchema (Validator duck-type entry point)
+ *   - toJsonSchema() — return clean JSON Schema (internal schema-dsl keywords stripped)
+ *   - strict()       — disallow extra properties
+ *   - requireAll()   — require all defined properties to be present
+ *   - toString()     — serialize to JSON string
+ */
+
+declare class ObjectDslBuilder {
+    readonly _isDslBuilder: true;
+    readonly _isObjectDsl: true;
+    private _schema;
+    constructor(schema: JSONSchema);
+    /** Return internal JSONSchema (Validator.validate() duck-type entry point). */
+    toSchema(): JSONSchema;
+    /** Return clean JSON Schema (internal schema-dsl keywords stripped; safe for serialization or external tools). */
+    toJsonSchema(): JSONSchema;
+    toString(): string;
+    /**
+     * strict() — disallow extra properties (v1 compat).
+     * Equivalent to setting strictSchema: true on the compiled schema.
+     */
+    strict(): this;
+    /**
+     * requireAll() — require all defined properties to be present (v1 compat).
+     * Equivalent to setting requiredAll: true on the compiled schema.
+     */
+    requireAll(): this;
+}
+
+/**
+ * LocaleKey — union type of all locale message keys (118 keys)
+ *
+ * TypeScript compile-time completeness enforcement: every locale file must implement
+ * the LocaleMessages interface; adding a new key causes a compiler error in all locales.
+ */
+/** A message is either a plain string or an object with code (v1.1.5+ format) */
+type LocaleMessage = string | {
+    code: string | number;
+    message: string;
+};
+
+interface LocaleResolvedMessage {
+    code: string | number;
+    message: string;
+}
+declare class Locale {
+    private static _currentLocale;
+    private static _customMessages;
+    /** v1 compat: expose custom messages */
+    static get customMessages(): Record<string, LocaleMessage>;
+    /** v1 compat: expose all locales as { locale: messages } map */
+    static get locales(): Record<string, Record<string, LocaleMessage>>;
+    static setLocale(locale: string): void;
+    static getLocale(): string;
+    static setMessages(messages: Record<string, LocaleMessage>): void;
+    static addLocale(locale: string, messages: Record<string, LocaleMessage>): void;
+    static getAvailableLocales(): string[];
+    static isSupportedLocale(locale: string): boolean;
+    /**
+     * Get a resolved message (v1 compat: returns { code, message } on hit).
+     *
+     * Priority: custom messages > locale pack > key itself.
+     */
+    static getMessage(type: string, customMessages?: Record<string, LocaleMessage>, locale?: string | null): LocaleResolvedMessage | string;
+    /**
+     * Get the final message text (used internally by v2 to avoid "[object Object]" in message field).
+     */
+    static getMessageText(type: string, customMessages?: Record<string, LocaleMessage>, locale?: string | null): string;
+    /**
+     * Get raw message config (used by I18nError; may include a numeric code).
+     */
+    static getMessageConfig(type: string, customMessages?: Record<string, LocaleMessage>, locale?: string | null): LocaleMessage;
+    /**
+     * Get the full message table for the given locale (built-in + custom).
+     */
+    static getMessages(locale?: string): Record<string, LocaleMessage>;
+    /**
+     * Reset to defaults (for testing).
+     */
+    static reset(): void;
+    private static _normalizeResolvedMessage;
+    private static _resolveMessage;
+    private static _isLocaleKey;
+}
+
+type AjvRawError = {
+    keyword: string;
+    instancePath: string;
+    schemaPath?: string;
+    params: Record<string, unknown>;
+    message?: string;
+    data?: unknown;
+    parentSchema?: Record<string, unknown>;
+    schema?: unknown;
+};
+/**
+ * Error formatter.
+ * Delegates template interpolation to TemplateEngine.renderTemplate() (fix CORE-03).
+ * Maintains full v1 API compatibility.
+ */
+declare class ErrorFormatter {
+    private messages;
+    private _locale;
+    private readonly _constructorCustomMessages;
+    constructor(locale?: string, messages?: ErrorMessages | Record<string, LocaleMessage | string | undefined>);
+    get locale(): string;
+    /**
+     * Format a single error object → message string (v1 API).
+     */
+    format(error: AjvRawError | Record<string, unknown>, locale?: string): string;
+    /**
+     * Format an AJV raw error array → ValidationErrorItem[].
+     *
+     * @param alreadyMerged - when true, customMessages is already a fully merged locale+custom result;
+     *   skip `{ ...this.messages, ...customMessages }` spread (avoids 100+ key cold-spread overhead).
+     */
+    formatDetailed(errors: AjvRawError[], locale?: string, customMessages?: ErrorMessages, alreadyMerged?: boolean): ValidationErrorItem[];
+    /**
+     * Format a single error entry into a ValidationErrorItem.
+     */
+    private _formatOne;
+    setLocale(locale: string): void;
+    addMessage(type: string, template: string): void;
+    addMessages(messages: ErrorMessages): void;
+}
+
+/**
+ * MessageTemplate — wraps a template string for rendering.
+ * Delegates to TemplateEngine.renderTemplate() (fix CORE-03).
+ * Maintains full v1 API compatibility (constructor + render + static render + static renderBatch).
+ */
+declare class MessageTemplate {
+    private readonly template;
+    constructor(template: string);
+    /**
+     * Render the template with the given context.
+     */
+    render(context?: Record<string, unknown>): string;
+    /**
+     * Statically render a template string with the given context.
+     */
+    static render(template: string, context?: Record<string, unknown>): string;
+    /**
+     * Statically render multiple templates in batch.
+     */
+    static renderBatch(templates: Record<string, string>, context?: Record<string, unknown>): Record<string, string>;
+}
+
+/**
+ * Unified template engine.
+ *
+ * Merges the two rendering implementations from v1 — MessageTemplate.render() and
+ * ErrorFormatter._interpolate() — into a single pipeline.
+ * Fixes the CORE-03 template injection vulnerability (single-pass replacement so that
+ * substituted values are never expanded a second time).
+ *
+ * Supports two placeholder formats:
+ *   {{#key}}  ← all v1 locale files use this format (must remain compatible)
+ *   {key}     ← recommended format for v2 message templates
+ */
+/**
+ * Render a template string by replacing placeholders with corresponding values from params.
+ *
+ * @param template - Template string, e.g. "{{#label}} must be at least {{#min}} characters"
+ * @param params   - Substitution parameter object
+ * @returns          Rendered string; placeholders with no matching key are kept as-is (aids debugging)
+ *
+ * @example
+ * renderTemplate('{{#label}} is required', { label: 'Email' })
+ * // → 'Email is required'
+ *
+ * renderTemplate('{field} must be {min}~{max}', { field: 'age', min: 18, max: 65 })
+ * // → 'age must be 18~65'
+ */
+declare function renderTemplate(template: string, params: Record<string, unknown>): string;
+
+/**
+ * PluginManager — plugin registration and hook execution.
+ *
+ * Full v1 compatible API:
+ *   - hooks        : public hooks Map; supports any hook name
+ *   - EventEmitter compat: on / once / off / emit / removeListener / removeAllListeners
+ *   - unhook(name, fn): remove a specific hook handler
+ *   - runHook(name, ...args): pass arbitrary args, collect return values
+ *   - install(core, name?, opts?): supports named + options install for a single plugin
+ *   - install / uninstall pass through context
+ *   - has / get / list / clear / size / uninstall (alias)
+ */
+declare class PluginManager extends EventEmitter {
+    readonly plugins: Map<string, Plugin>;
+    /**
+     * Public hooks Map (v1 compat: pluginManager.hooks.get('hookName')).
+     * Supports any string name, not limited to built-in HookName values.
+     */
+    readonly hooks: Map<string, Array<HookFn>>;
+    /** v1 compat context (passed to plugin install / uninstall). */
+    readonly context: {
+        plugins: Map<string, Plugin>;
+        hooks: Map<string, Array<HookFn>>;
+    };
+    /** Per-plugin hook references (used for automatic cleanup on unregister). */
+    private readonly _pluginHooks;
+    private _installedCore;
+    /** Built-in hook names (pre-initialized on construction). */
+    private static readonly BUILTIN_HOOKS;
+    /** Legacy v1 lifecycle hook names. */
+    private static readonly LEGACY_HOOKS;
+    constructor();
+    /**
+     * Register a plugin.
+     */
+    register(plugin: Plugin): this;
+    /**
+     * Add a hook callback (supports any name, not limited to built-in HookName).
+     */
+    hook(name: string, fn: HookFn): this;
+    /**
+     * Remove a specific hook handler (v1 compat: unhook).
+     */
+    unhook(name: string, fn: HookFn): this;
+    /**
+     * Run the specified hook.
+     * - Args are passed directly to each handler (v1 compat: runHook(name, arg1, arg2, ...)).
+     * - Returns an array of all handler return values.
+     * - If a handler throws, emits 'hook:error' and runs onError (does not interrupt remaining handlers).
+     */
+    runHook(name: string, ...args: unknown[]): Promise<unknown[]>;
+    /**
+     * Install plugins.
+     *
+     * Supports two call forms (v1 compat):
+     *   install(core)                       — install all registered plugins
+     *   install(core, pluginName, options?) — install the named plugin, merging plugin.options + options
+     */
+    install(core: unknown, pluginName?: string, extraOptions?: Record<string, unknown>): this;
+    private _installPlugin;
+    /**
+     * Unregister a plugin (v2 primary method).
+     * - Automatically cleans up all hooks registered by this plugin.
+     * - Emits 'plugin:uninstalled' event.
+     */
+    unregister(name: string, coreInstance?: unknown): this;
+    /** v1 compat: check whether a plugin is registered. */
+    has(name: string): boolean;
+    /** v1 compat: get a single plugin or the full plugins Map. */
+    get(name?: string): Plugin | Map<string, Plugin> | undefined;
+    /** v1 compat: list all plugin metadata. */
+    list(): Array<{
+        name: string;
+        version?: string;
+        description?: string;
+    }>;
+    /** v1 compat: clear all plugins (including hook cleanup). */
+    clear(coreInstance?: unknown): this;
+    /** v1 compat: uninstall a plugin (alias for unregister). */
+    uninstall(name: string, coreInstance?: unknown): this;
+    get pluginCount(): number;
+    /** v1 compat: plugin count (alias for pluginCount). */
+    get size(): number;
+    private _ensureHook;
+    private _addPluginHook;
+    private _runHookSync;
+}
+
+/**
+ * Type definition (structure of each entry in TypeRegistry)
+ */
+interface TypeDefinition {
+    /** Base JSON Schema fragment for this type */
+    baseSchema: Partial<JSONSchema>;
+    /** Custom messages associated with this type (e.g., error key for phone type) */
+    customMessages?: Record<string, string>;
+    /** Whether this type uses a pattern (keys are standard JSON Schema fields, not stripped in toJsonSchema) */
+    isPattern?: boolean;
+}
+/**
+ * TypeRegistry — unified type registration and resolution
+ *
+ * Replaces the three inconsistent type lists in v1 (fixes DB-01/DB-02/DA-01)
+ */
+declare const TypeRegistry: {
+    /**
+     * Resolve a type name to its TypeDefinition.
+     * Built-in types take priority; custom types may override non-primitive built-ins.
+     */
+    readonly resolve: (typeName: string) => TypeDefinition;
+    /**
+     * Register a custom type (delegated from DslBuilder.registerType)
+     */
+    readonly register: (name: string, def: TypeDefinition | Partial<JSONSchema>) => void;
+    /**
+     * Register a dynamic type (factory function invoked on every resolve call)
+     */
+    readonly registerDynamic: (name: string, factory: () => JSONSchema) => void;
+    /**
+     * Unregister a custom type
+     */
+    readonly unregister: (name: string) => void;
+    /**
+     * Clear all custom and dynamic types (primarily for testing; called by DslBuilder.clearCustomTypes).
+     * Built-in types are unaffected.
+     */
+    readonly clearCustomTypes: () => void;
+    /**
+     * Enable or disable strict mode for type resolution.
+     * In strict mode, resolving an unknown type throws instead of warning and falling back to string.
+     */
+    readonly setStrict: (flag: boolean) => void;
+    /**
+     * Check whether a type is registered (built-in or custom)
+     */
+    readonly has: (typeName: string) => boolean;
+    /**
+     * Return an iterator over all registered types (built-in + custom; custom overrides same-name built-in)
+     * BC-4 compat: consumed by the DslAdapter.typeMap getter
+     */
+    readonly entries: () => IterableIterator<[string, TypeDefinition]>;
+    /**
+     * Return the internal key set (used to strip non-standard fields during toJsonSchema)
+     */
+    readonly getInternalKeys: () => ReadonlySet<string>;
+    /**
+     * Strip internal keys from a schema and return a clean JSON Schema.
+     *
+     * Special case for exactLength: translated to standard minLength + maxLength
+     * instead of being stripped. This preserves v1 DslBuilder string:N behavior
+     * (output {minLength:N, maxLength:N}) while keeping AJV's exactLength Unicode
+     * code-point counting advantage internally (CK-Y04).
+     */
+    readonly toJsonSchema: (schema: JSONSchema) => JSONSchema;
+};
+
+/**
+ * ValidationError — error class thrown when validateAsync() fails.
+ * Fixes v1 bug: malformed message format when errors array is empty.
+ */
+declare class ValidationError extends Error {
+    readonly name: "ValidationError";
+    readonly errors: ValidationErrorItem[];
+    readonly data: unknown;
+    readonly statusCode: number;
+    constructor(errors: ValidationErrorItem[], data?: unknown, statusCode?: number);
+    toJSON(): {
+        error: string;
+        message: string;
+        statusCode: number;
+        details: Array<{
+            field: string | null;
+            message: string;
+            keyword: string;
+            params?: Record<string, unknown>;
+        }>;
+    };
+    getFieldError(field: string): ValidationErrorItem | null;
+    getFieldErrors(): Record<string, string>;
+    hasFieldError(field: string): boolean;
+    getErrorCount(): number;
+}
+
+type ParamsOrLocale = Record<string, unknown> | string | null | undefined;
+/**
+ * Internationalised error class.
+ * Maintains full v1 API compatibility: create / throw / assert / is / toJSON / toString
+ */
+declare class I18nError extends Error {
+    readonly name: "I18nError";
+    readonly originalKey: string;
+    readonly code: string | number;
+    readonly params: Record<string, unknown>;
+    readonly statusCode: number;
+    readonly locale: string | null;
+    constructor(key: string, params?: Record<string, unknown>, statusCode?: number, locale?: string | null, 
+    /** Internal: pre-resolved message template, bypasses Locale lookup (used to decouple init ordering). */
+    _resolvedTemplate?: string, _resolvedCode?: string | number);
+    /** Factory method — create an error instance. */
+    static create(code: string, paramsOrLocale?: ParamsOrLocale, statusCode?: number, locale?: string): I18nError;
+    /** Factory method — create and throw an error. */
+    static throw(code: string, paramsOrLocale?: ParamsOrLocale, statusCode?: number, locale?: string): never;
+    /** Assert — throw when condition is falsy. */
+    static assert(condition: unknown, code: string, paramsOrLocale?: ParamsOrLocale, statusCode?: number, locale?: string): asserts condition;
+    /** Check whether the error matches the given code or original key. */
+    is(codeOrKey: string | number): boolean;
+    toJSON(): {
+        error: string;
+        originalKey: string;
+        code: string | number;
+        message: string;
+        params: Record<string, unknown>;
+        statusCode: number;
+        locale: string | null;
+    };
+    toString(): string;
+}
+
+/**
+ * StringExtensions — opt-in String.prototype chainable DSL extensions.
+ *
+ * v2 fixes:
+ *   S-01/S-02: array-driven symmetric install/uninstall (v1 uninstall was missing `format` and
+ *              `phoneNumber`). All method names are now maintained in the EXTENSION_METHODS
+ *              array so both operations are guaranteed to be in sync.
+ *
+ * @example
+ * import { installStringExtensions } from 'schema-dsl'
+ * installStringExtensions(dsl)
+ * // Then you can use:
+ * 'email!'.label('Email address').messages({ format: 'Invalid format' })
+ * 'string:3-32!'.username('medium')
+ */
+
+type DslFn = (dslStr: string) => DslBuilder;
+/**
+ * Install String.prototype extensions.
+ * @param dslFunction - dsl() function (converts a string to a DslBuilder instance)
+ */
+declare function installStringExtensions$1(dslFunction: DslFn): void;
+/**
+ * Uninstall String.prototype extensions (useful for tests or clean-up).
+ * S-01/S-02 fix: uses EXTENSION_METHODS array to guarantee perfect symmetry with install.
+ */
+declare function uninstallStringExtensions(): void;
+
+/**
+ * BaseExporter — Base interface and abstract class for all exporters.
+ *
+ * Provides a unified abstract export() method signature; each exporter subclass implements it.
+ */
+
+interface ExporterOptions {
+    [key: string]: unknown;
+}
+declare abstract class BaseExporter<TOptions extends ExporterOptions = ExporterOptions> {
+    protected options: TOptions;
+    constructor(options?: Partial<TOptions>);
+    /**
+     * Export a JSON Schema to the target format.
+     * Each subclass must implement this method.
+     */
+    abstract export(...args: unknown[]): unknown;
+    /**
+     * Assert that the input JSON Schema is a valid object-type schema.
+     * @throws Error if invalid.
+     */
+    protected _assertObjectSchema(jsonSchema: unknown, label?: string): asserts jsonSchema is JSONSchema & {
+        type: 'object';
+    };
+    /**
+     * Escape SQL single quotes (generic utility).
+     */
+    protected _escapeString(str: string): string;
+    /**
+     * Detect the primary key column name in a schema (id / _id preferred).
+     */
+    protected _detectPrimaryKey(schema: JSONSchema): string | null;
+}
+
+/**
+ * MongoDBExporter — Export JSON Schema as a MongoDB $jsonSchema validation schema.
+ */
+
+interface MongoDBExporterOptions extends ExporterOptions {
+    /** Whether to use strict mode (validationLevel: 'strict' vs 'moderate'). */
+    strict: boolean;
+}
+interface MongoDBValidationSchema {
+    $jsonSchema: Record<string, unknown>;
+}
+interface MongoDBCreateCommand {
+    collectionName: string;
+    options: {
+        validator: MongoDBValidationSchema;
+        validationLevel: 'strict' | 'moderate';
+        validationAction: 'error' | 'warn';
+    };
+}
+declare class MongoDBExporter extends BaseExporter<MongoDBExporterOptions> {
+    constructor(options?: Partial<MongoDBExporterOptions>);
+    /**
+     * Convert a JSON Schema to a MongoDB $jsonSchema validation schema.
+     */
+    export(jsonSchema: unknown): MongoDBValidationSchema;
+    /**
+     * Generate a db.createCollection() command object.
+     */
+    generateCreateCommand(collectionName: string, jsonSchema: JSONSchema): MongoDBCreateCommand;
+    /**
+     * Generate an executable MongoDB command string.
+     */
+    generateCommand(collectionName: string, jsonSchema: JSONSchema): string;
+    /**
+     * Static quick-export shorthand.
+     */
+    static export(jsonSchema: JSONSchema): MongoDBValidationSchema;
+    private _convertSchema;
+}
+
+/**
+ * MySQLExporter — Export JSON Schema as a MySQL CREATE TABLE DDL statement.
+ *
+ * v2 fixes:
+ *   _escapeString uses standard SQL single-quote escaping (`'` → `''`)
+ *   _convertColumn passes the full schema object to TypeConverter.toMySQLType (includes maxLength etc.)
+ */
+
+interface MySQLExporterOptions extends ExporterOptions {
+    engine: string;
+    charset: string;
+    collate: string;
+}
+interface GenerateIndexOptions {
+    name?: string;
+    unique?: boolean;
+}
+declare class MySQLExporter extends BaseExporter<MySQLExporterOptions> {
+    constructor(options?: Partial<MySQLExporterOptions>);
+    /**
+     * Export as a MySQL CREATE TABLE statement.
+     */
+    export(tableName: string, jsonSchema: JSONSchema): string;
+    /**
+     * Generate a CREATE INDEX statement.
+     */
+    generateIndex(tableName: string, columnName: string, options?: GenerateIndexOptions): string;
+    /**
+     * Static quick-export shorthand.
+     */
+    static export(tableName: string, jsonSchema: JSONSchema): string;
+    private _quoteIdent;
+    private _convertProperties;
+    private _convertColumn;
+    private _resolveColumnType;
+    private _formatDefaultValue;
+}
+
+/**
+ * PostgreSQLExporter — Export JSON Schema as a PostgreSQL CREATE TABLE DDL statement.
+ *
+ * v2 fixes:
+ *   Identifiers are escaped with double quotes (`"identifier"` format) instead of v1's unescaped raw identifiers.
+ *   Column comments use the fully-qualified `"schema"."table"."column"` format.
+ */
+
+interface PostgreSQLExporterOptions extends ExporterOptions {
+    /** PostgreSQL schema name (default: public). */
+    schema: string;
+    /** Whether to wrap identifiers in double quotes (default false — compatible with v1 behaviour). */
+    quoteIdentifiers?: boolean;
+}
+interface GeneratePgIndexOptions {
+    name?: string;
+    unique?: boolean;
+    method?: 'btree' | 'hash' | 'gin' | 'gist';
+}
+declare class PostgreSQLExporter extends BaseExporter<PostgreSQLExporterOptions> {
+    constructor(options?: Partial<PostgreSQLExporterOptions>);
+    /**
+     * Export as a PostgreSQL CREATE TABLE statement.
+     */
+    export(tableName: string, jsonSchema: JSONSchema): string;
+    /**
+     * Generate a CREATE INDEX statement.
+     */
+    generateIndex(tableName: string, columnName: string, options?: GeneratePgIndexOptions): string;
+    /**
+     * Static quick-export shorthand.
+     */
+    static export(tableName: string, jsonSchema: JSONSchema): string;
+    /** Conditionally wrap a PG identifier in double quotes (when quoteIdentifiers=true). */
+    private _quoteIdent;
+    private _convertProperties;
+    private _convertColumn;
+    private _resolveColumnType;
+    private _generateCheckConstraints;
+    private _formatDefaultValue;
+    private _generateColumnComments;
+}
+
+/**
+ * MarkdownExporter — Export JSON Schema as human-readable Markdown documentation.
+ *
+ * v2 fix:
+ *   EX-01: required check prefers prop._required, then falls back to schema.required?.includes(key)
+ *          (v1 already had this logic; v2 preserves it with stronger type safety)
+ *
+ * @version 2.0.0
+ */
+
+interface MarkdownExporterOptions extends ExporterOptions {
+    title?: string;
+    locale?: 'zh-CN' | 'en-US' | 'ja-JP' | 'fr-FR' | 'es-ES';
+    includeExample?: boolean;
+    includeDescription?: boolean;
+}
+declare class MarkdownExporter extends BaseExporter<MarkdownExporterOptions> {
+    constructor(options?: Partial<MarkdownExporterOptions>);
+    /**
+     * Export as a Markdown document.
+     */
+    export(schema: JSONSchema, options?: Partial<MarkdownExporterOptions>): string;
+    /**
+     * Static method: export directly without instantiation.
+     */
+    static export(schema: JSONSchema, options?: Partial<MarkdownExporterOptions>): string;
+    private static _i18nFields;
+    private static _i18nTypes;
+    private static _i18nConstraints;
+    private static _i18nRules;
+    private static _generateFieldsTable;
+    private static _escapeTableCell;
+    private static _formatType;
+    private static _formatConstraints;
+    private static _getDescription;
+    private static _generateExample;
+    private static _buildExample;
+    private static _getExampleValue;
+    private static _generateConstraintsSection;
+}
+
+/**
+ * src/exporters/index.ts — Unified re-export for all exporters
+ */
+
+type _exporters_BaseExporter<TOptions extends ExporterOptions = ExporterOptions> = BaseExporter<TOptions>;
+declare const _exporters_BaseExporter: typeof BaseExporter;
+type _exporters_ExporterOptions = ExporterOptions;
+type _exporters_GenerateIndexOptions = GenerateIndexOptions;
+type _exporters_GeneratePgIndexOptions = GeneratePgIndexOptions;
+type _exporters_MarkdownExporter = MarkdownExporter;
+declare const _exporters_MarkdownExporter: typeof MarkdownExporter;
+type _exporters_MarkdownExporterOptions = MarkdownExporterOptions;
+type _exporters_MongoDBCreateCommand = MongoDBCreateCommand;
+type _exporters_MongoDBExporter = MongoDBExporter;
+declare const _exporters_MongoDBExporter: typeof MongoDBExporter;
+type _exporters_MongoDBExporterOptions = MongoDBExporterOptions;
+type _exporters_MongoDBValidationSchema = MongoDBValidationSchema;
+type _exporters_MySQLExporter = MySQLExporter;
+declare const _exporters_MySQLExporter: typeof MySQLExporter;
+type _exporters_MySQLExporterOptions = MySQLExporterOptions;
+type _exporters_PostgreSQLExporter = PostgreSQLExporter;
+declare const _exporters_PostgreSQLExporter: typeof PostgreSQLExporter;
+type _exporters_PostgreSQLExporterOptions = PostgreSQLExporterOptions;
+declare namespace _exporters {
+  export { _exporters_BaseExporter as BaseExporter, type _exporters_ExporterOptions as ExporterOptions, type _exporters_GenerateIndexOptions as GenerateIndexOptions, type _exporters_GeneratePgIndexOptions as GeneratePgIndexOptions, _exporters_MarkdownExporter as MarkdownExporter, type _exporters_MarkdownExporterOptions as MarkdownExporterOptions, type _exporters_MongoDBCreateCommand as MongoDBCreateCommand, _exporters_MongoDBExporter as MongoDBExporter, type _exporters_MongoDBExporterOptions as MongoDBExporterOptions, type _exporters_MongoDBValidationSchema as MongoDBValidationSchema, _exporters_MySQLExporter as MySQLExporter, type _exporters_MySQLExporterOptions as MySQLExporterOptions, _exporters_PostgreSQLExporter as PostgreSQLExporter, type _exporters_PostgreSQLExporterOptions as PostgreSQLExporterOptions };
+}
+
+/**
+ * TypeConverter — Schema type conversion utilities (static methods).
+ *
+ * Maps JSON Schema types to target-format types:
+ *   - JSON Schema type
+ *   - MongoDB BSON type
+ *   - MySQL column type
+ *   - PostgreSQL column type
+ *
+ * Also includes format helpers: normalizePropertyName, formatToRegex, mergeSchemas, extractConstraints.
+ */
+
+type JSType = string | string[];
+declare class TypeConverter {
+    static toJSONSchemaType(nativeType: string): string;
+    static toMongoDBType(jsonSchemaType: JSType): string;
+    static toMySQLType(jsonSchemaType: JSType, schema?: JSONSchema): string;
+    static toPostgreSQLType(jsonSchemaType: JSType, schema?: JSONSchema): string;
+    static normalizePropertyName(name: string): string;
+    static formatToRegex(format: string): RegExp | null;
+    static mergeSchemas(...schemas: JSONSchema[]): JSONSchema;
+    static extractConstraints(schema: JSONSchema): Record<string, unknown>;
+}
+
+/**
+ * SchemaHelper — Schema utility functions.
+ *
+ * Common helpers for JSON Schema structure manipulation:
+ *   isValidSchema, generateSchemaId, cloneSchema, flattenSchema,
+ *   getFieldPaths, extractRequiredFields, compareSchemas, simplifySchema,
+ *   isValidPropertyName, getSchemaComplexity, summarizeSchema
+ */
+
+declare class SchemaHelper {
+    /**
+     * Check whether the value is a valid JSON Schema (must contain at least one of: type / properties / items / $ref).
+     */
+    static isValidSchema(schema: unknown): schema is JSONSchema;
+    /**
+     * Generate a content-hash-based unique ID for a schema.
+     */
+    static generateSchemaId(schema: JSONSchema): string;
+    /**
+     * Deep-clone a schema via JSON serialisation (Function/RegExp fields are not preserved).
+     */
+    static cloneSchema(schema: JSONSchema): JSONSchema;
+    /**
+     * Flatten a nested schema into dot-separated path form.
+     * @param prefix - Property path prefix.
+     */
+    static flattenSchema(schema: JSONSchema, prefix?: string): Record<string, JSONSchema>;
+    /**
+     * Get all field paths in a schema (including nested object and array paths).
+     */
+    static getFieldPaths(schema: JSONSchema): string[];
+    /**
+     * Extract all required fields from a schema (including nested paths).
+     */
+    static extractRequiredFields(schema: JSONSchema): string[];
+    /**
+     * Shallow-compare two schemas for equality (via JSON serialisation).
+     */
+    static compareSchemas(schema1: JSONSchema, schema2: JSONSchema): boolean;
+    /**
+     * Simplify a schema by removing $schema, empty properties, and empty required arrays.
+     */
+    static simplifySchema(schema: JSONSchema): JSONSchema;
+    /**
+     * Validate that a property name is legal (letters/digits/underscores/hyphens; must start with a letter or underscore).
+     */
+    static isValidPropertyName(name: string): boolean;
+    /**
+     * Get the maximum nesting depth (complexity) of a schema.
+     */
+    static getSchemaComplexity(schema: JSONSchema): number;
+    /**
+     * Generate a summary of schema metadata.
+     */
+    static summarizeSchema(schema: JSONSchema): {
+        type: string;
+        fieldCount: number;
+        requiredCount: number;
+        complexity: number;
+        hasNested: boolean;
+        fields: string[];
+    };
+}
+
+/**
+ * SchemaUtils — Advanced schema operations (reuse, merge, extend, performance monitoring)
+ *
+ * v2 note: v1's extend/validateBatch used require('../adapters/DslAdapter'),
+ *          v2 uses dynamic import or accepts pre-compiled schema directly (avoids circular deps)
+ */
+
+interface ChainableSchema extends JSONSchema {
+    _isChainable: true;
+    partial(fields?: string[]): ChainableSchema;
+    pick(fields: string[]): ChainableSchema;
+    omit(fields: string[]): ChainableSchema;
+    extend(extensions: Record<string, unknown>): ChainableSchema;
+}
+declare class SchemaUtils {
+    /**
+     * Create a reusable schema factory.
+     * @example const emailField = SchemaUtils.reusable(() => dsl('email!').label('email'))
+     */
+    static reusable<T>(factory: () => T): () => T;
+    /**
+     * Create a schema fragment library.
+     * @example const fields = SchemaUtils.createLibrary({ email: () => dsl('email!') })
+     */
+    static createLibrary<T extends Record<string, () => unknown>>(fragments: T): T;
+    /**
+     * Extend a schema (like inheritance) — merges extension fields into the base schema.
+     */
+    static extend(baseSchema: JSONSchema, extensions: JSONSchema | Record<string, unknown>): ChainableSchema;
+    /**
+     * Pick a subset of fields from a schema.
+     */
+    static pick(schema: JSONSchema, fields: string[]): ChainableSchema;
+    /**
+     * Omit fields from a schema.
+     */
+    static omit(schema: JSONSchema, fields: string[]): ChainableSchema;
+    /**
+     * Make all fields optional (removes required).
+     * @param fields - optional; only process these fields (others remain unchanged)
+     */
+    static partial(schema: JSONSchema, fields?: string[] | null): ChainableSchema;
+    /**
+     * Wrap a Validator instance with performance monitoring.
+     */
+    static withPerformance<V extends {
+        validate: (...args: unknown[]) => unknown;
+    }>(validator: V): V;
+    /**
+     * Batch validate using a pre-compiled Ajv validate function.
+     */
+    static validateBatch(schema: JSONSchema, dataArray: unknown[], ajvInstance: {
+        compile: (schema: JSONSchema) => (data: unknown) => boolean;
+    } & {
+        errors?: unknown;
+    }): {
+        results: Array<{
+            index: number;
+            valid: boolean;
+            errors: unknown;
+            data: unknown;
+        }>;
+        summary: {
+            total: number;
+            valid: number;
+            invalid: number;
+            duration: number;
+            averageTime: number;
+        };
+    };
+    static toMarkdown(schema: JSONSchema, options?: {
+        title?: string;
+    }): string;
+    static clone(schema: JSONSchema): JSONSchema;
+    /**
+     * toHTML — v1 compat: export schema as HTML document
+     */
+    static toHTML(schema: JSONSchema, options?: {
+        title?: string;
+    }): string;
+    private static _mergeProperties;
+    private static _deleteRequired;
+    private static _clone;
+    private static _makeChainable;
+    private static _extractSchema;
+}
+
+/**
+ * CustomKeywords — AJV custom keyword registrar
+ *
+ * Fixes:
+ *   CK-01: internally uses getMessageText() to obtain strings, avoiding v1 compat objects
+ *          that serialized as "[object Object]"
+ *   CK-02: regex keyword error messages use locale keys instead of concatenating raw messages
+ *   CK-Y04: exactLength uses Unicode code-point counting ([...str].length) instead of
+ *           str.length, correctly handling emoji and multi-byte characters
+ */
+declare class CustomKeywords {
+    /**
+     * Register all custom keywords on an AJV instance
+     */
+    static registerAll(ajv: Ajv): void;
+    static registerMetadataKeywords(ajv: Ajv): void;
+    static registerCustomValidatorsKeyword(ajv: Ajv): void;
+    private static _isUnsafePattern;
+    static registerRegexKeyword(ajv: Ajv): void;
+    static registerFunctionKeyword(ajv: Ajv): void;
+    static registerStringValidators(ajv: Ajv): void;
+    static registerNumberValidators(ajv: Ajv): void;
+    static registerObjectValidators(ajv: Ajv): void;
+    private static _deepEqual;
+    static registerArrayValidators(ajv: Ajv): void;
+    static registerDateValidators(ajv: Ajv): void;
+}
+
+/**
+ * Global constants.
+ * Fixes:
+ *   CF-01 IPv4 regex too permissive → replaced with RFC-compliant standard regex
+ *   CF-02 IPv6 regex did not support compressed notation → replaced with full RFC 5952 compatible regex
+ */
+declare const VALIDATION: {
+    readonly MAX_RECURSION_DEPTH: 100;
+    readonly MAX_ARRAY_SIZE: 100000;
+    readonly MAX_STRING_LENGTH: 1000000;
+    readonly MAX_OBJECT_KEYS: 10000;
+    readonly DEFAULT_TIMEOUT: 5000;
+    readonly REGEX_TIMEOUT: 100;
+    readonly CUSTOM_VALIDATOR_TIMEOUT: 1000;
+};
+declare const CACHE: {
+    readonly ENABLED: true;
+    readonly SCHEMA_CACHE: {
+        readonly MAX_SIZE: 5000;
+        readonly TTL: 3600000;
+        readonly STRATEGY: "LRU";
+    };
+    readonly STATS_ENABLED: true;
+};
+declare const PATTERN_IPV4: RegExp;
+declare const PATTERN_IPV6: RegExp;
+declare const FORMATS: {
+    readonly BUILT_IN: readonly ["email", "url", "uri", "uuid", "ipv4", "ipv6", "hostname", "date", "date-time", "time", "regex", "json"];
+    readonly PATTERNS: {
+        readonly email: RegExp;
+        readonly uuid: RegExp;
+        readonly ipv4: RegExp;
+        readonly ipv6: RegExp;
+        readonly hostname: RegExp;
+        readonly dateTime: RegExp;
+        readonly date: RegExp;
+        readonly time: RegExp;
+    };
+};
+declare const PLUGINS: {
+    readonly MAX_PLUGINS: 50;
+    readonly NAMING_CONVENTION: RegExp;
+};
+
+declare const _CONSTANTS_CACHE: typeof CACHE;
+declare const _CONSTANTS_FORMATS: typeof FORMATS;
+declare const _CONSTANTS_PATTERN_IPV4: typeof PATTERN_IPV4;
+declare const _CONSTANTS_PATTERN_IPV6: typeof PATTERN_IPV6;
+declare const _CONSTANTS_PLUGINS: typeof PLUGINS;
+declare const _CONSTANTS_VALIDATION: typeof VALIDATION;
+declare namespace _CONSTANTS {
+  export { _CONSTANTS_CACHE as CACHE, _CONSTANTS_FORMATS as FORMATS, _CONSTANTS_PATTERN_IPV4 as PATTERN_IPV4, _CONSTANTS_PATTERN_IPV6 as PATTERN_IPV6, _CONSTANTS_PLUGINS as PLUGINS, _CONSTANTS_VALIDATION as VALIDATION };
+}
+
+/**
+ * Error code constants.
+ * Defines all built-in error codes used by ErrorFormatter and Locale.
+ */
+declare const ErrorCodes: ErrorCodeMap;
+
+/**
+ * Built-in regex validation patterns (migrated from v1 lib/config/patterns/ to a single TypeScript file)
+ */
+interface PatternConfig {
+    pattern: RegExp;
+    min?: number;
+    max?: number;
+    key: string;
+}
+declare const PATTERNS: {
+    phone: Record<string, PatternConfig>;
+    idCard: Record<string, PatternConfig>;
+    creditCard: Record<string, PatternConfig>;
+    licensePlate: Record<string, PatternConfig>;
+    postalCode: Record<string, PatternConfig>;
+    passport: Record<string, PatternConfig>;
+    common: Record<string, PatternConfig>;
+};
+
+type StripMarker<S extends string> = S extends `${infer Base}!` | `${infer Base}?` ? Base : S;
+type KnownDslType = 'string' | 'email' | 'url' | 'uri' | 'uuid' | 'ipv4' | 'ipv6' | 'ip' | 'hostname' | 'date' | 'datetime' | 'time' | 'binary' | 'objectId' | 'hexColor' | 'macAddress' | 'cron' | 'slug' | 'chineseName' | 'chinese' | 'emailDomain' | 'alphanum' | 'lower' | 'upper' | 'json' | 'port' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null' | 'any';
+type InferPipeMember<S extends string> = StripMarker<S> extends KnownDslType ? InferDslString<S> : StripMarker<S>;
+type SplitPipe<S extends string> = S extends `${infer Head}|${infer Tail}` ? InferPipeMember<Head> | SplitPipe<Tail> : InferPipeMember<S>;
+type RequiredDslKeys<T extends Record<string, unknown>> = {
+    [K in keyof T]: K extends string ? K extends `${infer Name}!` ? Name : T[K] extends `${string}!` ? K : never : never;
+}[keyof T];
+type CleanDslKey<K> = K extends `${infer Name}!` | `${infer Name}?` ? Name : K;
+type InferJsonSchemaProperties<Properties, RequiredKeys extends PropertyKey> = {
+    [K in keyof Properties as K extends RequiredKeys ? K : never]-?: InferSchema<Properties[K]>;
+} & {
+    [K in keyof Properties as K extends RequiredKeys ? never : K]?: InferSchema<Properties[K]>;
+};
+type InferDslProperties<T extends Record<string, unknown>, RequiredKeys extends PropertyKey = RequiredDslKeys<T>> = {
+    [K in keyof T as CleanDslKey<K> extends RequiredKeys ? CleanDslKey<K> : never]-?: InferSchema<T[K]>;
+} & {
+    [K in keyof T as CleanDslKey<K> extends RequiredKeys ? never : CleanDslKey<K>]?: InferSchema<T[K]>;
+};
+type InferDslString<T extends string> = StripMarker<T> extends `types:${infer Rest}` ? SplitPipe<Rest> : StripMarker<T> extends `enum:${infer Values}` ? SplitPipe<Values> : StripMarker<T> extends `array<${infer Item}>` ? InferDslString<Item>[] : StripMarker<T> extends `${infer Base}:${string}` ? InferDslString<Base> : StripMarker<T> extends 'number' | 'integer' | 'port' ? number : StripMarker<T> extends 'boolean' ? boolean : StripMarker<T> extends 'object' ? Record<string, unknown> : StripMarker<T> extends 'array' ? unknown[] : StripMarker<T> extends 'null' ? null : StripMarker<T> extends 'any' ? unknown : StripMarker<T> extends `${string}|${string}` ? SplitPipe<StripMarker<T>> : string;
+type InferJsonSchema<T> = T extends {
+    oneOf: readonly (infer Variant)[];
+} ? InferSchema<Variant> : T extends {
+    anyOf: readonly (infer Variant)[];
+} ? InferSchema<Variant> : T extends {
+    enum: readonly (infer Value)[];
+} ? Value : T extends {
+    type: 'object';
+    properties: infer Properties;
+    required?: readonly (infer RequiredKey)[];
+} ? InferJsonSchemaProperties<Properties, Extract<RequiredKey, keyof Properties>> : T extends {
+    type: 'array';
+    items: infer Item;
+} ? InferSchema<Item>[] : T extends {
+    type: 'number' | 'integer';
+} ? number : T extends {
+    type: 'boolean';
+} ? boolean : T extends {
+    type: 'null';
+} ? null : T extends {
+    type: 'object';
+} ? Record<string, unknown> : T extends {
+    type: 'array';
+} ? unknown[] : T extends {
+    type: 'string';
+} ? string : unknown;
+type InferDslDefinition<T extends Record<string, unknown>> = InferDslProperties<T>;
+type InferSchema<T> = T extends string ? InferDslString<T> : T extends {
+    type: unknown;
+} | {
+    properties: unknown;
+} | {
+    oneOf: unknown;
+} | {
+    anyOf: unknown;
+} | {
+    enum: unknown;
+} ? InferJsonSchema<T> : T extends Record<string, unknown> ? InferDslDefinition<T> : unknown;
+
+/**
+ * schema-dsl v2 — main entry point
+ *
+ * Fix IX-01: VERSION is read dynamically from package.json instead of being hard-coded
+ *
+ * @module schema-dsl
+ * @version 2.0.0
+ */
+declare const VERSION: string;
+
+declare const CONSTANTS: typeof _CONSTANTS;
+declare const exporters: typeof _exporters;
+declare function _dslConfig(options?: Partial<DslConfigOptions>): void;
+declare function _getDefaultValidator(): InstanceType<typeof Validator>;
+
+/**
+ * Reset the default Validator singleton (useful for cleaning up state in test environments)
+ */
+declare function resetDefaultValidator(): void;
+/**
+ * Reset global runtime state that may leak across tests, workers, or tenants.
+ */
+declare function resetRuntimeState(): void;
+/**
+ * Convenience validate function (uses the default Validator singleton).
+ * Automatically coerces string → number when options.coerce !== false.
+ */
+declare function validate<T = unknown>(schema: JSONSchema | DslDefinition | IDslBuilder | IConditionalBuilder, data: T, options?: Record<string, unknown>): ValidationResult<T>;
+/**
+ * Convenience async validate function
+ */
+declare function validateAsync<T = unknown>(schema: JSONSchema | DslDefinition | IDslBuilder | IConditionalBuilder, data: T, options?: Record<string, unknown>): Promise<T>;
+/**
+ * dsl — main API entry point
+ *
+ * @example
+ * // String DSL → DslBuilder (chainable)
+ * const builder = dsl('email!').label('Email address')
+ *
+ * @example
+ * // Object DSL → JSON Schema
+ * const schema = dsl({ email: 'email!', name: 'string:2-32!' })
+ */
+declare const dsl: {
+    (def: string): IDslBuilder;
+    (def: DslDefinition): JSONSchema;
+    config: (options?: Partial<DslConfigOptions>) => void;
+    if: {
+        (condition: string, thenSchema: unknown, elseSchema?: unknown): DslConditionMarker;
+        (condition: (data: unknown) => boolean): ReturnType<typeof ConditionalBuilder.start>;
+    };
+    _if: {
+        (condition: string, thenSchema: unknown, elseSchema?: unknown): DslConditionMarker;
+        (condition: (data: unknown) => boolean): ReturnType<typeof ConditionalBuilder.start>;
+    };
+    match: (value: unknown, cases: Record<string, unknown>) => DslConditionMarker;
+    error: {
+        create: typeof I18nError.create;
+        throw: typeof I18nError.throw;
+        assert: typeof I18nError.assert;
+        [key: string]: unknown;
+    };
+};
+
+declare const config: typeof _dslConfig;
+declare function installStringExtensions(dslFunction?: Parameters<typeof installStringExtensions$1>[0]): void;
+
+export { BaseExporter, CACHE, CONSTANTS, ConditionalBuilder, CustomKeywords, DslBuilder, DslConditionMarker, DslConfigOptions, DslDefinition, ErrorCodes, ErrorFormatter, type ExporterOptions, FORMATS, I18nError, IConditionalBuilder, IDslBuilder, type InferDslDefinition, type InferDslString, type InferJsonSchema, type InferSchema, JSONSchema, JSONSchemaCore, Locale, MarkdownExporter, type MarkdownExporterOptions, MessageTemplate, MongoDBExporter, type MongoDBExporterOptions, MySQLExporter, type MySQLExporterOptions, ObjectDslBuilder, PATTERNS, PATTERN_IPV4, PATTERN_IPV6, PluginManager, PostgreSQLExporter, type PostgreSQLExporterOptions, SchemaHelper, SchemaUtils, TypeConverter, TypeRegistry, VALIDATION, VERSION, ValidationError, ValidationErrorItem, ValidationResult, Validator, config, dsl as default, dsl, exporters, _getDefaultValidator as getDefaultValidator, installStringExtensions, renderTemplate, resetDefaultValidator, resetRuntimeState, uninstallStringExtensions, validate, validateAsync };