@naturalcycles/nodejs-lib 15.92.1 → 15.94.0

package/dist/validation/ajv/{ajvSchema.d.ts → jSchema.d.ts}

@@ -3,134 +3,20 @@ import type { Set2 } from '@naturalcycles/js-lib/object';
 import type { AnyObject, BaseDBEntity, IANATimezone, Inclusiveness, IsoDate, IsoDateTime, IsoMonth, NumberEnum, StringEnum, StringMap, UnixTimestamp, UnixTimestampMillis } from '@naturalcycles/js-lib/types';
 import type { Ajv } from 'ajv';
 import { AjvValidationError } from './ajvValidationError.js';
-/**
- * On creation - compiles ajv validation function.
- * Provides convenient methods, error reporting, etc.
- */
-export declare class AjvSchema<OUT> {
-    schema: JsonSchema<OUT>;
-    private constructor();
-    /**
-     * Shortcut for AjvSchema.create(schema, { lazy: true })
-     */
-    static createLazy<OUT>(schema: SchemaHandledByAjv<OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<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<OUT>(schema: SchemaHandledByAjv<OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<OUT>;
-    static isJsonSchemaBuilder<OUT>(schema: unknown): schema is JsonSchemaTerminal<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: unknown, opt?: AjvValidationOptions): OUT;
-    isValid(input: unknown, opt?: AjvValidationOptions): boolean;
-    getValidationResult(input: unknown, opt?: AjvValidationOptions): ValidationFunctionResult<OUT, AjvValidationError>;
-    getValidationFunction(): ValidationFunction<OUT, AjvValidationError>;
-    static isSchemaWithCachedAjvSchema<Base, OUT>(schema: Base): schema is WithCachedAjvSchema<Base, OUT>;
-    static cacheAjvSchema<Base extends AnyObject, OUT>(schema: Base, ajvSchema: AjvSchema<OUT>): WithCachedAjvSchema<Base, OUT>;
-    static requireCachedAjvSchema<Base, OUT>(schema: WithCachedAjvSchema<Base, OUT>): AjvSchema<OUT>;
-    private getAJVValidateFunction;
-    private static requireValidJsonSchema;
-    private applyImprovementsOnErrorMessages;
-    /**
-     * Filters out noisy errors produced by nullable anyOf patterns.
-     * When `nullable()` wraps a schema in `anyOf: [realSchema, { type: 'null' }]`,
-     * AJV produces "must be null" and "must match a schema in anyOf" errors
-     * that are confusing. This method splices them out, keeping only the real errors.
-     */
-    private filterNullableAnyOfErrors;
-    /**
-     * Navigates the schema tree using an AJV schemaPath (e.g. "#/properties/foo/anyOf")
-     * and returns the parent schema containing the last keyword.
-     */
-    private resolveSchemaPath;
-    private getErrorMessageForInstancePath;
-    private traverseSchemaPath;
-    private getChildSchema;
-    private getArrayItemSchema;
-    private getObjectPropertySchema;
-}
-export declare const HIDDEN_AJV_SCHEMA: unique symbol;
-export type WithCachedAjvSchema<Base, OUT> = Base & {
-    [HIDDEN_AJV_SCHEMA]: AjvSchema<OUT>;
-};
-export interface AjvValidationOptions {
-    /**
-     * Defaults to true,
-     * because that's how AJV works by default,
-     * and what gives it performance advantage.
-     * (Because we have found that deep-clone is surprisingly slow,
-     * nearly as slow as Joi validation).
-     *
-     * If set to true - AJV will mutate the input in case it needs to apply transformations
-     * (strip unknown properties, convert types, etc).
-     *
-     * If false - it will deep-clone (using JSON.stringify+parse) the input to prevent its mutation.
-     * Will return the cloned/mutated object.
-     * Please note that JSON.stringify+parse has side-effects,
-     * e.g it will transform Buffer into a weird object.
-     */
-    mutateInput?: boolean;
-    inputName?: string;
-    inputId?: string;
-    /**
-     * Function that returns "original input".
-     * What is original input?
-     * It's an input in its original non-mutated form.
-     * Why is it needed?
-     * Because we mutates the Input here. And after its been mutated - we no longer
-     * can include it "how it was" in an error message. So, for that reason we'll use
-     * `getOriginalInput()`, if it's provided.
-     */
-    getOriginalInput?: () => unknown;
-}
-export interface AjvSchemaCfg {
-    /**
-     * Pass Ajv instance, otherwise Ajv will be created with
-     * AjvSchema default (not the same as Ajv defaults) parameters
-     */
-    ajv: Ajv;
-    inputName?: string;
-    /**
-     * Option of Ajv.
-     * If set to true - will mutate your input objects!
-     * Defaults to false.
-     *
-     * This option is a "shortcut" to skip creating and passing Ajv instance.
-     */
-    /**
-     * If true - schema will be compiled on-demand (lazily).
-     * Default: false.
-     */
-    lazy?: boolean;
-}
-export type SchemaHandledByAjv<OUT> = JsonSchemaTerminal<OUT, any> | JsonSchema<OUT> | AjvSchema<OUT>;
 export declare const j: {
     /**
      * Matches literally any value - equivalent to TypeScript's `any` type.
      * Use sparingly, as it bypasses type validation entirely.
      */
-    any(): JsonSchemaAnyBuilder<any, false>;
-    string(): JsonSchemaStringBuilder<string, false>;
-    number(): JsonSchemaNumberBuilder<number, false>;
-    boolean(): JsonSchemaBooleanBuilder<boolean, false>;
+    any(): JBuilder<any, false>;
+    string(): JString<string, false>;
+    number(): JNumber<number, false>;
+    boolean(): JBoolean<boolean, false>;
     object: typeof object & {
         dbEntity: typeof objectDbEntity;
         infer: typeof objectInfer;
-        any(): JsonSchemaObjectBuilder<AnyObject, false>;
-        stringMap<S extends JsonSchemaTerminal<any, any>>(schema: S): JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>, false>;
+        any(): JObject<AnyObject, false>;
+        stringMap<S extends JSchema<any, any>>(schema: S): JObject<StringMap<SchemaOut<S>>, false>;
         /**
          * @experimental Look around, maybe you find a rule that is better for your use-case.
          *
@@ -166,11 +52,11 @@ export declare const j: {
         withEnumKeys: typeof withEnumKeys;
         withRegexKeys: typeof withRegexKeys;
     };
-    array<OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<OUT, Opt>): JsonSchemaArrayBuilder<OUT, Opt>;
-    tuple<const S extends JsonSchemaAnyBuilder<any, any>[]>(items: S): JsonSchemaTupleBuilder<S>;
-    set<OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<OUT, Opt>): JsonSchemaSet2Builder<OUT, Opt>;
-    buffer(): JsonSchemaBufferBuilder;
-    enum<const T extends any>(input: T, opt?: JsonBuilderRuleOpt | undefined): JsonSchemaEnumBuilder<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never, false>;
+    array<OUT, Opt>(itemSchema: JBuilder<OUT, Opt>): JArray<OUT, Opt>;
+    tuple<const S extends JBuilder<any, any>[]>(items: S): JTuple<S>;
+    set<OUT, Opt>(itemSchema: JBuilder<OUT, Opt>): JSet2Builder<OUT, Opt>;
+    buffer(): JBuilder<Buffer<ArrayBufferLike>, false>;
+    enum<const T extends any>(input: T, opt?: JsonBuilderRuleOpt | undefined): JEnum<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never, false>;
     /**
      * Use only with primitive values, otherwise this function will throw to avoid bugs.
      * To validate objects, use `anyOfBy`.
@@ -182,7 +68,7 @@ export declare const j: {
      * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
      * Use `oneOf` when schemas are mutually exclusive.
      */
-    oneOf<B extends readonly JsonSchemaAnyBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<OUT, false>;
+    oneOf<B extends readonly JBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JBuilder<OUT, false>;
     /**
      * Use only with primitive values, otherwise this function will throw to avoid bugs.
      * To validate objects, use `anyOfBy` or `anyOfThese`.
@@ -194,7 +80,7 @@ export declare const j: {
      * Use `anyOf` when schemas may overlap (e.g., AccountId | PartnerId with same format).
      * Use `oneOf` when schemas are mutually exclusive.
      */
-    anyOf<B extends readonly JsonSchemaAnyBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<OUT, false>;
+    anyOf<B extends readonly JBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JBuilder<OUT, false>;
     /**
      * Pick validation schema for an object based on the value of a specific property.
      *
@@ -207,7 +93,7 @@ export declare const j: {
      * const schema = j.anyOfBy('success', schemaMap)
      * ```
      */
-    anyOfBy<D extends Record<PropertyKey, JsonSchemaTerminal<any, any>>, OUT = AnyOfByOut<D>>(propertyName: string, schemaDictionary: D): JsonSchemaAnyOfByBuilder<OUT>;
+    anyOfBy<D extends Record<PropertyKey, JSchema<any, any>>, OUT = AnyOfByOut<D>>(propertyName: string, schemaDictionary: D): JBuilder<OUT, false>;
     /**
      * Custom version of `anyOf` which - in contrast to the original function - does not mutate the input.
      * This comes with a performance penalty, so do not use it where performance matters.
@@ -216,17 +102,38 @@ export declare const j: {
      * const schema = j.anyOfThese([successSchema, errorSchema])
      * ```
      */
-    anyOfThese<B extends readonly JsonSchemaAnyBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<OUT, false>;
+    anyOfThese<B extends readonly JBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(items: [...B]): JBuilder<OUT, false>;
     and(): {
         silentBob: () => never;
     };
-    literal<const V extends string | number | boolean | null>(v: V): JsonSchemaEnumBuilder<V, false>;
+    literal<const V extends string | number | boolean | null>(v: V): JEnum<V, false>;
+    /**
+     * Create a JSchema from a plain JsonSchema object.
+     * Useful when the schema is loaded from a JSON file or generated externally.
+     *
+     * Optionally accepts a custom Ajv instance and/or inputName for error messages.
+     */
+    fromSchema<OUT>(schema: JsonSchema<OUT>, cfg?: {
+        ajv?: Ajv | undefined;
+        inputName?: string | undefined;
+    } | undefined): JSchema<OUT, false>;
 };
-export declare class JsonSchemaTerminal<OUT, Opt> {
+export declare const HIDDEN_AJV_SCHEMA: unique symbol;
+export type WithCachedAjvSchema<Base, OUT> = Base & {
+    [HIDDEN_AJV_SCHEMA]: AjvSchema<OUT>;
+};
+export declare class JSchema<OUT, Opt> {
     protected [HIDDEN_AJV_SCHEMA]: AjvSchema<any> | undefined;
     protected schema: JsonSchema;
-    constructor(schema: JsonSchema);
-    get ajvSchema(): AjvSchema<any>;
+    private _cfg?;
+    constructor(schema: JsonSchema, cfg?: {
+        ajv?: Ajv;
+        inputName?: string;
+    });
+    private _builtSchema?;
+    private _compiledFns?;
+    private _getBuiltSchema;
+    private _getCompiled;
     getSchema(): JsonSchema;
     /**
      * Produces a "clean schema object" without methods.
@@ -248,29 +155,20 @@ export declare class JsonSchemaTerminal<OUT, Opt> {
      *
      * If you throw an error from this function, it will show up as an error in the validation.
      */
-    postValidation<OUT2 = OUT>(fn: PostValidatonFn<OUT, OUT2>): JsonSchemaTerminal<OUT2, Opt>;
+    postValidation<OUT2 = OUT>(fn: PostValidatonFn<OUT, OUT2>): JSchema<OUT2, Opt>;
     /**
      * @experimental
      */
     out: OUT;
     opt: Opt;
 }
-export declare class JsonSchemaAnyBuilder<OUT, Opt> extends JsonSchemaTerminal<OUT, Opt> {
+export declare class JBuilder<OUT, Opt> extends JSchema<OUT, Opt> {
     protected setErrorMessage(ruleName: string, errorMessage: string | undefined): void;
     /**
      * A helper function that takes a type parameter and compares it with the type inferred from the schema.
      *
      * When the type inferred from the schema differs from the passed-in type,
      * the schema becomes unusable, by turning its type into `never`.
-     *
-     * ```ts
-     * const schemaGood = j.string().isOfType<string>() // ✅
-     *
-     * const schemaBad = j.string().isOfType<number>() // ❌
-     * schemaBad.build() // TypeError: property "build" does not exist on type "never"
-     *
-     * const result = ajvValidateRequest.body(req, schemaBad) // result will have `unknown` type
-     * ```
      */
     isOfType<ExpectedType>(): ExactMatch<ExpectedType, OUT> extends true ? this : never;
     $schema($schema: string): this;
@@ -282,24 +180,24 @@ export declare class JsonSchemaAnyBuilder<OUT, Opt> extends JsonSchemaTerminal<O
     type(type: string): this;
     default(v: any): this;
     instanceof(of: string): this;
-    optional(): JsonSchemaAnyBuilder<OUT | undefined, true>;
-    nullable(): JsonSchemaAnyBuilder<OUT | null, Opt>;
+    optional(): JBuilder<OUT | undefined, true>;
+    nullable(): JBuilder<OUT | null, Opt>;
     /**
      * @deprecated
      * The usage of this function is discouraged as it defeats the purpose of having type-safe validation.
      */
-    castAs<T>(): JsonSchemaAnyBuilder<T, Opt>;
+    castAs<T>(): JBuilder<T, Opt>;
     /**
      * Locks the given schema chain and no other modification can be done to it.
      */
-    final(): JsonSchemaTerminal<OUT, Opt>;
+    final(): JSchema<OUT, Opt>;
     /**
      *
      * @param validator A validator function that returns an error message or undefined.
      *
      * You may add multiple custom validators and they will be executed in the order you added them.
      */
-    custom<OUT2 = OUT>(validator: CustomValidatorFn): JsonSchemaAnyBuilder<OUT2, Opt>;
+    custom<OUT2 = OUT>(validator: CustomValidatorFn): JBuilder<OUT2, Opt>;
     /**
      *
      * @param converter A converter function that returns a new value.
@@ -310,9 +208,9 @@ export declare class JsonSchemaAnyBuilder<OUT, Opt> extends JsonSchemaTerminal<O
      * This feature only works when the current schema is nested in an object or array schema,
      * due to how mutability works in Ajv.
      */
-    convert<OUT2>(converter: CustomConverterFn<OUT2>): JsonSchemaAnyBuilder<OUT2, Opt>;
+    convert<OUT2>(converter: CustomConverterFn<OUT2>): JBuilder<OUT2, Opt>;
 }
-export declare class JsonSchemaStringBuilder<OUT extends string | undefined = string, Opt extends boolean = false> extends JsonSchemaAnyBuilder<OUT, Opt> {
+export declare class JString<OUT extends string | undefined = string, Opt extends boolean = false> extends JBuilder<OUT, Opt> {
     constructor();
     /**
      * @param optionalValues List of values that should be considered/converted as `undefined`.
@@ -322,10 +220,10 @@ export declare class JsonSchemaStringBuilder<OUT extends string | undefined = st
      *
      * Make sure this `optional()` call is at the end of your call chain.
      *
-     * When `null` is included in optionalValues, the return type becomes `JsonSchemaTerminal`
+     * When `null` is included in optionalValues, the return type becomes `JSchema`
      * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
      */
-    optional<T extends readonly (string | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JsonSchemaTerminal<OUT | undefined, true> : JsonSchemaStringBuilder<OUT | undefined, true> : JsonSchemaStringBuilder<OUT | undefined, true>;
+    optional<T extends readonly (string | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JSchema<OUT | undefined, true> : JString<OUT | undefined, true> : JString<OUT | undefined, true>;
     regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this;
     pattern(pattern: string, opt?: JsonBuilderRuleOpt): this;
     minLength(minLength: number): this;
@@ -337,16 +235,16 @@ export declare class JsonSchemaStringBuilder<OUT extends string | undefined = st
     toLowerCase(): this;
     toUpperCase(): this;
     truncate(toLength: number): this;
-    branded<B extends string>(): JsonSchemaStringBuilder<B, Opt>;
+    branded<B extends string>(): JString<B, Opt>;
     /**
      * Validates that the input is a fully-specified YYYY-MM-DD formatted valid IsoDate value.
      *
      * All previous expectations in the schema chain are dropped - including `.optional()` -
      * because this call effectively starts a new schema chain.
      */
-    isoDate(): JsonSchemaIsoDateBuilder;
-    isoDateTime(): JsonSchemaStringBuilder<IsoDateTime, Opt>;
-    isoMonth(): JsonSchemaIsoMonthBuilder;
+    isoDate(): JIsoDate;
+    isoDateTime(): JString<IsoDateTime, Opt>;
+    isoMonth(): JBuilder<IsoMonth, false>;
     /**
      * Validates the string format to be JWT.
      * Expects the JWT to be signed!
@@ -366,14 +264,14 @@ export declare class JsonSchemaStringBuilder<OUT extends string | undefined = st
      * All previous expectations in the schema chain are dropped - including `.optional()` -
      * because this call effectively starts a new schema chain as an `enum` validation.
      */
-    ianaTimezone(): JsonSchemaEnumBuilder<IANATimezone, false>;
+    ianaTimezone(): JEnum<IANATimezone, false>;
     base64Url(): this;
     uuid(): this;
 }
 export interface JsonSchemaStringEmailOptions {
     checkTLD: boolean;
 }
-export declare class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<IsoDate, Opt> {
+export declare class JIsoDate<Opt extends boolean = false> extends JBuilder<IsoDate, Opt> {
     constructor();
     /**
      * @param nullValue Pass `null` to have `null` values be considered/converted as `undefined`.
@@ -381,10 +279,10 @@ export declare class JsonSchemaIsoDateBuilder<Opt extends boolean = false> exten
      * This `null` feature only works when the current schema is nested in an object or array schema,
      * due to how mutability works in Ajv.
      *
-     * When `null` is passed, the return type becomes `JsonSchemaTerminal`
+     * When `null` is passed, the return type becomes `JSchema`
      * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
      */
-    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JsonSchemaTerminal<IsoDate | undefined, true> : JsonSchemaAnyBuilder<IsoDate | undefined, true>;
+    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JSchema<IsoDate | undefined, true> : JBuilder<IsoDate | undefined, true>;
     before(date: string): this;
     sameOrBefore(date: string): this;
     after(date: string): this;
@@ -397,12 +295,9 @@ export interface JsonSchemaIsoDateOptions {
     after?: string;
     sameOrAfter?: string;
 }
-export declare class JsonSchemaIsoMonthBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<IsoMonth, Opt> {
-    constructor();
-}
 export interface JsonSchemaIsoMonthOptions {
 }
-export declare class JsonSchemaNumberBuilder<OUT extends number | undefined = number, Opt extends boolean = false> extends JsonSchemaAnyBuilder<OUT, Opt> {
+export declare class JNumber<OUT extends number | undefined = number, Opt extends boolean = false> extends JBuilder<OUT, Opt> {
     constructor();
     /**
      * @param optionalValues List of values that should be considered/converted as `undefined`.
@@ -412,12 +307,12 @@ export declare class JsonSchemaNumberBuilder<OUT extends number | undefined = nu
      *
      * Make sure this `optional()` call is at the end of your call chain.
      *
-     * When `null` is included in optionalValues, the return type becomes `JsonSchemaTerminal`
+     * When `null` is included in optionalValues, the return type becomes `JSchema`
      * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
      */
-    optional<T extends readonly (number | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JsonSchemaTerminal<OUT | undefined, true> : JsonSchemaNumberBuilder<OUT | undefined, true> : JsonSchemaNumberBuilder<OUT | undefined, true>;
+    optional<T extends readonly (number | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JSchema<OUT | undefined, true> : JNumber<OUT | undefined, true> : JNumber<OUT | undefined, true>;
     integer(): this;
-    branded<B extends number>(): JsonSchemaNumberBuilder<B, Opt>;
+    branded<B extends number>(): JNumber<B, Opt>;
     multipleOf(multipleOf: number): this;
     min(minimum: number): this;
     exclusiveMin(exclusiveMinimum: number): this;
@@ -433,10 +328,10 @@ export declare class JsonSchemaNumberBuilder<OUT extends number | undefined = nu
     int64(): this;
     float(): this;
     double(): this;
-    unixTimestamp(): JsonSchemaNumberBuilder<UnixTimestamp, Opt>;
-    unixTimestamp2000(): JsonSchemaNumberBuilder<UnixTimestamp, Opt>;
-    unixTimestampMillis(): JsonSchemaNumberBuilder<UnixTimestampMillis, Opt>;
-    unixTimestamp2000Millis(): JsonSchemaNumberBuilder<UnixTimestampMillis, Opt>;
+    unixTimestamp(): JNumber<UnixTimestamp, Opt>;
+    unixTimestamp2000(): JNumber<UnixTimestamp, Opt>;
+    unixTimestampMillis(): JNumber<UnixTimestampMillis, Opt>;
+    unixTimestamp2000Millis(): JNumber<UnixTimestampMillis, Opt>;
     utcOffset(): this;
     utcOffsetHour(): this;
     /**
@@ -446,7 +341,7 @@ export declare class JsonSchemaNumberBuilder<OUT extends number | undefined = nu
      */
     precision(numberOfDigits: number): this;
 }
-export declare class JsonSchemaBooleanBuilder<OUT extends boolean | undefined = boolean, Opt extends boolean = false> extends JsonSchemaAnyBuilder<OUT, Opt> {
+export declare class JBoolean<OUT extends boolean | undefined = boolean, Opt extends boolean = false> extends JBuilder<OUT, Opt> {
     constructor();
     /**
      * @param optionalValue One of the two possible boolean values that should be considered/converted as `undefined`.
@@ -454,29 +349,28 @@ export declare class JsonSchemaBooleanBuilder<OUT extends boolean | undefined =
      * This `optionalValue` feature only works when the current schema is nested in an object or array schema,
      * due to how mutability works in Ajv.
      */
-    optional(optionalValue?: boolean): JsonSchemaBooleanBuilder<OUT | undefined, true>;
+    optional(optionalValue?: boolean): JBoolean<OUT | undefined, true>;
 }
-export declare class JsonSchemaObjectBuilder<OUT extends AnyObject, Opt extends boolean = false> extends JsonSchemaAnyBuilder<OUT, Opt> {
-    constructor(props?: AnyObject, opt?: JsonSchemaObjectBuilderOpts);
-    addProperties(props: AnyObject): this;
+export declare class JObject<OUT extends AnyObject, Opt extends boolean = false> extends JBuilder<OUT, Opt> {
+    constructor(props?: AnyObject, opt?: JObjectOpts);
     /**
      * @param nullValue Pass `null` to have `null` values be considered/converted as `undefined`.
      *
      * This `null` feature only works when the current schema is nested in an object or array schema,
      * due to how mutability works in Ajv.
      *
-     * When `null` is passed, the return type becomes `JsonSchemaTerminal`
+     * When `null` is passed, the return type becomes `JSchema`
      * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
      */
-    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JsonSchemaTerminal<OUT | undefined, true> : JsonSchemaAnyBuilder<OUT | undefined, true>;
+    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JSchema<OUT | undefined, true> : JBuilder<OUT | undefined, true>;
     /**
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties(): this;
-    extend<P extends Record<string, JsonSchemaAnyBuilder<any, any>>>(props: P): JsonSchemaObjectBuilder<Override<OUT, {
-        [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: P[K] extends JsonSchemaAnyBuilder<infer OUT2, any> ? OUT2 : never;
+    extend<P extends Record<string, JBuilder<any, any>>>(props: P): JObject<Override<OUT, {
+        [K in keyof P as P[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: P[K] extends JBuilder<infer OUT2, any> ? OUT2 : never;
     } & {
-        [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: P[K] extends JsonSchemaAnyBuilder<infer OUT2, any> ? OUT2 : never;
+        [K in keyof P as P[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: P[K] extends JBuilder<infer OUT2, any> ? OUT2 : never;
     }>, false>;
     /**
      * Concatenates another schema to the current schema.
@@ -484,23 +378,12 @@ export declare class JsonSchemaObjectBuilder<OUT extends AnyObject, Opt extends
      * It expects you to use `isOfType<T>()` in the chain,
      * otherwise the validation will throw. This is to ensure
      * that the schemas you concatenated match the intended final type.
-     *
-     * ```ts
-     *  interface Foo { foo: string }
-     *  const fooSchema = j.object<Foo>({ foo: j.string() })
-     *
-     *  interface Bar { bar: number }
-     *  const barSchema = j.object<Bar>({ bar: j.number() })
-     *
-     *  interface Shu { foo: string, bar: number }
-     *  const shuSchema = fooSchema.concat(barSchema).isOfType<Shu>() // important
-     * ```
      */
-    concat<OUT2 extends AnyObject>(other: JsonSchemaObjectBuilder<OUT2, any>): JsonSchemaObjectBuilder<OUT & OUT2, false>;
+    concat<OUT2 extends AnyObject>(other: JObject<OUT2, any>): JObject<OUT & OUT2, false>;
     /**
      * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
      */
-    dbEntity(): JsonSchemaObjectBuilder<Override<OUT, {
+    dbEntity(): JObject<Override<OUT, {
         id: string;
         created: any;
         updated: any;
@@ -509,54 +392,53 @@ export declare class JsonSchemaObjectBuilder<OUT extends AnyObject, Opt extends
     maxProperties(maxProperties: number): this;
     exclusiveProperties(propNames: readonly (keyof OUT & string)[]): this;
 }
-interface JsonSchemaObjectBuilderOpts {
+interface JObjectOpts {
     hasIsOfTypeCheck?: false;
     patternProperties?: StringMap<JsonSchema<any>>;
     keySchema?: JsonSchema;
 }
-export declare class JsonSchemaObjectInferringBuilder<PROPS extends Record<string, JsonSchemaAnyBuilder<any, any>>, Opt extends boolean = false> extends JsonSchemaAnyBuilder<Expand<{
-    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
+export declare class JObjectInfer<PROPS extends Record<string, JBuilder<any, any>>, Opt extends boolean = false> extends JBuilder<Expand<{
+    [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
 } & {
-    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
+    [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
 }>, Opt> {
     constructor(props?: PROPS);
-    addProperties(props: PROPS): this;
     /**
      * @param nullValue Pass `null` to have `null` values be considered/converted as `undefined`.
      *
      * This `null` feature only works when the current schema is nested in an object or array schema,
      * due to how mutability works in Ajv.
      *
-     * When `null` is passed, the return type becomes `JsonSchemaTerminal`
+     * When `null` is passed, the return type becomes `JSchema`
      * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
      */
-    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JsonSchemaTerminal<Expand<{
-        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
+    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JSchema<Expand<{
+        [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
     } & {
-        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
-    }> | undefined, true> : JsonSchemaAnyBuilder<Expand<{
-        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
+        [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
+    }> | undefined, true> : JBuilder<Expand<{
+        [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
     } & {
-        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
+        [K in keyof PROPS as PROPS[K] extends JBuilder<any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JBuilder<infer OUT, any> ? OUT : never;
     }> | undefined, true>;
     /**
      * When set, the validation will not strip away properties that are not specified explicitly in the schema.
      */
     allowAdditionalProperties(): this;
-    extend<NEW_PROPS extends Record<string, JsonSchemaAnyBuilder<any, any>>>(props: NEW_PROPS): JsonSchemaObjectInferringBuilder<{
+    extend<NEW_PROPS extends Record<string, JBuilder<any, any>>>(props: NEW_PROPS): JObjectInfer<{
         [K in keyof PROPS | keyof NEW_PROPS]: K extends keyof NEW_PROPS ? NEW_PROPS[K] : K extends keyof PROPS ? PROPS[K] : never;
     }, Opt>;
     /**
      * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
      */
-    dbEntity(): JsonSchemaObjectInferringBuilder<{ [K in "created" | "id" | "updated" | keyof PROPS]: K extends "created" | "id" | "updated" ? {
-        id: JsonSchemaStringBuilder<string, false>;
-        created: JsonSchemaNumberBuilder<UnixTimestamp, false>;
-        updated: JsonSchemaNumberBuilder<UnixTimestamp, false>;
+    dbEntity(): JObjectInfer<{ [K in "created" | "id" | "updated" | keyof PROPS]: K extends "created" | "id" | "updated" ? {
+        id: JString<string, false>;
+        created: JNumber<UnixTimestamp, false>;
+        updated: JNumber<UnixTimestamp, false>;
     }[K] : K extends keyof PROPS ? PROPS[K] : never; }, Opt>;
 }
-export declare class JsonSchemaArrayBuilder<OUT, Opt> extends JsonSchemaAnyBuilder<OUT[], Opt> {
-    constructor(itemsSchema: JsonSchemaAnyBuilder<OUT, Opt>);
+export declare class JArray<OUT, Opt> extends JBuilder<OUT[], Opt> {
+    constructor(itemsSchema: JBuilder<OUT, Opt>);
     minLength(minItems: number): this;
     maxLength(maxItems: number): this;
     length(exactLength: number): this;
@@ -564,28 +446,138 @@ export declare class JsonSchemaArrayBuilder<OUT, Opt> extends JsonSchemaAnyBuild
     exactLength(length: number): this;
     unique(): this;
 }
-export declare class JsonSchemaSet2Builder<OUT, Opt> extends JsonSchemaAnyBuilder<Set2<OUT>, Opt> {
-    constructor(itemsSchema: JsonSchemaAnyBuilder<OUT, Opt>);
+declare class JSet2Builder<OUT, Opt> extends JBuilder<Set2<OUT>, Opt> {
+    constructor(itemsSchema: JBuilder<OUT, Opt>);
     min(minItems: number): this;
     max(maxItems: number): this;
 }
-export declare class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder<Buffer, false> {
-    constructor();
-}
-export declare class JsonSchemaEnumBuilder<OUT extends string | number | boolean | null, Opt extends boolean = false> extends JsonSchemaAnyBuilder<OUT, Opt> {
+export declare class JEnum<OUT extends string | number | boolean | null, Opt extends boolean = false> extends JBuilder<OUT, Opt> {
     constructor(enumValues: readonly OUT[], baseType: EnumBaseType, opt?: JsonBuilderRuleOpt);
-    branded<B extends OUT>(): JsonSchemaEnumBuilder<B, Opt>;
+    branded<B extends OUT>(): JEnum<B, Opt>;
 }
-export declare class JsonSchemaTupleBuilder<ITEMS extends JsonSchemaAnyBuilder<any, any>[]> extends JsonSchemaAnyBuilder<TupleOut<ITEMS>, false> {
+export declare class JTuple<ITEMS extends JBuilder<any, any>[]> extends JBuilder<TupleOut<ITEMS>, false> {
     constructor(items: ITEMS);
 }
-export declare class JsonSchemaAnyOfByBuilder<OUT> extends JsonSchemaAnyBuilder<OUT, false> {
-    constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any>>);
-}
-export declare class JsonSchemaAnyOfTheseBuilder<OUT> extends JsonSchemaAnyBuilder<OUT, false> {
-    constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any>>);
+declare function object(props: AnyObject): never;
+declare function object<OUT extends AnyObject>(props: {
+    [K in keyof Required<OUT>]-?: JSchema<OUT[K], any>;
+}): JObject<OUT, false>;
+declare function objectInfer<P extends Record<string, JBuilder<any, any>>>(props: P): JObjectInfer<P, false>;
+declare function objectDbEntity(props: AnyObject): never;
+declare function objectDbEntity<OUT extends BaseDBEntity, EXTRA_KEYS extends Exclude<keyof OUT, keyof BaseDBEntity> = Exclude<keyof OUT, keyof BaseDBEntity>>(props: {
+    [K in EXTRA_KEYS]-?: BuilderFor<OUT[K]>;
+} & (ExactMatch<OUT['id'], BaseDBEntity['id']> extends true ? {
+    id?: BuilderFor<BaseDBEntity['id']>;
+} : {
+    id: BuilderFor<OUT['id']>;
+}) & (ExactMatch<OUT['created'], BaseDBEntity['created']> extends true ? {
+    created?: BuilderFor<BaseDBEntity['created']>;
+} : {
+    created: BuilderFor<OUT['created']>;
+}) & (ExactMatch<OUT['updated'], BaseDBEntity['updated']> extends true ? {
+    updated?: BuilderFor<BaseDBEntity['updated']>;
+} : {
+    updated: BuilderFor<OUT['updated']>;
+})): JObject<OUT, false>;
+declare function record<KS extends JBuilder<any, any>, VS extends JBuilder<any, any>, Opt extends boolean = SchemaOpt<VS>>(keySchema: KS, valueSchema: VS): JObject<Opt extends true ? Partial<Record<SchemaOut<KS>, SchemaOut<VS>>> : Record<SchemaOut<KS>, SchemaOut<VS>>, false>;
+declare function withRegexKeys<S extends JBuilder<any, any>>(keyRegex: RegExp | string, schema: S): JObject<StringMap<SchemaOut<S>>, false>;
+/**
+ * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
+ */
+declare function withEnumKeys<const T extends readonly (string | number)[] | StringEnum | NumberEnum, S extends JBuilder<any, any>, K extends string | number = EnumKeyUnion<T>, Opt extends boolean = SchemaOpt<S>>(keys: T, schema: S): JObject<Opt extends true ? {
+    [P in K]?: SchemaOut<S>;
+} : {
+    [P in K]: SchemaOut<S>;
+}, false>;
+/**
+ * On creation - compiles ajv validation function.
+ * Provides convenient methods, error reporting, etc.
+ */
+export declare class AjvSchema<OUT> {
+    schema: JsonSchema<OUT>;
+    private constructor();
+    /**
+     * Shortcut for AjvSchema.create(schema, { lazy: true })
+     */
+    static createLazy<OUT>(schema: SchemaHandledByAjv<OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<OUT>;
+    /**
+     * Conveniently allows to pass either JsonSchema or JSchema builder, 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.
+     */
+    static create<OUT>(schema: SchemaHandledByAjv<OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<OUT>;
+    /**
+     * Creates a minimal AjvSchema wrapper from a pre-compiled validate function.
+     * Used internally by JSchema to cache a compatible AjvSchema instance.
+     */
+    static _wrap<OUT>(schema: JsonSchema<OUT>, compiledFn: any): AjvSchema<OUT>;
+    static isSchemaWithCachedAjvSchema<Base, OUT>(schema: Base): schema is WithCachedAjvSchema<Base, OUT>;
+    static cacheAjvSchema<Base extends AnyObject, OUT>(schema: Base, ajvSchema: AjvSchema<OUT>): WithCachedAjvSchema<Base, OUT>;
+    static requireCachedAjvSchema<Base, OUT>(schema: WithCachedAjvSchema<Base, OUT>): AjvSchema<OUT>;
+    readonly cfg: AjvSchemaCfg;
+    private _compiledFn;
+    private _getValidateFn;
+    /**
+     * It returns the original object just for convenience.
+     */
+    validate(input: unknown, opt?: AjvValidationOptions): OUT;
+    isValid(input: unknown, opt?: AjvValidationOptions): boolean;
+    getValidationResult(input: unknown, opt?: AjvValidationOptions): ValidationFunctionResult<OUT, AjvValidationError>;
+    getValidationFunction(): ValidationFunction<OUT, AjvValidationError>;
+    private static requireValidJsonSchema;
 }
 type EnumBaseType = 'string' | 'number' | 'other';
+export interface AjvValidationOptions {
+    /**
+     * Custom Ajv instance to use for this validation.
+     * Overrides the default Ajv or any Ajv set at construction time.
+     * Compiled functions are cached per Ajv instance.
+     */
+    ajv?: Ajv;
+    /**
+     * Defaults to true,
+     * because that's how AJV works by default,
+     * and what gives it performance advantage.
+     * (Because we have found that deep-clone is surprisingly slow,
+     * nearly as slow as Joi validation).
+     *
+     * If set to true - AJV will mutate the input in case it needs to apply transformations
+     * (strip unknown properties, convert types, etc).
+     *
+     * If false - it will deep-clone (using JSON.stringify+parse) the input to prevent its mutation.
+     * Will return the cloned/mutated object.
+     * Please note that JSON.stringify+parse has side-effects,
+     * e.g it will transform Buffer into a weird object.
+     */
+    mutateInput?: boolean;
+    inputName?: string;
+    inputId?: string;
+    /**
+     * Function that returns "original input".
+     * What is original input?
+     * It's an input in its original non-mutated form.
+     * Why is it needed?
+     * Because we mutates the Input here. And after its been mutated - we no longer
+     * can include it "how it was" in an error message. So, for that reason we'll use
+     * `getOriginalInput()`, if it's provided.
+     */
+    getOriginalInput?: () => unknown;
+}
+export interface AjvSchemaCfg {
+    /**
+     * Pass Ajv instance, otherwise Ajv will be created with
+     * AjvSchema default (not the same as Ajv defaults) parameters
+     */
+    ajv: Ajv;
+    inputName?: string;
+    /**
+     * If true - schema will be compiled on-demand (lazily).
+     * Default: false.
+     */
+    lazy?: boolean;
+}
+export type SchemaHandledByAjv<OUT> = JSchema<OUT, any> | JsonSchema<OUT> | AjvSchema<OUT>;
 export interface JsonSchema<OUT = unknown> {
     readonly out?: OUT;
     $schema?: string;
@@ -662,37 +654,9 @@ export interface JsonSchema<OUT = unknown> {
     customConversions?: CustomConverterFn<any>[];
     postValidation?: PostValidatonFn<any, OUT>;
 }
-declare function object(props: AnyObject): never;
-declare function object<OUT extends AnyObject>(props: {
-    [K in keyof Required<OUT>]-?: JsonSchemaTerminal<OUT[K], any>;
-}): JsonSchemaObjectBuilder<OUT, false>;
-declare function objectInfer<P extends Record<string, JsonSchemaAnyBuilder<any, any>>>(props: P): JsonSchemaObjectInferringBuilder<P, false>;
-declare function objectDbEntity(props: AnyObject): never;
-declare function objectDbEntity<OUT extends BaseDBEntity, EXTRA_KEYS extends Exclude<keyof OUT, keyof BaseDBEntity> = Exclude<keyof OUT, keyof BaseDBEntity>>(props: {
-    [K in EXTRA_KEYS]-?: BuilderFor<OUT[K]>;
-} & (ExactMatch<OUT['id'], BaseDBEntity['id']> extends true ? {
-    id?: BuilderFor<BaseDBEntity['id']>;
-} : {
-    id: BuilderFor<OUT['id']>;
-}) & (ExactMatch<OUT['created'], BaseDBEntity['created']> extends true ? {
-    created?: BuilderFor<BaseDBEntity['created']>;
-} : {
-    created: BuilderFor<OUT['created']>;
-}) & (ExactMatch<OUT['updated'], BaseDBEntity['updated']> extends true ? {
-    updated?: BuilderFor<BaseDBEntity['updated']>;
-} : {
-    updated: BuilderFor<OUT['updated']>;
-})): JsonSchemaObjectBuilder<OUT, false>;
-declare function record<KS extends JsonSchemaAnyBuilder<any, any>, VS extends JsonSchemaAnyBuilder<any, any>, Opt extends boolean = SchemaOpt<VS>>(keySchema: KS, valueSchema: VS): JsonSchemaObjectBuilder<Opt extends true ? Partial<Record<SchemaOut<KS>, SchemaOut<VS>>> : Record<SchemaOut<KS>, SchemaOut<VS>>, false>;
-declare function withRegexKeys<S extends JsonSchemaAnyBuilder<any, any>>(keyRegex: RegExp | string, schema: S): JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>, false>;
-/**
- * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
- */
-declare function withEnumKeys<const T extends readonly (string | number)[] | StringEnum | NumberEnum, S extends JsonSchemaAnyBuilder<any, any>, K extends string | number = EnumKeyUnion<T>, Opt extends boolean = SchemaOpt<S>>(keys: T, schema: S): JsonSchemaObjectBuilder<Opt extends true ? {
-    [P in K]?: SchemaOut<S>;
-} : {
-    [P in K]: SchemaOut<S>;
-}, false>;
+export type PostValidatonFn<OUT, OUT2> = (v: OUT) => OUT2;
+export type CustomValidatorFn = (v: any) => string | undefined;
+export type CustomConverterFn<OUT> = (v: any) => OUT;
 type Expand<T> = {
     [K in keyof T]: T[K];
 };
@@ -711,14 +675,14 @@ type IsAny<T> = 0 extends 1 & T ? true : false;
 type IsAssignableRelaxed<A, B> = IsAny<RelaxIndexSignature<A>> extends true ? true : [RelaxIndexSignature<A>] extends [B] ? true : false;
 type ExactMatchBase<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => (T extends B ? 1 : 2) ? (<T>() => T extends B ? 1 : 2) extends <T>() => (T extends A ? 1 : 2) ? true : false : false;
 type ExactMatch<A, B> = HasAllowExtraKeys<B> extends true ? IsAssignableRelaxed<B, A> : ExactMatchBase<Expand<A>, Expand<B>> extends true ? true : ExactMatchBase<Expand<StripIndexSignatureDeep<A>>, Expand<StripIndexSignatureDeep<B>>>;
-type BuilderOutUnion<B extends readonly JsonSchemaAnyBuilder<any, any>[]> = {
-    [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<infer O, any> ? O : never;
+type BuilderOutUnion<B extends readonly JBuilder<any, any>[]> = {
+    [K in keyof B]: B[K] extends JBuilder<infer O, any> ? O : never;
 }[number];
-type AnyOfByOut<D extends Record<PropertyKey, JsonSchemaTerminal<any, any>>> = {
-    [K in keyof D]: D[K] extends JsonSchemaTerminal<infer O, any> ? O : never;
+type AnyOfByOut<D extends Record<PropertyKey, JSchema<any, any>>> = {
+    [K in keyof D]: D[K] extends JSchema<infer O, any> ? O : never;
 }[keyof D];
-type BuilderFor<T> = JsonSchemaAnyBuilder<T, any>;
-interface JsonBuilderRuleOpt {
+type BuilderFor<T> = JBuilder<T, any>;
+export interface JsonBuilderRuleOpt {
     /**
      * Text of error message to return when the validation fails for the given rule:
      *
@@ -733,12 +697,9 @@ interface JsonBuilderRuleOpt {
     name?: string;
 }
 type EnumKeyUnion<T> = T extends readonly (infer U)[] ? U : T extends StringEnum | NumberEnum ? T[keyof T] : never;
-type SchemaOut<S> = S extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never;
-type SchemaOpt<S> = S extends JsonSchemaAnyBuilder<any, infer Opt> ? (Opt extends true ? true : false) : false;
-type TupleOut<T extends readonly JsonSchemaAnyBuilder<any, any>[]> = {
-    [K in keyof T]: T[K] extends JsonSchemaAnyBuilder<infer O, any> ? O : never;
+type SchemaOut<S> = S extends JBuilder<infer OUT, any> ? OUT : never;
+type SchemaOpt<S> = S extends JBuilder<any, infer Opt> ? (Opt extends true ? true : false) : false;
+type TupleOut<T extends readonly JBuilder<any, any>[]> = {
+    [K in keyof T]: T[K] extends JBuilder<infer O, any> ? O : never;
 };
-export type PostValidatonFn<OUT, OUT2> = (v: OUT) => OUT2;
-export type CustomValidatorFn = (v: any) => string | undefined;
-export type CustomConverterFn<OUT> = (v: any) => OUT;
 export {};