@oxog/vld 2.0.2 → 2.0.3

package/dist/index.js

@@ -1,17 +1,17 @@
-import { h as VldPreprocess, g as VldNullish, f as VldNullable, e as VldOptional, d as VldBigInt, c as VldDate, b as VldBoolean, a as VldNumber, V as VldString } from './chunks/bigint-DgsCr2dC.js';
-export { i as VldBase, r as getLocale, t as getMessages, s as setLocale } from './chunks/bigint-DgsCr2dC.js';
-import { u as VldJson, t as VldLazy, p as VldNever, s as VldNan, r as VldUndefined, q as VldNull, o as VldVoid, n as VldAny, m as VldEnum, l as VldLiteral, k as VldXor, j as VldDiscriminatedUnion, i as VldIntersection, h as VldUnion, g as VldMap, f as VldSet, e as VldRecord, d as VldTuple, c as VldObject, b as VldArray, a as VldStringBool, V as VldSymbol } from './chunks/json-o20GFhTh.js';
-import { V as VldUnknown } from './chunks/unknown-SLIH1VCf.js';
-import { t as templateLiteral, s as stringFormat, i as iso, h as hash, e as e164, c as cidrv6, a as cidrv4, m as mac, b as ipv6, d as ipv4, u as ulid, f as cuid2, g as cuid, n as nanoid, j as jwt, k as hex, l as base64url, o as base64, p as emoji, q as hostname, r as uuidv4, v as uuid, w as email, x as functionValidator, y as file, z as custom } from './chunks/index-BZqWZvVe.js';
-import { V as VldCodec, a as VldUint8Array, b as VldHex, c as VldBase64 } from './chunks/index-CETyGkrv.js';
-export { D as base64Json, w as base64ToBytes, d as base64ToUint8Array, x as base64UrlToBytes, y as base64urlToBytes, C as bytesToUtf8, p as epochMillisToDate, o as epochSecondsToDate, A as hexLowerToBytes, z as hexToBytes, h as hexToUint8Array, m as isoDatetimeToDate, q as jsonCodec, E as jwtPayload, n as numberToBigInt, k as stringToBigInt, l as stringToBoolean, t as stringToHttpURL, j as stringToInt, i as stringToNumber, r as stringToURL, s as stringToUint8Array, u as uint8ArrayToBase64, e as uint8ArrayToBase64Url, f as uint8ArrayToHex, g as uint8ArrayToString, v as uriComponent, B as utf8ToBytes } from './chunks/index-CETyGkrv.js';
-import { V as VldCoerceDate, a as VldCoerceBoolean, b as VldCoerceNumber, c as VldCoerceString } from './chunks/date-ODue_rtq.js';
+import { g as VldPreprocess, r as VldExactOptional, e as VldNullish, d as VldNullable, f as VldOptional, V as VldBigInt, b as VldDate, a as VldBoolean, c as VldNumber, h as VldString } from './chunks/bigint-CRS0QVsy.js';
+export { i as VldBase, s as VldMeta, t as getLocale, u as getMessages, v as setLocale } from './chunks/bigint-CRS0QVsy.js';
+import { f as VldJson, g as VldLazy, V as VldNever, l as VldNan, r as VldUndefined, m as VldNull, t as VldVoid, a as VldAny, d as VldEnum, h as VldLiteral, u as VldXor, c as VldDiscriminatedUnion, e as VldIntersection, s as VldUnion, k as VldMap, n as VldSet, j as VldRecord, q as VldTuple, i as VldObject, b as VldArray, o as VldStringBool, p as VldSymbol } from './chunks/json-Cp4WO0M9.js';
+import { V as VldUnknown } from './chunks/unknown-Dhzri_T-.js';
+import { promise, templateLiteral, httpUrl, guid, xid, stringFormat, iso, hash, e164, cidrv6, cidrv4, mac, ipv6, ipv4, ulid, cuid2, cuid, nanoid, jwt, hex, base64url, base64, emoji, hostname, uuidv4, uuid, email, functionValidator, file, custom } from './validators/index.js';
+import { V as VldCodec, a as VldUint8Array, b as VldHex, c as VldBase64 } from './chunks/index-DO8CFMxD.js';
+export { d as base64Json, e as base64ToBytes, f as base64ToUint8Array, g as base64UrlToBytes, h as base64urlToBytes, i as bytesToUtf8, j as epochMillisToDate, k as epochSecondsToDate, l as hexLowerToBytes, m as hexToBytes, n as hexToUint8Array, o as isoDatetimeToDate, p as jsonCodec, q as jwtPayload, r as numberToBigInt, s as stringToBigInt, t as stringToBoolean, u as stringToHttpURL, v as stringToInt, w as stringToNumber, x as stringToURL, y as stringToUint8Array, z as uint8ArrayToBase64, A as uint8ArrayToBase64Url, B as uint8ArrayToHex, C as uint8ArrayToString, D as uriComponent, E as utf8ToBytes } from './chunks/index-DO8CFMxD.js';
+import { V as VldCoerceDate, a as VldCoerceBoolean, b as VldCoerceNumber, c as VldCoerceString } from './chunks/date-50JV_Mfj.js';
 import { VldCoerceBigInt } from './coercion/index.js';
 export { VldError, flattenError, prettifyError, prettifyErrorColored, prettifyErrorPlain, treeifyError } from './errors.js';
 export { Err, Ok, ResultUtils, all, failure, flatMap, fromNullable, isErr, isOk, isResult, map, mapErr, match, success, tryCatch, tryCatchAsync, unwrap, unwrapOr } from './compat/result.js';
 export { createEmitter, createEventBus, withEmitter } from './compat/emitter.js';
 export { createVldKernel, definePlugin, getVldKernel, resetVldKernel, usePlugin } from './kernel.js';
-export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from './pigment.js';
+export { blue, bold, createTheme, cyan, dim, gray, green, grey, italic, magenta, default as pigment, red, strip, supportsColor, underline, vldTheme, white, yellow } from './pigment.js';
 
 /**
  * VLD Logger
@@ -191,6 +191,533 @@ function createNoOpLogger() {
     return createLogger({ level: 'silent' });
 }
 
+/**
+ * JSON Schema support for VLD validators
+ * Provides conversion between VLD schemas and JSON Schema
+ */
+/**
+ * Convert a VLD schema to JSON Schema
+ * @param schema The VLD schema to convert
+ * @param options Conversion options
+ * @returns JSON Schema definition
+ */
+function toJSONSchema(schema, options = {}) {
+    return schemaToJSONSchema(schema, options);
+}
+/**
+ * Convert a JSON Schema to a VLD schema
+ * @param json The JSON Schema definition
+ * @returns A VLD schema
+ */
+function fromJSONSchema(json) {
+    return jsonSchemaToVLD(json);
+}
+/**
+ * Internal function to convert VLD schema to JSON Schema
+ */
+function schemaToJSONSchema(schema, options) {
+    // Handle primitives
+    if (schema.constructor.name === 'VldString') {
+        return buildStringSchema();
+    }
+    if (schema.constructor.name === 'VldNumber') {
+        return buildNumberSchema(schema);
+    }
+    if (schema.constructor.name === 'VldBoolean') {
+        return { type: 'boolean' };
+    }
+    if (schema.constructor.name === 'VldBigInt') {
+        return { type: 'integer' };
+    }
+    if (schema.constructor.name === 'VldDate') {
+        return { type: 'string', format: 'date-time' };
+    }
+    if (schema.constructor.name === 'VldArray') {
+        return buildArraySchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldObject') {
+        return buildObjectSchema(schema, options);
+    }
+    // Handle union types
+    if (schema.constructor.name === 'VldUnion') {
+        return buildUnionSchema(schema, options);
+    }
+    // Handle literal types
+    if (schema.constructor.name === 'VldLiteral') {
+        return buildLiteralSchema(schema);
+    }
+    if (schema.constructor.name === 'VldEnum') {
+        return buildEnumSchema(schema);
+    }
+    if (schema.constructor.name === 'VldRecord') {
+        return buildRecordSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldTuple') {
+        return buildTupleSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldIntersection') {
+        return buildIntersectionSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldOptional') {
+        return buildOptionalSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldNullable') {
+        return buildNullableSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldNullish') {
+        return buildNullishSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldExactOptional') {
+        return buildExactOptionalSchema(schema, options);
+    }
+    if (schema.constructor.name === 'VldLazy') {
+        return { type: 'object' }; // Placeholder for recursive schemas
+    }
+    if (schema.constructor.name === 'VldJson') {
+        return {}; // Any JSON
+    }
+    if (schema.constructor.name === 'VldAny') {
+        return {}; // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldUnknown') {
+        return {}; // JSON Schema true
+    }
+    if (schema.constructor.name === 'VldNever') {
+        return { not: {} }; // JSON Schema false
+    }
+    if (schema.constructor.name === 'VldNull') {
+        return { type: 'null' };
+    }
+    if (schema.constructor.name === 'VldUndefined') {
+        return { not: {} }; // Undefined can't be represented in JSON Schema
+    }
+    if (schema.constructor.name === 'VldNan') {
+        return { type: 'number', not: {} }; // NaN is a number type constraint
+    }
+    if (schema.constructor.name === 'VldVoid') {
+        return { not: {} }; // Void/undefined can't be represented
+    }
+    // Handle branded types - unwrap and continue
+    if (schema.constructor.name === 'VldBrand') {
+        return schemaToJSONSchema(schema.baseValidator, options);
+    }
+    // Handle readonly types
+    if (schema.constructor.name === 'VldReadonly') {
+        return schemaToJSONSchema(schema.baseValidator, options);
+    }
+    // Handle transform types
+    if (schema.constructor.name === 'VldTransform') {
+        return schemaToJSONSchema(schema._inner, options);
+    }
+    // Handle meta types - unwrap metadata
+    if (schema.constructor.name === 'VldMeta') {
+        const metaSchema = schema;
+        const result = schemaToJSONSchema(metaSchema.baseValidator, options);
+        if (options.includeMetadata !== false && metaSchema.metadata) {
+            const meta = metaSchema.metadata;
+            if (meta.title)
+                result.title = meta.title;
+            if (meta.description)
+                result.description = meta.description;
+            if (meta.examples && options.includeExamples)
+                result.examples = meta.examples;
+            if (meta.default !== undefined)
+                result.default = meta.default;
+            if (meta.deprecated)
+                result.deprecated = true;
+            if (meta.readOnly)
+                result.readOnly = true;
+            if (meta.writeOnly)
+                result.writeOnly = true;
+        }
+        return result;
+    }
+    // Handle refine/superRefine types
+    if (schema.constructor.name === 'VldRefine' || schema.constructor.name === 'VldSuperRefine') {
+        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+    }
+    // Handle pipe types
+    if (schema.constructor.name === 'VldPipe') {
+        return schemaToJSONSchema(schema._next || schema.second, options);
+    }
+    // Handle default/catch types
+    if (schema.constructor.name === 'VldDefault' || schema.constructor.name === 'VldCatch') {
+        return schemaToJSONSchema(schema._inner || schema._baseValidator, options);
+    }
+    // Handle preprocess types
+    if (schema.constructor.name === 'VldPreprocess') {
+        return schemaToJSONSchema(schema._schema, options);
+    }
+    // Handle string format validators
+    if (schema.constructor.name === 'VldStringFormat') {
+        const formatSchema = schema;
+        return { type: 'string', format: formatSchema._format };
+    }
+    // Fallback for unknown types
+    return {};
+}
+/**
+ * Build string JSON Schema
+ */
+function buildStringSchema(_target) {
+    return { type: 'string' };
+}
+/**
+ * Build number JSON Schema from VLD number schema
+ */
+function buildNumberSchema(schema, _target) {
+    const config = schema.config || {};
+    const checks = config.checks || [];
+    const result = { type: 'number' };
+    for (const check of checks) {
+        // Try to extract constraints from closures
+        const checkStr = check.toString();
+        if (checkStr.includes('>=') || checkStr.includes('min')) {
+            result.minimum = 0; // Default, actual value is in closure
+        }
+        if (checkStr.includes('<=') || checkStr.includes('max')) {
+            result.maximum = 0; // Default, actual value is in closure
+        }
+        if (checkStr.includes('isInteger') || checkStr.includes('int')) {
+            result.type = 'integer';
+        }
+        if (checkStr.includes('isSafeInteger')) {
+            result.type = 'integer';
+        }
+        if (checkStr.includes('Number.isFinite')) ;
+    }
+    return result;
+}
+/**
+ * Build array JSON Schema
+ */
+function buildArraySchema(schema, options) {
+    const inner = schema._item || schema._inner;
+    if (inner) {
+        return {
+            type: 'array',
+            items: toJSONSchema(inner, options)
+        };
+    }
+    return { type: 'array' };
+}
+/**
+ * Build object JSON Schema
+ */
+function buildObjectSchema(schema, options) {
+    const shape = schema._shape || schema.shape;
+    if (!shape)
+        return { type: 'object' };
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+        properties[key] = toJSONSchema(value, options);
+        // VLD objects require all keys by default
+        if (schema._strict !== false) {
+            required.push(key);
+        }
+    }
+    const result = {
+        type: 'object',
+        properties
+    };
+    if (required.length > 0) {
+        result.required = required;
+    }
+    // Handle passthrough mode
+    if (schema._passthrough || schema._loose) {
+        result.additionalProperties = true;
+    }
+    else if (schema._strict) {
+        result.additionalProperties = false;
+    }
+    return result;
+}
+/**
+ * Build union JSON Schema
+ */
+function buildUnionSchema(schema, options) {
+    const validators = schema._validators || schema._options || [];
+    return {
+        anyOf: validators.map((v) => toJSONSchema(v, options))
+    };
+}
+/**
+ * Build literal JSON Schema
+ */
+function buildLiteralSchema(schema) {
+    const value = schema._value || schema.value;
+    if (value === null)
+        return { type: 'null' };
+    if (typeof value === 'string')
+        return { type: 'string', const: value };
+    if (typeof value === 'number')
+        return { type: 'number', const: value };
+    if (typeof value === 'boolean')
+        return { type: 'boolean', const: value };
+    return { const: value };
+}
+/**
+ * Build enum JSON Schema
+ */
+function buildEnumSchema(schema) {
+    const values = schema._values || schema.values;
+    if (Array.isArray(values)) {
+        return { enum: [...values] };
+    }
+    return {};
+}
+/**
+ * Build record JSON Schema
+ */
+function buildRecordSchema(schema, options) {
+    const valueValidator = schema._value || schema._inner;
+    if (valueValidator) {
+        return {
+            type: 'object',
+            additionalProperties: toJSONSchema(valueValidator, options)
+        };
+    }
+    return { type: 'object' };
+}
+/**
+ * Build tuple JSON Schema
+ */
+function buildTupleSchema(schema, options) {
+    const items = schema._items || schema.items;
+    if (!items || !Array.isArray(items)) {
+        return { type: 'array' };
+    }
+    return {
+        type: 'array',
+        items: items.map((item) => toJSONSchema(item, options)),
+        minItems: items.length,
+        maxItems: items.length
+    };
+}
+/**
+ * Build intersection JSON Schema
+ */
+function buildIntersectionSchema(schema, options) {
+    const first = schema._first || schema.first;
+    const second = schema._second || schema.second;
+    const schemas = [];
+    if (first)
+        schemas.push(toJSONSchema(first, options));
+    if (second)
+        schemas.push(toJSONSchema(second, options));
+    if (schemas.length === 0)
+        return {};
+    if (schemas.length === 1)
+        return schemas[0];
+    return { allOf: schemas };
+}
+/**
+ * Build optional JSON Schema
+ */
+function buildOptionalSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    const result = toJSONSchema(inner, options);
+    // Remove from required array - but we don't track required here
+    return result;
+}
+/**
+ * Build nullable JSON Schema
+ */
+function buildNullableSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return { type: 'null' };
+    const result = toJSONSchema(inner, options);
+    if (typeof result.type === 'string') {
+        return { type: [result.type, 'null'] };
+    }
+    else if (Array.isArray(result.type)) {
+        result.type.push('null');
+        return result;
+    }
+    return {
+        anyOf: [result, { type: 'null' }]
+    };
+}
+/**
+ * Build nullish JSON Schema
+ */
+function buildNullishSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    return toJSONSchema(inner, options);
+}
+/**
+ * Build exactOptional JSON Schema
+ */
+function buildExactOptionalSchema(schema, options) {
+    const inner = schema._inner || schema._baseValidator;
+    if (!inner)
+        return {};
+    return toJSONSchema(inner, options);
+}
+/**
+ * Internal function to convert JSON Schema to VLD schema
+ */
+function jsonSchemaToVLD(json) {
+    // This is a simplified implementation
+    // Full implementation would recursively handle all JSON Schema types
+    const VldString = require('../validators/string').VldString;
+    const VldNumber = require('../validators/number').VldNumber;
+    const VldBoolean = require('../validators/boolean').VldBoolean;
+    const VldObject = require('../validators/object').VldObject;
+    const VldArray = require('../validators/array').VldArray;
+    const VldUnion = require('../validators/union').VldUnion;
+    const VldLiteral = require('../validators/literal').VldLiteral;
+    const VldEnum = require('../validators/enum').VldEnum;
+    const VldNull = require('../validators/null').VldNull;
+    const VldAny = require('../validators/any').VldAny;
+    const VldRecord = require('../validators/record').VldRecord;
+    // Handle $ref
+    if (json.$ref) {
+        // For now, return any - full $ref handling requires registry
+        return VldAny.create();
+    }
+    // Handle anyOf/oneOf (union)
+    if (json.anyOf || json.oneOf) {
+        const options = (json.anyOf || json.oneOf)
+            .map((s) => jsonSchemaToVLD(s))
+            .filter(Boolean);
+        if (options.length > 0) {
+            return VldUnion.create(...options);
+        }
+    }
+    // Handle allOf (intersection)
+    if (json.allOf) {
+        // For intersection, we'd need VldIntersection
+        const first = jsonSchemaToVLD(json.allOf[0]);
+        if (json.allOf.length > 1) {
+            const second = jsonSchemaToVLD({ allOf: json.allOf.slice(1) });
+            const VldIntersection = require('../validators/intersection').VldIntersection;
+            return VldIntersection.create(first, second);
+        }
+        return first;
+    }
+    // Handle not
+    if (json.not) {
+        // For negation, we need special handling
+        return VldAny.create();
+    }
+    // Handle const
+    if (json.const !== undefined) {
+        return VldLiteral.create(json.const);
+    }
+    // Handle enum
+    if (json.enum) {
+        return VldEnum.create(json.enum);
+    }
+    // Handle type
+    const type = json.type;
+    if (type === 'string' || type === undefined) {
+        const s = VldString.create();
+        if (json.minLength)
+            s.minLength = json.minLength;
+        if (json.maxLength)
+            s.maxLength = json.maxLength;
+        if (json.pattern)
+            s.pattern = json.pattern;
+        if (json.format) {
+            // Map JSON Schema formats to VLD validators
+            switch (json.format) {
+                case 'date-time':
+                case 'date':
+                case 'time':
+                    // Would need DateTime validator
+                    break;
+                case 'email':
+                    const email = require('../validators/string-formats').email;
+                    return email();
+                case 'uri':
+                case 'uri-reference':
+                    const httpUrl = require('../validators/string-formats').httpUrl;
+                    return httpUrl();
+                case 'uuid':
+                    const uuid = require('../validators/string-formats').uuid;
+                    return uuid();
+            }
+        }
+        return s;
+    }
+    if (type === 'number' || type === 'integer') {
+        const n = VldNumber.create();
+        if (type === 'integer')
+            n.int();
+        if (json.minimum !== undefined)
+            n.min(json.minimum);
+        if (json.maximum !== undefined)
+            n.max(json.maximum);
+        if (json.exclusiveMinimum !== undefined)
+            n.gt(json.exclusiveMinimum);
+        if (json.exclusiveMaximum !== undefined)
+            n.lt(json.exclusiveMaximum);
+        if (json.multipleOf !== undefined)
+            n.multipleOf(json.multipleOf);
+        return n;
+    }
+    if (type === 'boolean') {
+        return VldBoolean.create();
+    }
+    if (type === 'array') {
+        if (json.items && !Array.isArray(json.items)) {
+            return VldArray.create(jsonSchemaToVLD(json.items));
+        }
+        return VldArray.create(VldAny.create());
+    }
+    if (type === 'object') {
+        if (json.properties) {
+            const shape = {};
+            const required = json.required || [];
+            for (const [key, propSchema] of Object.entries(json.properties)) {
+                shape[key] = jsonSchemaToVLD(propSchema);
+            }
+            let obj = VldObject.create(shape);
+            if (!required.length) {
+                // If no required fields, make all optional
+                for (const key of Object.keys(shape)) {
+                    if (!required.includes(key)) ;
+                }
+            }
+            if (json.additionalProperties === false) {
+                obj = obj.strict();
+            }
+            else if (json.additionalProperties === true) {
+                obj = obj.passthrough();
+            }
+            else if (json.additionalProperties) {
+                // additionalProperties is a schema
+                const valueSchema = jsonSchemaToVLD(json.additionalProperties);
+                obj = VldRecord.create(valueSchema);
+            }
+            return obj;
+        }
+        // Empty object schema
+        return VldObject.create({});
+    }
+    if (type === 'null') {
+        return VldNull.create();
+    }
+    if (Array.isArray(type)) {
+        // Union of types
+        const options = type.map((t) => {
+            return jsonSchemaToVLD({ ...json, type: t });
+        });
+        if (options.length > 0) {
+            return VldUnion.create(...options);
+        }
+    }
+    // Fallback to any
+    return VldAny.create();
+}
+
 /**
  * VLD - Fast, Type-Safe Validation Library
  * Zero dependencies, blazing fast performance
@@ -216,6 +743,11 @@ const v = {
     number: () => VldNumber.create(),
     int: () => VldNumber.create().int(),
     int32: () => VldNumber.create().int().min(-2147483648).max(2147483647),
+    uint32: () => VldNumber.create().uint32(),
+    uint64: () => VldNumber.create().uint64(),
+    int64: () => VldNumber.create().int64(),
+    float32: () => VldNumber.create().float32(),
+    float64: () => VldNumber.create().float64(),
     boolean: () => VldBoolean.create(),
     date: () => VldDate.create(),
     bigint: () => VldBigInt.create(),
@@ -254,6 +786,7 @@ const v = {
     optional: (validator) => VldOptional.create(validator),
     nullable: (validator) => VldNullable.create(validator),
     nullish: (validator) => VldNullish.create(validator),
+    exactOptional: (validator) => VldExactOptional.create(validator),
     // Recursive schemas
     lazy: (schemaGetter) => VldLazy.create(schemaGetter),
     // JSON validator
@@ -302,6 +835,10 @@ const v = {
         duration: () => iso.duration(),
     },
     stringFormat: (name, validator) => stringFormat(name, validator),
+    // Zod v4 parity string formats
+    xid: () => xid(),
+    guid: () => guid(),
+    httpUrl: () => httpUrl(),
     // Template literal validator
     templateLiteral: (...components) => templateLiteral(...components),
     // Codec validators (binary data validators)
@@ -309,8 +846,10 @@ const v = {
     hexBytes: () => VldHex.create(),
     uint8Array: () => VldUint8Array.create(),
     // Codec factory
-    codec: (inputValidator, outputValidator, transform) => VldCodec.create(inputValidator, outputValidator, transform)
+    codec: (inputValidator, outputValidator, transform) => VldCodec.create(inputValidator, outputValidator, transform),
+    // Promise validator (Zod v4 parity)
+    promise: (inner) => promise(inner)
 };
 
-export { VldIntersection, createLogger, createNoOpLogger, v as default, disableLogging, enableDebug, getLogger, initLogger, setLogLevel, v };
+export { VldIntersection, createLogger, createNoOpLogger, v as default, disableLogging, enableDebug, fromJSONSchema, getLogger, initLogger, setLogLevel, toJSONSchema, v };
 //# sourceMappingURL=index.js.map