@naturalcycles/nodejs-lib 15.37.2 → 15.39.0

package/dist/log/log.util.d.ts

@@ -1,4 +1,4 @@
 /**
- * CommonLogger that logs to process.stdout directly (bypassing console.log).
+ * CommonLogger that logs to process.stdout directly (bypassing console.log)!
  */
 export declare const stdoutLogger: any;

package/dist/log/log.util.js

@@ -1,7 +1,7 @@
 import { commonLoggerCreate } from '@naturalcycles/js-lib/log';
 import { _inspect } from '../string/inspect.js';
 /**
- * CommonLogger that logs to process.stdout directly (bypassing console.log).
+ * CommonLogger that logs to process.stdout directly (bypassing console.log)!
  */
 export const stdoutLogger = commonLoggerCreate((_level, args) => {
     process.stdout.write(args.map(a => _inspect(a)).join(' ') + '\n');

package/dist/security/nanoid.js

@@ -4,7 +4,7 @@ This file is "vendored" from Nanoid, all credit is to Nanoid authors:
 https://github.com/ai/nanoid/
 
  */
-/* eslint-disable */
+// oxlint-disable no-bitwise -- NanoID implementation relies on bitwise operations
 import { randomFillSync } from 'node:crypto';
 export const ALPHABET_NONAMBIGUOUS = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
 export const ALPHABET_NUMBER = '0123456789';

package/dist/validation/ajv/ajvSchema.d.ts

@@ -1,10 +1,59 @@
 import { type ValidationFunction, type ValidationFunctionResult } from '@naturalcycles/js-lib';
-import type { JsonSchema, JsonSchemaBuilder } from '@naturalcycles/js-lib/json-schema';
-import type { AnyObject } from '@naturalcycles/js-lib/types';
-import { ZodType } from '@naturalcycles/js-lib/zod';
+import { type AnyObject } from '@naturalcycles/js-lib/types';
+import type { ZodType } from '@naturalcycles/js-lib/zod';
 import type { Ajv } from 'ajv';
 import { AjvValidationError } from './ajvValidationError.js';
-export type SchemaHandledByAjv<T> = JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T> | ZodType<T>;
+import { type JsonSchema, JsonSchemaAnyBuilder } from './jsonSchemaBuilder.js';
+/**
+ * On creation - compiles ajv validation function.
+ * Provides convenient methods, error reporting, etc.
+ */
+export declare class AjvSchema<IN = unknown, OUT = IN> {
+    schema: JsonSchema<IN, OUT>;
+    private constructor();
+    /**
+     * Shortcut for AjvSchema.create(schema, { lazy: true })
+     */
+    static createLazy<IN, OUT>(schema: SchemaHandledByAjv<IN, OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<IN, OUT>;
+    /**
+     * Conveniently allows to pass either JsonSchema or JsonSchemaBuilder, or existing AjvSchema.
+     * If it's already an AjvSchema - it'll just return it without any processing.
+     * If it's a Builder - will call `build` before proceeding.
+     * Otherwise - will construct AjvSchema instance ready to be used.
+     *
+     * Implementation note: JsonSchemaBuilder goes first in the union type, otherwise TypeScript fails to infer <T> type
+     * correctly for some reason.
+     */
+    static create<IN, OUT = IN>(schema: SchemaHandledByAjv<IN, OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<IN, OUT>;
+    /**
+     * @deprecated Use `j` to build schemas, not `z` or `zod`.
+     */
+    static createFromZod<T extends ZodType<any, any, any>>(schema: T): AjvSchema<T['_input'], T['_output']>;
+    static isJsonSchemaBuilder<IN, OUT>(schema: unknown): schema is JsonSchemaAnyBuilder<IN, OUT, any>;
+    readonly cfg: AjvSchemaCfg;
+    /**
+     * It returns the original object just for convenience.
+     * Reminder: Ajv will MUTATE your object under 2 circumstances:
+     * 1. `useDefaults` option (enabled by default!), which will set missing/empty values that have `default` set in the schema.
+     * 2. `coerceTypes` (false by default).
+     *
+     * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
+     */
+    validate(input: IN, opt?: AjvValidationOptions): OUT;
+    isValid(input: IN, opt?: AjvValidationOptions): boolean;
+    getValidationResult(input: IN, opt?: AjvValidationOptions): ValidationFunctionResult<OUT, AjvValidationError>;
+    getValidationFunction(): ValidationFunction<IN, OUT, AjvValidationError>;
+    static isSchemaWithCachedAjvSchema<Base, IN, OUT>(schema: Base): schema is WithCachedAjvSchema<Base, IN, OUT>;
+    static cacheAjvSchema<Base extends AnyObject, IN, OUT>(schema: Base, ajvSchema: AjvSchema<IN, OUT>): WithCachedAjvSchema<Base, IN, OUT>;
+    static requireCachedAjvSchema<Base, IN, OUT>(schema: WithCachedAjvSchema<Base, IN, OUT>): AjvSchema<IN, OUT>;
+    private getAJVValidateFunction;
+    private static requireValidJsonSchema;
+    private applyImprovementsOnErrorMessages;
+}
+export declare const HIDDEN_AJV_SCHEMA: unique symbol;
+export type WithCachedAjvSchema<Base, IN, OUT> = Base & {
+    [HIDDEN_AJV_SCHEMA]: AjvSchema<IN, OUT>;
+};
 export interface AjvValidationOptions {
     /**
      * Defaults to true,
@@ -45,54 +94,4 @@ export interface AjvSchemaCfg {
      */
     lazy?: boolean;
 }
-/**
- * On creation - compiles ajv validation function.
- * Provides convenient methods, error reporting, etc.
- */
-export declare class AjvSchema<T = unknown> {
-    schema: JsonSchema<T>;
-    private constructor();
-    /**
-     * Shortcut for AjvSchema.create(schema, { lazy: true })
-     */
-    static createLazy<T>(schema: JsonSchemaBuilder<T> | JsonSchema<T> | AjvSchema<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
-    /**
-     * Conveniently allows to pass either JsonSchema or JsonSchemaBuilder, or existing AjvSchema.
-     * If it's already an AjvSchema - it'll just return it without any processing.
-     * If it's a Builder - will call `build` before proceeding.
-     * Otherwise - will construct AjvSchema instance ready to be used.
-     *
-     * Implementation note: JsonSchemaBuilder goes first in the union type, otherwise TypeScript fails to infer <T> type
-     * correctly for some reason.
-     */
-    static create<T>(schema: SchemaHandledByAjv<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
-    /**
-     * @deprecated
-     *
-     * Use `AjvSchema.create`
-     */
-    static createFromZod<T>(zodSchema: ZodType<T>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<T>;
-    static isJsonSchemaBuilder<T>(schema: unknown): schema is JsonSchemaBuilder<T>;
-    static isZodSchema<T>(schema: unknown): schema is ZodType<T>;
-    readonly cfg: AjvSchemaCfg;
-    /**
-     * It returns the original object just for convenience.
-     * Reminder: Ajv will MUTATE your object under 2 circumstances:
-     * 1. `useDefaults` option (enabled by default!), which will set missing/empty values that have `default` set in the schema.
-     * 2. `coerceTypes` (false by default).
-     *
-     * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
-     */
-    validate(input: T, opt?: AjvValidationOptions): T;
-    isValid(input: T, opt?: AjvValidationOptions): boolean;
-    getValidationResult(input: T, opt?: AjvValidationOptions): ValidationFunctionResult<T, AjvValidationError>;
-    getValidationFunction(): ValidationFunction<T, AjvValidationError>;
-    static isSchemaWithCachedAjvSchema<Base, T>(schema: Base): schema is WithCachedAjvSchema<Base, T>;
-    static cacheAjvSchema<Base extends AnyObject, T>(schema: Base, ajvSchema: AjvSchema<T>): WithCachedAjvSchema<Base, T>;
-    static requireCachedAjvSchema<Base, T>(schema: WithCachedAjvSchema<Base, T>): AjvSchema<T>;
-    private getAJVValidateFunction;
-}
-export declare const HIDDEN_AJV_SCHEMA: unique symbol;
-export type WithCachedAjvSchema<Base, T> = Base & {
-    [HIDDEN_AJV_SCHEMA]: AjvSchema<T>;
-};
+export type SchemaHandledByAjv<IN, OUT = IN> = JsonSchemaAnyBuilder<IN, OUT, any> | JsonSchema<IN, OUT> | AjvSchema<IN, OUT>;

package/dist/validation/ajv/ajvSchema.js

@@ -1,11 +1,13 @@
 import { _isObject, _lazyValue, } from '@naturalcycles/js-lib';
-import { JsonSchemaAnyBuilder } from '@naturalcycles/js-lib/json-schema';
+import { _assert } from '@naturalcycles/js-lib/error';
 import { _deepCopy, _filterNullishValues } from '@naturalcycles/js-lib/object';
 import { _substringBefore } from '@naturalcycles/js-lib/string';
-import { z, ZodType } from '@naturalcycles/js-lib/zod';
+import { _typeCast } from '@naturalcycles/js-lib/types';
+import { z } from '@naturalcycles/js-lib/zod';
 import { _inspect } from '../../string/inspect.js';
 import { AjvValidationError } from './ajvValidationError.js';
 import { getAjv } from './getAjv.js';
+import { JsonSchemaAnyBuilder } from './jsonSchemaBuilder.js';
 /**
  * On creation - compiles ajv validation function.
  * Provides convenient methods, error reporting, etc.
@@ -52,9 +54,7 @@ export class AjvSchema {
         let jsonSchema;
         if (AjvSchema.isJsonSchemaBuilder(schema)) {
             jsonSchema = schema.build();
-        }
-        else if (AjvSchema.isZodSchema(schema)) {
-            jsonSchema = z.toJSONSchema(schema, { target: 'draft-7' });
+            AjvSchema.requireValidJsonSchema(jsonSchema);
         }
         else {
             jsonSchema = schema;
@@ -64,19 +64,17 @@ export class AjvSchema {
         return ajvSchema;
     }
     /**
-     * @deprecated
-     *
-     * Use `AjvSchema.create`
+     * @deprecated Use `j` to build schemas, not `z` or `zod`.
      */
-    static createFromZod(zodSchema, cfg) {
-        return AjvSchema.create(zodSchema, cfg);
+    static createFromZod(schema) {
+        const jsonSchema = z.toJSONSchema(schema, {
+            target: 'draft-7',
+        });
+        return AjvSchema.create(jsonSchema);
     }
     static isJsonSchemaBuilder(schema) {
         return schema instanceof JsonSchemaAnyBuilder;
     }
-    static isZodSchema(schema) {
-        return schema instanceof ZodType;
-    }
     cfg;
     /**
      * It returns the original object just for convenience.
@@ -104,11 +102,13 @@ export class AjvSchema {
             ? input // mutate
             : _deepCopy(input); // not mutate
         const valid = fn(item); // mutates item
+        _typeCast(item);
         if (valid)
             return [null, item];
         const errors = fn.errors;
         const { inputId = _isObject(input) ? input['id'] : undefined, inputName = this.cfg.inputName || 'Object', } = opt;
         const dataVar = [inputName, inputId].filter(Boolean).join('.');
+        this.applyImprovementsOnErrorMessages(errors);
         let message = this.cfg.ajv.errorsText(errors, {
             dataVar,
             separator,
@@ -143,6 +143,23 @@ export class AjvSchema {
         return schema[HIDDEN_AJV_SCHEMA];
     }
     getAJVValidateFunction = _lazyValue(() => this.cfg.ajv.compile(this.schema));
+    static requireValidJsonSchema(schema) {
+        // For object schemas we require that it is type checked against an external type, e.g.:
+        // interface Foo { name: string }
+        // const schema = j.object({ name: j.string() }).ofType<Foo>()
+        _assert(schema.type !== 'object' || schema.hasIsOfTypeCheck, 'The schema must be type checked against a type or interface, using the `.isOfType()` helper in `j`.');
+    }
+    applyImprovementsOnErrorMessages(errors) {
+        if (!errors)
+            return;
+        const { errorMessages } = this.schema;
+        for (const error of errors) {
+            if (errorMessages?.[error.keyword]) {
+                error.message = errorMessages[error.keyword];
+            }
+            error.instancePath = error.instancePath.replaceAll(/\/(\d+)/g, `[$1]`).replaceAll('/', '.');
+        }
+    }
 }
 const separator = '\n';
 export const HIDDEN_AJV_SCHEMA = Symbol('HIDDEN_AJV_SCHEMA');

package/dist/validation/ajv/getAjv.d.ts

@@ -1,5 +1,4 @@
-import type { Options } from 'ajv';
-import { Ajv } from 'ajv';
+import { Ajv, type Options } from 'ajv';
 /**
  * Return cached instance of Ajv with default (recommended) options.
  *

package/dist/validation/ajv/getAjv.js

@@ -1,9 +1,10 @@
-/* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
-/* eslint-disable unicorn/prefer-code-point */
 import { _lazyValue } from '@naturalcycles/js-lib';
-import { Ajv } from 'ajv';
-import ajvFormats from 'ajv-formats';
-import ajvKeywords from 'ajv-keywords';
+import { Set2 } from '@naturalcycles/js-lib/object';
+import { _substringAfterLast } from '@naturalcycles/js-lib/string';
+import { _, Ajv } from 'ajv';
+import { validTLDs } from './tlds.js';
+/* eslint-disable @typescript-eslint/prefer-string-starts-ends-with */
+// oxlint-disable unicorn/prefer-code-point
 const AJV_OPTIONS = {
     removeAdditional: true,
     allErrors: true,
@@ -44,91 +45,238 @@ export function createAjv(opt) {
         ...AJV_OPTIONS,
         ...opt,
     });
-    // Add custom formats
-    addCustomAjvFormats(ajv);
-    // todo: review and possibly cherry-pick/vendor the formats
-    // Adds ajv "formats"
-    // https://ajv.js.org/guide/formats.html
-    // @ts-expect-error types are wrong
-    ajvFormats(ajv);
-    // https://ajv.js.org/packages/ajv-keywords.html
-    // @ts-expect-error types are wrong
-    ajvKeywords(ajv, [
-        'transform', // trim, toLowerCase, etc.
-        'uniqueItemProperties',
-        'instanceof',
-    ]);
     // Adds $merge, $patch keywords
     // https://github.com/ajv-validator/ajv-merge-patch
     // Kirill: temporarily disabled, as it creates a noise of CVE warnings
     // require('ajv-merge-patch')(ajv)
-    return ajv;
-}
-const TS_2500 = 16725225600; // 2500-01-01
-const TS_2500_MILLIS = TS_2500 * 1000;
-const TS_2000 = 946684800; // 2000-01-01
-const TS_2000_MILLIS = TS_2000 * 1000;
-const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-function addCustomAjvFormats(ajv) {
-    return (ajv
-        .addFormat('id', /^[a-z0-9_]{6,64}$/)
-        .addFormat('slug', /^[a-z0-9-]+$/)
-        .addFormat('semVer', /^[0-9]+\.[0-9]+\.[0-9]+$/)
-        // IETF language tag (https://en.wikipedia.org/wiki/IETF_language_tag)
-        .addFormat('languageTag', /^[a-z]{2}(-[A-Z]{2})?$/)
-        .addFormat('countryCode', /^[A-Z]{2}$/)
-        .addFormat('currency', /^[A-Z]{3}$/)
-        .addFormat('unixTimestamp', {
-        type: 'number',
-        validate: (n) => {
-            return n >= 0 && n < TS_2500;
-        },
-    })
-        .addFormat('unixTimestamp2000', {
-        type: 'number',
-        validate: (n) => {
-            return n >= TS_2000 && n < TS_2500;
+    ajv.addKeyword({
+        keyword: 'transform',
+        type: 'string',
+        modifying: true,
+        schemaType: 'object',
+        errors: true,
+        code(ctx) {
+            const { gen, data, schema, it } = ctx;
+            const { parentData, parentDataProperty } = it;
+            if (schema.trim) {
+                gen.assign(_ `${data}`, _ `${data}.trim()`);
+            }
+            if (schema.toLowerCase) {
+                gen.assign(_ `${data}`, _ `${data}.toLowerCase()`);
+            }
+            if (schema.toUpperCase) {
+                gen.assign(_ `${data}`, _ `${data}.toUpperCase()`);
+            }
+            if (typeof schema.truncate === 'number' && schema.truncate >= 0) {
+                gen.assign(_ `${data}`, _ `${data}.slice(0, ${schema.truncate})`);
+                if (schema.trim) {
+                    gen.assign(_ `${data}`, _ `${data}.trim()`);
+                }
+            }
+            gen.if(_ `${parentData} !== undefined`, () => {
+                gen.assign(_ `${parentData}[${parentDataProperty}]`, data);
+            });
         },
-    })
-        .addFormat('unixTimestampMillis', {
-        type: 'number',
-        validate: (n) => {
-            return n >= 0 && n < TS_2500_MILLIS;
+    });
+    ajv.addKeyword({
+        keyword: 'instanceof',
+        modifying: true,
+        schemaType: 'string',
+        validate(instanceOf, data, _schema, _ctx) {
+            if (typeof data !== 'object')
+                return false;
+            if (data === null)
+                return false;
+            let proto = Object.getPrototypeOf(data);
+            while (proto) {
+                if (proto.constructor?.name === instanceOf)
+                    return true;
+                proto = Object.getPrototypeOf(proto);
+            }
+            return false;
         },
-    })
-        .addFormat('unixTimestampMillis2000', {
-        type: 'number',
-        validate: (n) => {
-            return n >= TS_2000_MILLIS && n < TS_2500_MILLIS;
+    });
+    ajv.addKeyword({
+        keyword: 'Set2',
+        type: ['array', 'object'],
+        modifying: true,
+        errors: true,
+        schemaType: 'object',
+        compile(innerSchema, _parentSchema, _it) {
+            const validateItem = ajv.compile(innerSchema);
+            function validateSet(data, ctx) {
+                let set;
+                const isIterable = data === null || typeof data[Symbol.iterator] === 'function';
+                if (data instanceof Set2) {
+                    set = data;
+                }
+                else if (isIterable && ctx?.parentData) {
+                    set = new Set2(data);
+                }
+                else if (isIterable && !ctx?.parentData) {
+                    ;
+                    validateSet.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: 'can only transform an Iterable into a Set2 when the schema is in an object or an array schema. This is an Ajv limitation.',
+                        },
+                    ];
+                    return false;
+                }
+                else {
+                    ;
+                    validateSet.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: 'must be a Set2 object (or optionally an Iterable in some cases)',
+                        },
+                    ];
+                    return false;
+                }
+                let idx = 0;
+                for (const value of set.values()) {
+                    if (!validateItem(value)) {
+                        ;
+                        validateSet.errors = [
+                            {
+                                instancePath: (ctx?.instancePath ?? '') + '/' + idx,
+                                message: `invalid set item at index ${idx}`,
+                                params: { errors: validateItem.errors },
+                            },
+                        ];
+                        return false;
+                    }
+                    idx++;
+                }
+                if (ctx?.parentData && ctx.parentDataProperty) {
+                    ctx.parentData[ctx.parentDataProperty] = set;
+                }
+                return true;
+            }
+            return validateSet;
         },
-    })
-        .addFormat('utcOffset', {
-        type: 'number',
-        validate: (n) => {
-            // min: -14 hours
-            // max +14 hours
-            // multipleOf 15 (minutes)
-            return n >= -14 * 60 && n <= 14 * 60 && Number.isInteger(n);
+    });
+    ajv.addKeyword({
+        keyword: 'Buffer',
+        modifying: true,
+        errors: true,
+        schemaType: 'boolean',
+        compile(_innerSchema, _parentSchema, _it) {
+            function validateBuffer(data, ctx) {
+                let buffer;
+                if (data === null)
+                    return false;
+                const isValid = data instanceof Buffer ||
+                    data instanceof ArrayBuffer ||
+                    Array.isArray(data) ||
+                    typeof data === 'string';
+                if (!isValid)
+                    return false;
+                if (data instanceof Buffer) {
+                    buffer = data;
+                }
+                else if (isValid && ctx?.parentData) {
+                    buffer = Buffer.from(data);
+                }
+                else if (isValid && !ctx?.parentData) {
+                    ;
+                    validateBuffer.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: 'can only transform data into a Buffer when the schema is in an object or an array schema. This is an Ajv limitation.',
+                        },
+                    ];
+                    return false;
+                }
+                else {
+                    ;
+                    validateBuffer.errors = [
+                        {
+                            instancePath: ctx?.instancePath ?? '',
+                            message: 'must be a Buffer object (or optionally an Array-like object or ArrayBuffer in some cases)',
+                        },
+                    ];
+                    return false;
+                }
+                if (ctx?.parentData && ctx.parentDataProperty) {
+                    ctx.parentData[ctx.parentDataProperty] = buffer;
+                }
+                return true;
+            }
+            return validateBuffer;
         },
-    })
-        .addFormat('utcOffsetHours', {
-        type: 'number',
-        validate: (n) => {
-            // min: -14 hours
-            // max +14 hours
-            // multipleOf 15 (minutes)
-            return n >= -14 && n <= 14 && Number.isInteger(n);
+    });
+    ajv.addKeyword({
+        keyword: 'email',
+        type: 'string',
+        modifying: false,
+        errors: true,
+        schemaType: 'object',
+        validate: function validate(opt, data, _schema, ctx) {
+            const { checkTLD } = opt;
+            if (!checkTLD)
+                return true;
+            const tld = _substringAfterLast(data, '.');
+            if (validTLDs.has(tld))
+                return true;
+            validate.errors = [
+                {
+                    instancePath: ctx?.instancePath ?? '',
+                    message: `has an invalid TLD`,
+                },
+            ];
+            return false;
         },
-    })
-        .addFormat('IsoDate', {
+    });
+    ajv.addKeyword({
+        keyword: 'IsoDate',
         type: 'string',
-        validate: isIsoDateValid,
-    })
-        .addFormat('IsoDateTime', {
+        modifying: false,
+        errors: true,
+        schemaType: 'boolean',
+        validate: function validate(_opt, data, _schema, ctx) {
+            const isValid = isIsoDateValid(data);
+            if (isValid)
+                return true;
+            validate.errors = [
+                {
+                    instancePath: ctx?.instancePath ?? '',
+                    message: `is an invalid IsoDate`,
+                },
+            ];
+            return false;
+        },
+    });
+    ajv.addKeyword({
+        keyword: 'IsoDateTime',
         type: 'string',
-        validate: isIsoDateTimeValid,
-    }));
+        modifying: false,
+        errors: true,
+        schemaType: 'boolean',
+        validate: function validate(_opt, data, _schema, ctx) {
+            const isValid = isIsoDateTimeValid(data);
+            if (isValid)
+                return true;
+            validate.errors = [
+                {
+                    instancePath: ctx?.instancePath ?? '',
+                    message: `is an invalid IsoDateTime`,
+                },
+            ];
+            return false;
+        },
+    });
+    ajv.addKeyword({
+        keyword: 'errorMessages',
+        schemaType: 'object',
+    });
+    ajv.addKeyword({
+        keyword: 'hasIsOfTypeCheck',
+        schemaType: 'boolean',
+    });
+    return ajv;
 }
+const monthLengths = [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 const DASH_CODE = '-'.charCodeAt(0);
 const ZERO_CODE = '0'.charCodeAt(0);
 const PLUS_CODE = '+'.charCodeAt(0);

package/dist/validation/ajv/index.d.ts

@@ -2,4 +2,5 @@ import Ajv from 'ajv';
 export * from './ajvSchema.js';
 export * from './ajvValidationError.js';
 export * from './getAjv.js';
+export * from './jsonSchemaBuilder.js';
 export { Ajv };

package/dist/validation/ajv/index.js

@@ -2,4 +2,5 @@ import Ajv from 'ajv';
 export * from './ajvSchema.js';
 export * from './ajvValidationError.js';
 export * from './getAjv.js';
+export * from './jsonSchemaBuilder.js';
 export { Ajv };