@naturalcycles/nodejs-lib 15.90.2 → 15.92.0

package/src/validation/ajv/ajvSchema.ts

@@ -1,24 +1,69 @@
-import { _isObject, _lazyValue } from '@naturalcycles/js-lib'
+/* eslint-disable id-denylist */
+// oxlint-disable max-lines
+
 import type { ValidationFunction, ValidationFunctionResult } from '@naturalcycles/js-lib'
-import { _assert } from '@naturalcycles/js-lib/error'
-import { _deepCopy, _filterNullishValues } from '@naturalcycles/js-lib/object'
+import {
+  _isObject,
+  _isUndefined,
+  _lazyValue,
+  _numberEnumValues,
+  _stringEnumValues,
+  getEnumType,
+} from '@naturalcycles/js-lib'
+import { _uniq } from '@naturalcycles/js-lib/array'
+import { _assert, _try } from '@naturalcycles/js-lib/error'
+import type { Set2 } from '@naturalcycles/js-lib/object'
+import { _deepCopy, _filterNullishValues, _sortObject } from '@naturalcycles/js-lib/object'
 import { _substringBefore } from '@naturalcycles/js-lib/string'
-import { _typeCast } from '@naturalcycles/js-lib/types'
-import type { AnyObject } from '@naturalcycles/js-lib/types'
+import type {
+  AnyObject,
+  BaseDBEntity,
+  IANATimezone,
+  Inclusiveness,
+  IsoDate,
+  IsoDateTime,
+  IsoMonth,
+  NumberEnum,
+  StringEnum,
+  StringMap,
+  UnixTimestamp,
+  UnixTimestampMillis,
+} from '@naturalcycles/js-lib/types'
+import { _objectAssign, _typeCast, JWT_REGEX } from '@naturalcycles/js-lib/types'
 import type { Ajv, ErrorObject } from 'ajv'
 import { _inspect } from '../../string/inspect.js'
+import {
+  BASE64URL_REGEX,
+  COUNTRY_CODE_REGEX,
+  CURRENCY_REGEX,
+  IPV4_REGEX,
+  IPV6_REGEX,
+  LANGUAGE_TAG_REGEX,
+  SEMVER_REGEX,
+  SLUG_REGEX,
+  URL_REGEX,
+  UUID_REGEX,
+} from '../regexes.js'
+import { TIMEZONES } from '../timezones.js'
 import { AjvValidationError } from './ajvValidationError.js'
 import { getAjv } from './getAjv.js'
-import { JsonSchemaTerminal } from './jsonSchemaBuilder.js'
-import type { JsonSchema } from './jsonSchemaBuilder.js'
+import {
+  isEveryItemNumber,
+  isEveryItemPrimitive,
+  isEveryItemString,
+  JSON_SCHEMA_ORDER,
+  mergeJsonSchemaObjects,
+} from './jsonSchemaBuilder.util.js'
+
+// ==== AJV =====
 
 /**
  * On creation - compiles ajv validation function.
  * Provides convenient methods, error reporting, etc.
  */
-export class AjvSchema<IN = unknown, OUT = IN> {
+export class AjvSchema<OUT> {
   private constructor(
-    public schema: JsonSchema<IN, OUT>,
+    public schema: JsonSchema<OUT>,
     cfg: Partial<AjvSchemaCfg> = {},
   ) {
     this.cfg = {
@@ -37,10 +82,10 @@ export class AjvSchema<IN = unknown, OUT = IN> {
   /**
    * Shortcut for AjvSchema.create(schema, { lazy: true })
    */
-  static createLazy<IN, OUT>(
-    schema: SchemaHandledByAjv<IN, OUT>,
+  static createLazy<OUT>(
+    schema: SchemaHandledByAjv<OUT>,
     cfg?: Partial<AjvSchemaCfg>,
-  ): AjvSchema<IN, OUT> {
+  ): AjvSchema<OUT> {
     return AjvSchema.create(schema, {
       lazy: true,
       ...cfg,
@@ -56,21 +101,18 @@ export class AjvSchema<IN = unknown, OUT = IN> {
    * 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> {
+  static create<OUT>(schema: SchemaHandledByAjv<OUT>, cfg?: Partial<AjvSchemaCfg>): AjvSchema<OUT> {
     if (schema instanceof AjvSchema) return schema
 
-    if (AjvSchema.isSchemaWithCachedAjvSchema<typeof schema, IN, OUT>(schema)) {
-      return AjvSchema.requireCachedAjvSchema<typeof schema, IN, OUT>(schema)
+    if (AjvSchema.isSchemaWithCachedAjvSchema<typeof schema, OUT>(schema)) {
+      return AjvSchema.requireCachedAjvSchema<typeof schema, OUT>(schema)
     }
 
-    let jsonSchema: JsonSchema<IN, OUT>
+    let jsonSchema: JsonSchema<OUT>
 
     if (AjvSchema.isJsonSchemaBuilder(schema)) {
       // oxlint-disable typescript-eslint(no-unnecessary-type-assertion)
-      jsonSchema = (schema as JsonSchemaTerminal<IN, OUT, any>).build()
+      jsonSchema = (schema as JsonSchemaTerminal<OUT, any>).build()
       AjvSchema.requireValidJsonSchema(jsonSchema)
     } else {
       jsonSchema = schema
@@ -83,13 +125,13 @@ export class AjvSchema<IN = unknown, OUT = IN> {
     // really upsets Ajv.
     delete jsonSchema.optionalField
 
-    const ajvSchema = new AjvSchema<IN, OUT>(jsonSchema, cfg)
+    const ajvSchema = new AjvSchema<OUT>(jsonSchema, cfg)
     AjvSchema.cacheAjvSchema(schema, ajvSchema)
 
     return ajvSchema
   }
 
-  static isJsonSchemaBuilder<IN, OUT>(schema: unknown): schema is JsonSchemaTerminal<IN, OUT, any> {
+  static isJsonSchemaBuilder<OUT>(schema: unknown): schema is JsonSchemaTerminal<OUT, any> {
     return schema instanceof JsonSchemaTerminal
   }
 
@@ -103,13 +145,13 @@ export class AjvSchema<IN = unknown, OUT = IN> {
    *
    * Returned object is always the same object (`===`) that was passed, so it is returned just for convenience.
    */
-  validate(input: IN, opt: AjvValidationOptions<IN> = {}): OUT {
+  validate(input: unknown, opt: AjvValidationOptions = {}): OUT {
     const [err, output] = this.getValidationResult(input, opt)
     if (err) throw err
     return output
   }
 
-  isValid(input: IN, opt?: AjvValidationOptions<IN>): boolean {
+  isValid(input: unknown, opt?: AjvValidationOptions): boolean {
     // todo: we can make it both fast and non-mutating by using Ajv
     // with "removeAdditional" and "useDefaults" disabled.
     const [err] = this.getValidationResult(input, opt)
@@ -117,8 +159,8 @@ export class AjvSchema<IN = unknown, OUT = IN> {
   }
 
   getValidationResult(
-    input: IN,
-    opt: AjvValidationOptions<IN> = {},
+    input: unknown,
+    opt: AjvValidationOptions = {},
   ): ValidationFunctionResult<OUT, AjvValidationError> {
     const fn = this.getAJVValidateFunction()
 
@@ -127,14 +169,31 @@ export class AjvSchema<IN = unknown, OUT = IN> {
         ? input // mutate
         : _deepCopy(input) // not mutate
 
-    const valid = fn(item) // mutates item, but not input
+    let valid = fn(item) // mutates item, but not input
     _typeCast<OUT>(item)
-    if (valid) return [null, item]
+
+    let output: OUT = item
+    if (valid && this.schema.postValidation) {
+      const [err, result] = _try(() => this.schema.postValidation!(output))
+      if (err) {
+        valid = false
+        ;(fn as any).errors = [
+          {
+            instancePath: '',
+            message: err.message,
+          },
+        ]
+      } else {
+        output = result
+      }
+    }
+
+    if (valid) return [null, output]
 
     const errors = fn.errors!
 
     const {
-      inputId = _isObject(input) ? input['id' as keyof IN] : undefined,
+      inputId = _isObject(input) ? (input as any)['id'] : undefined,
       inputName = this.cfg.inputName || 'Object',
     } = opt
     const dataVar = [inputName, inputId].filter(Boolean).join('.')
@@ -160,10 +219,10 @@ export class AjvSchema<IN = unknown, OUT = IN> {
         inputId,
       }),
     )
-    return [err, item]
+    return [err, output]
   }
 
-  getValidationFunction(): ValidationFunction<IN, OUT, AjvValidationError> {
+  getValidationFunction(): ValidationFunction<OUT, AjvValidationError> {
     return (input, opt) => {
       return this.getValidationResult(input, {
         mutateInput: opt?.mutateInput,
@@ -173,22 +232,20 @@ export class AjvSchema<IN = unknown, OUT = IN> {
     }
   }
 
-  static isSchemaWithCachedAjvSchema<Base, IN, OUT>(
+  static isSchemaWithCachedAjvSchema<Base, OUT>(
     schema: Base,
-  ): schema is WithCachedAjvSchema<Base, IN, OUT> {
+  ): schema is WithCachedAjvSchema<Base, OUT> {
     return !!(schema as any)?.[HIDDEN_AJV_SCHEMA]
   }
 
-  static cacheAjvSchema<Base extends AnyObject, IN, OUT>(
+  static cacheAjvSchema<Base extends AnyObject, OUT>(
     schema: Base,
-    ajvSchema: AjvSchema<IN, OUT>,
-  ): WithCachedAjvSchema<Base, IN, OUT> {
+    ajvSchema: AjvSchema<OUT>,
+  ): WithCachedAjvSchema<Base, OUT> {
     return Object.assign(schema, { [HIDDEN_AJV_SCHEMA]: ajvSchema })
   }
 
-  static requireCachedAjvSchema<Base, IN, OUT>(
-    schema: WithCachedAjvSchema<Base, IN, OUT>,
-  ): AjvSchema<IN, OUT> {
+  static requireCachedAjvSchema<Base, OUT>(schema: WithCachedAjvSchema<Base, OUT>): AjvSchema<OUT> {
     return schema[HIDDEN_AJV_SCHEMA]
   }
 
@@ -229,7 +286,7 @@ export class AjvSchema<IN = unknown, OUT = IN> {
   }
 
   private getErrorMessageForInstancePath(
-    schema: JsonSchema<IN, OUT> | undefined,
+    schema: JsonSchema<OUT> | undefined,
     instancePath: string,
     keyword: string,
   ): string | undefined {
@@ -239,8 +296,8 @@ export class AjvSchema<IN = unknown, OUT = IN> {
     return this.traverseSchemaPath(schema, segments, keyword)
   }
 
-  private traverseSchemaPath<IN = unknown, OUT = IN>(
-    schema: JsonSchema<IN, OUT>,
+  private traverseSchemaPath<T>(
+    schema: JsonSchema<T>,
     segments: string[],
     keyword: string,
   ): string | undefined {
@@ -290,11 +347,11 @@ const separator = '\n'
 
 export const HIDDEN_AJV_SCHEMA = Symbol('HIDDEN_AJV_SCHEMA')
 
-export type WithCachedAjvSchema<Base, IN, OUT> = Base & {
-  [HIDDEN_AJV_SCHEMA]: AjvSchema<IN, OUT>
+export type WithCachedAjvSchema<Base, OUT> = Base & {
+  [HIDDEN_AJV_SCHEMA]: AjvSchema<OUT>
 }
 
-export interface AjvValidationOptions<IN> {
+export interface AjvValidationOptions {
   /**
    * Defaults to true,
    * because that's how AJV works by default,
@@ -322,7 +379,7 @@ export interface AjvValidationOptions<IN> {
    * can include it "how it was" in an error message. So, for that reason we'll use
    * `getOriginalInput()`, if it's provided.
    */
-  getOriginalInput?: () => IN
+  getOriginalInput?: () => unknown
 }
 
 export interface AjvSchemaCfg {
@@ -350,7 +407,1830 @@ export interface AjvSchemaCfg {
   lazy?: boolean
 }
 
-export type SchemaHandledByAjv<IN, OUT = IN> =
-  | JsonSchemaTerminal<IN, OUT, any>
-  | JsonSchema<IN, OUT>
-  | AjvSchema<IN, OUT>
+export type SchemaHandledByAjv<OUT> =
+  | JsonSchemaTerminal<OUT, any>
+  | JsonSchema<OUT>
+  | AjvSchema<OUT>
+
+// ===== JsonSchemaBuilders ===== //
+
+export const j = {
+  /**
+   * Matches literally any value - equivalent to TypeScript's `any` type.
+   * Use sparingly, as it bypasses type validation entirely.
+   */
+  any(): JsonSchemaAnyBuilder<any, false> {
+    return new JsonSchemaAnyBuilder({})
+  },
+
+  string(): JsonSchemaStringBuilder<string, false> {
+    return new JsonSchemaStringBuilder()
+  },
+
+  number(): JsonSchemaNumberBuilder<number, false> {
+    return new JsonSchemaNumberBuilder()
+  },
+
+  boolean(): JsonSchemaBooleanBuilder<boolean, false> {
+    return new JsonSchemaBooleanBuilder()
+  },
+
+  object: Object.assign(object, {
+    dbEntity: objectDbEntity,
+    infer: objectInfer,
+    any() {
+      return j.object<AnyObject>({}).allowAdditionalProperties()
+    },
+
+    stringMap<S extends JsonSchemaTerminal<any, any>>(
+      schema: S,
+    ): JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>> {
+      const isValueOptional = schema.getSchema().optionalField
+      const builtSchema = schema.build()
+      const finalValueSchema: JsonSchema = isValueOptional
+        ? { anyOf: [{ isUndefined: true }, builtSchema] }
+        : builtSchema
+
+      return new JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>>(
+        {},
+        {
+          hasIsOfTypeCheck: false,
+          patternProperties: {
+            '^.+$': finalValueSchema,
+          },
+        },
+      )
+    },
+
+    /**
+     * @experimental Look around, maybe you find a rule that is better for your use-case.
+     *
+     * For Record<K, V> type of validations.
+     * ```ts
+     * const schema = j.object
+     *  .record(
+     *    j
+     *      .string()
+     *      .regex(/^\d{3,4}$/)
+     *      .branded<B>(),
+     *    j.number().nullable(),
+     *  )
+     *  .isOfType<Record<B, number | null>>()
+     * ```
+     *
+     * When the keys of the Record are values from an Enum, prefer `j.object.withEnumKeys`!
+     *
+     * Non-matching keys will be stripped from the object, i.e. they will not cause an error.
+     *
+     * Caveat: This rule first validates values of every properties of the object, and only then validates the keys.
+     * A consequence of that is that the validation will throw when there is an unexpected property with a value not matching the value schema.
+     */
+    record,
+
+    /**
+     * For Record<ENUM, V> type of validations.
+     *
+     * When the keys of the Record are values from an Enum,
+     * this helper is more performant and behaves in a more conventional manner than `j.object.record` would.
+     *
+     *
+     */
+    withEnumKeys,
+    withRegexKeys,
+  }),
+
+  array<OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<OUT, Opt>): JsonSchemaArrayBuilder<OUT, Opt> {
+    return new JsonSchemaArrayBuilder(itemSchema)
+  },
+
+  tuple<const S extends JsonSchemaAnyBuilder<any, any>[]>(items: S): JsonSchemaTupleBuilder<S> {
+    return new JsonSchemaTupleBuilder<S>(items)
+  },
+
+  set<OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<OUT, Opt>): JsonSchemaSet2Builder<OUT, Opt> {
+    return new JsonSchemaSet2Builder(itemSchema)
+  },
+
+  buffer(): JsonSchemaBufferBuilder {
+    return new JsonSchemaBufferBuilder()
+  },
+
+  enum<const T extends readonly (string | number | boolean | null)[] | StringEnum | NumberEnum>(
+    input: T,
+    opt?: JsonBuilderRuleOpt,
+  ): JsonSchemaEnumBuilder<
+    T extends readonly (infer U)[]
+      ? U
+      : T extends StringEnum
+        ? T[keyof T]
+        : T extends NumberEnum
+          ? T[keyof T]
+          : never
+  > {
+    let enumValues: readonly (string | number | boolean | null)[] | undefined
+    let baseType: EnumBaseType = 'other'
+
+    if (Array.isArray(input)) {
+      enumValues = input
+      if (isEveryItemNumber(input)) {
+        baseType = 'number'
+      } else if (isEveryItemString(input)) {
+        baseType = 'string'
+      }
+    } else if (typeof input === 'object') {
+      const enumType = getEnumType(input)
+      if (enumType === 'NumberEnum') {
+        enumValues = _numberEnumValues(input as NumberEnum)
+        baseType = 'number'
+      } else if (enumType === 'StringEnum') {
+        enumValues = _stringEnumValues(input as StringEnum)
+        baseType = 'string'
+      }
+    }
+
+    _assert(enumValues, 'Unsupported enum input')
+    return new JsonSchemaEnumBuilder(enumValues as any, baseType, opt)
+  },
+
+  /**
+   * Use only with primitive values, otherwise this function will throw to avoid bugs.
+   * To validate objects, use `anyOfBy`.
+   *
+   * Our Ajv is configured to strip unexpected properties from objects,
+   * and since Ajv is mutating the input, this means that it cannot
+   * properly validate the same data over multiple schemas.
+   *
+   * 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> {
+    const schemas = items.map(b => b.build())
+    _assert(
+      schemas.every(hasNoObjectSchemas),
+      'Do not use `oneOf` validation with non-primitive types!',
+    )
+
+    return new JsonSchemaAnyBuilder<OUT, false>({
+      oneOf: schemas,
+    })
+  },
+
+  /**
+   * Use only with primitive values, otherwise this function will throw to avoid bugs.
+   * To validate objects, use `anyOfBy` or `anyOfThese`.
+   *
+   * Our Ajv is configured to strip unexpected properties from objects,
+   * and since Ajv is mutating the input, this means that it cannot
+   * properly validate the same data over multiple schemas.
+   *
+   * 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> {
+    const schemas = items.map(b => b.build())
+    _assert(
+      schemas.every(hasNoObjectSchemas),
+      'Do not use `anyOf` validation with non-primitive types!',
+    )
+
+    return new JsonSchemaAnyBuilder<OUT, false>({
+      anyOf: schemas,
+    })
+  },
+
+  /**
+   * Pick validation schema for an object based on the value of a specific property.
+   *
+   * ```
+   * const schemaMap = {
+   *   true: successSchema,
+   *   false: errorSchema
+   * }
+   *
+   * const schema = j.anyOfBy('success', schemaMap)
+   * ```
+   */
+  anyOfBy<D extends Record<PropertyKey, JsonSchemaTerminal<any, any>>, OUT = AnyOfByOut<D>>(
+    propertyName: string,
+    schemaDictionary: D,
+  ): JsonSchemaAnyOfByBuilder<OUT> {
+    return new JsonSchemaAnyOfByBuilder<OUT>(propertyName, schemaDictionary)
+  },
+
+  /**
+   * 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.
+   *
+   * ```
+   * const schema = j.anyOfThese([successSchema, errorSchema])
+   * ```
+   */
+  anyOfThese<B extends readonly JsonSchemaAnyBuilder<any, boolean>[], OUT = BuilderOutUnion<B>>(
+    items: [...B],
+  ): JsonSchemaAnyBuilder<OUT, false> {
+    return new JsonSchemaAnyBuilder<OUT, false>({
+      anyOfThese: items.map(b => b.build()),
+    })
+  },
+
+  and() {
+    return {
+      silentBob: () => {
+        throw new Error('...strike back!')
+      },
+    }
+  },
+
+  literal<const V extends string | number | boolean | null>(v: V) {
+    let baseType: EnumBaseType = 'other'
+    if (typeof v === 'string') baseType = 'string'
+    if (typeof v === 'number') baseType = 'number'
+    return new JsonSchemaEnumBuilder<V>([v], baseType)
+  },
+}
+
+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
+
+/*
+  Notes for future reference
+
+  Q: Why do we need `Opt` - when `IN` and `OUT` already carries the `| undefined`?
+  A: Because of objects. Without `Opt`, an optional field would be inferred as `{ foo: string | undefined }`,
+     which means that the `foo` property would be mandatory, it's just that its value can be `undefined` as well.
+     With `Opt`, we can infer it as `{ foo?: string | undefined }`.
+*/
+
+export class JsonSchemaTerminal<OUT, Opt> {
+  protected [HIDDEN_AJV_SCHEMA]: AjvSchema<any> | undefined
+  protected schema: JsonSchema
+
+  constructor(schema: JsonSchema) {
+    this.schema = schema
+  }
+
+  get ajvSchema(): AjvSchema<any> {
+    if (!this[HIDDEN_AJV_SCHEMA]) {
+      this[HIDDEN_AJV_SCHEMA] = AjvSchema.create<OUT>(this)
+    }
+
+    return this[HIDDEN_AJV_SCHEMA]
+  }
+
+  getSchema(): JsonSchema {
+    return this.schema
+  }
+
+  /**
+   * Produces a "clean schema object" without methods.
+   * Same as if it would be JSON.stringified.
+   */
+  build(): JsonSchema<OUT> {
+    _assert(
+      !(this.schema.optionalField && this.schema.default !== undefined),
+      '.optional() and .default() should not be used together - the default value makes .optional() redundant and causes incorrect type inference',
+    )
+
+    const jsonSchema = _sortObject(
+      deepCopyPreservingFunctions(this.schema) as AnyObject,
+      JSON_SCHEMA_ORDER,
+    ) as JsonSchema<OUT>
+
+    delete jsonSchema.optionalField
+
+    return jsonSchema
+  }
+
+  clone(): this {
+    const cloned = Object.create(Object.getPrototypeOf(this))
+    cloned.schema = deepCopyPreservingFunctions(this.schema)
+    return cloned
+  }
+
+  cloneAndUpdateSchema(schema: Partial<JsonSchema>): this {
+    const clone = this.clone()
+    _objectAssign(clone.schema, schema)
+    return clone
+  }
+
+  validate(input: unknown, opt?: AjvValidationOptions): OUT {
+    return this.ajvSchema.validate(input, opt)
+  }
+
+  isValid(input: unknown, opt?: AjvValidationOptions): boolean {
+    return this.ajvSchema.isValid(input, opt)
+  }
+
+  getValidationResult(
+    input: unknown,
+    opt: AjvValidationOptions = {},
+  ): ValidationFunctionResult<OUT, AjvValidationError> {
+    return this.ajvSchema.getValidationResult(input, opt)
+  }
+
+  getValidationFunction(): ValidationFunction<OUT, AjvValidationError> {
+    return this.ajvSchema.getValidationFunction()
+  }
+
+  /**
+   * Specify a function to be called after the normal validation is finished.
+   *
+   * This function will receive the validated, type-safe data, and you can use it
+   * to do further validations, e.g. conditional validations based on certain property values,
+   * or to do data modifications either by mutating the input or returning a new value.
+   *
+   * 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> {
+    const clone = this.cloneAndUpdateSchema({
+      postValidation: fn,
+    })
+    return clone as unknown as JsonSchemaTerminal<OUT2, Opt>
+  }
+
+  /**
+   * @experimental
+   */
+  out!: OUT
+  opt!: Opt
+}
+
+export class JsonSchemaAnyBuilder<OUT, Opt> extends JsonSchemaTerminal<OUT, Opt> {
+  protected setErrorMessage(ruleName: string, errorMessage: string | undefined): void {
+    if (_isUndefined(errorMessage)) return
+
+    this.schema.errorMessages ||= {}
+    this.schema.errorMessages[ruleName] = errorMessage
+  }
+
+  /**
+   * 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 {
+    return this.cloneAndUpdateSchema({ hasIsOfTypeCheck: true }) as any
+  }
+
+  $schema($schema: string): this {
+    return this.cloneAndUpdateSchema({ $schema })
+  }
+
+  $schemaDraft7(): this {
+    return this.$schema('http://json-schema.org/draft-07/schema#')
+  }
+
+  $id($id: string): this {
+    return this.cloneAndUpdateSchema({ $id })
+  }
+
+  title(title: string): this {
+    return this.cloneAndUpdateSchema({ title })
+  }
+
+  description(description: string): this {
+    return this.cloneAndUpdateSchema({ description })
+  }
+
+  deprecated(deprecated = true): this {
+    return this.cloneAndUpdateSchema({ deprecated })
+  }
+
+  type(type: string): this {
+    return this.cloneAndUpdateSchema({ type })
+  }
+
+  default(v: any): this {
+    return this.cloneAndUpdateSchema({ default: v })
+  }
+
+  instanceof(of: string): this {
+    return this.cloneAndUpdateSchema({ type: 'object', instanceof: of })
+  }
+
+  optional(): JsonSchemaAnyBuilder<OUT | undefined, true> {
+    const clone = this.cloneAndUpdateSchema({ optionalField: true })
+    return clone as unknown as JsonSchemaAnyBuilder<OUT | undefined, true>
+  }
+
+  nullable(): JsonSchemaAnyBuilder<OUT | null, Opt> {
+    return new JsonSchemaAnyBuilder({
+      anyOf: [this.build(), { type: 'null' }],
+    })
+  }
+
+  /**
+   * @deprecated
+   * The usage of this function is discouraged as it defeats the purpose of having type-safe validation.
+   */
+  castAs<T>(): JsonSchemaAnyBuilder<T, Opt> {
+    return this as unknown as JsonSchemaAnyBuilder<T, Opt>
+  }
+
+  /**
+   * Locks the given schema chain and no other modification can be done to it.
+   */
+  final(): JsonSchemaTerminal<OUT, Opt> {
+    return new JsonSchemaTerminal<OUT, Opt>(this.schema)
+  }
+
+  /**
+   *
+   * @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> {
+    const { customValidations = [] } = this.schema
+    return this.cloneAndUpdateSchema({
+      customValidations: [...customValidations, validator],
+    }) as unknown as JsonSchemaAnyBuilder<OUT2, Opt>
+  }
+
+  /**
+   *
+   * @param converter A converter function that returns a new value.
+   *
+   * You may add multiple converters and they will be executed in the order you added them,
+   * each converter receiving the result from the previous one.
+   *
+   * 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> {
+    const { customConversions = [] } = this.schema
+    return this.cloneAndUpdateSchema({
+      customConversions: [...customConversions, converter],
+    }) as unknown as JsonSchemaAnyBuilder<OUT2, Opt>
+  }
+}
+
+export class JsonSchemaStringBuilder<
+  OUT extends string | undefined = string,
+  Opt extends boolean = false,
+> extends JsonSchemaAnyBuilder<OUT, Opt> {
+  constructor() {
+    super({
+      type: 'string',
+    })
+  }
+
+  /**
+   * @param optionalValues List of values that should be considered/converted as `undefined`.
+   *
+   * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   *
+   * Make sure this `optional()` call is at the end of your call chain.
+   *
+   * When `null` is included in optionalValues, the return type becomes `JsonSchemaTerminal`
+   * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
+   */
+  override 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> {
+    if (!optionalValues) {
+      return super.optional() as any
+    }
+
+    _typeCast<(string | null)[]>(optionalValues)
+
+    let newBuilder: JsonSchemaTerminal<OUT | undefined, true> = new JsonSchemaStringBuilder<
+      OUT,
+      Opt
+    >().optional()
+    const alternativesSchema = j.enum(optionalValues)
+    Object.assign(newBuilder.getSchema(), {
+      anyOf: [this.build(), alternativesSchema.build()],
+      optionalValues,
+    })
+
+    // When `null` is specified, we want `null` to be stripped and the value to become `undefined`,
+    // so we must allow `null` values to be parsed by Ajv,
+    // but the typing should not reflect that.
+    // We also cannot accept more rules attached, since we're not building a StringSchema anymore.
+    if (optionalValues.includes(null)) {
+      newBuilder = new JsonSchemaTerminal({
+        anyOf: [{ type: 'null', optionalValues }, newBuilder.build()],
+        optionalField: true,
+      })
+    }
+
+    return newBuilder as any
+  }
+
+  regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this {
+    _assert(
+      !pattern.flags,
+      `Regex flags are not supported by JSON Schema. Received: /${pattern.source}/${pattern.flags}`,
+    )
+    return this.pattern(pattern.source, opt)
+  }
+
+  pattern(pattern: string, opt?: JsonBuilderRuleOpt): this {
+    const clone = this.cloneAndUpdateSchema({ pattern })
+    if (opt?.name) clone.setErrorMessage('pattern', `is not a valid ${opt.name}`)
+    if (opt?.msg) clone.setErrorMessage('pattern', opt.msg)
+    return clone
+  }
+
+  minLength(minLength: number): this {
+    return this.cloneAndUpdateSchema({ minLength })
+  }
+
+  maxLength(maxLength: number): this {
+    return this.cloneAndUpdateSchema({ maxLength })
+  }
+
+  length(exactLength: number): this
+  length(minLength: number, maxLength: number): this
+  length(minLengthOrExactLength: number, maxLength?: number): this {
+    const maxLengthActual = maxLength ?? minLengthOrExactLength
+    return this.minLength(minLengthOrExactLength).maxLength(maxLengthActual)
+  }
+
+  email(opt?: Partial<JsonSchemaStringEmailOptions>): this {
+    const defaultOptions: JsonSchemaStringEmailOptions = { checkTLD: true }
+    return this.cloneAndUpdateSchema({ email: { ...defaultOptions, ...opt } })
+      .trim()
+      .toLowerCase()
+  }
+
+  trim(): this {
+    return this.cloneAndUpdateSchema({ transform: { ...this.schema.transform, trim: true } })
+  }
+
+  toLowerCase(): this {
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, toLowerCase: true },
+    })
+  }
+
+  toUpperCase(): this {
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, toUpperCase: true },
+    })
+  }
+
+  truncate(toLength: number): this {
+    return this.cloneAndUpdateSchema({
+      transform: { ...this.schema.transform, truncate: toLength },
+    })
+  }
+
+  branded<B extends string>(): JsonSchemaStringBuilder<B, Opt> {
+    return this as unknown as JsonSchemaStringBuilder<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 {
+    return new JsonSchemaIsoDateBuilder()
+  }
+
+  isoDateTime(): JsonSchemaStringBuilder<IsoDateTime, Opt> {
+    return this.cloneAndUpdateSchema({ IsoDateTime: true }).branded<IsoDateTime>()
+  }
+
+  isoMonth(): JsonSchemaIsoMonthBuilder {
+    return new JsonSchemaIsoMonthBuilder()
+  }
+
+  /**
+   * Validates the string format to be JWT.
+   * Expects the JWT to be signed!
+   */
+  jwt(): this {
+    return this.regex(JWT_REGEX, { msg: 'is not a valid JWT format' })
+  }
+
+  url(): this {
+    return this.regex(URL_REGEX, { msg: 'is not a valid URL format' })
+  }
+
+  ipv4(): this {
+    return this.regex(IPV4_REGEX, { msg: 'is not a valid IPv4 format' })
+  }
+
+  ipv6(): this {
+    return this.regex(IPV6_REGEX, { msg: 'is not a valid IPv6 format' })
+  }
+
+  slug(): this {
+    return this.regex(SLUG_REGEX, { msg: 'is not a valid slug format' })
+  }
+
+  semVer(): this {
+    return this.regex(SEMVER_REGEX, { msg: 'is not a valid semver format' })
+  }
+
+  languageTag(): this {
+    return this.regex(LANGUAGE_TAG_REGEX, { msg: 'is not a valid language format' })
+  }
+
+  countryCode(): this {
+    return this.regex(COUNTRY_CODE_REGEX, { msg: 'is not a valid country code format' })
+  }
+
+  currency(): this {
+    return this.regex(CURRENCY_REGEX, { msg: 'is not a valid currency format' })
+  }
+
+  /**
+   * Validates that the input is a valid IANATimzone value.
+   *
+   * 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> {
+    // UTC is added to assist unit-testing, which uses UTC by default (not technically a valid Iana timezone identifier)
+    return j.enum(TIMEZONES, { msg: 'is an invalid IANA timezone' }).branded<IANATimezone>()
+  }
+
+  base64Url(): this {
+    return this.regex(BASE64URL_REGEX, {
+      msg: 'contains characters not allowed in Base64 URL characterset',
+    })
+  }
+
+  uuid(): this {
+    return this.regex(UUID_REGEX, { msg: 'is an invalid UUID' })
+  }
+}
+
+export interface JsonSchemaStringEmailOptions {
+  checkTLD: boolean
+}
+
+export class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<
+  IsoDate,
+  Opt
+> {
+  constructor() {
+    super({
+      type: 'string',
+      IsoDate: {},
+    })
+  }
+
+  /**
+   * @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`
+   * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
+   */
+  override optional<N extends null | undefined = undefined>(
+    nullValue?: N,
+  ): N extends null
+    ? JsonSchemaTerminal<IsoDate | undefined, true>
+    : JsonSchemaAnyBuilder<IsoDate | undefined, true> {
+    if (nullValue === undefined) {
+      return super.optional() as any
+    }
+
+    // When `null` is specified, we want `null` to be stripped and the value to become `undefined`,
+    // so we must allow `null` values to be parsed by Ajv,
+    // but the typing should not reflect that.
+    // We also cannot accept more rules attached, since we're not building an ObjectSchema anymore.
+    return new JsonSchemaTerminal({
+      anyOf: [{ type: 'null', optionalValues: [null] }, this.build()],
+      optionalField: true,
+    }) as any
+  }
+
+  before(date: string): this {
+    return this.cloneAndUpdateSchema({ IsoDate: { before: date } })
+  }
+
+  sameOrBefore(date: string): this {
+    return this.cloneAndUpdateSchema({ IsoDate: { sameOrBefore: date } })
+  }
+
+  after(date: string): this {
+    return this.cloneAndUpdateSchema({ IsoDate: { after: date } })
+  }
+
+  sameOrAfter(date: string): this {
+    return this.cloneAndUpdateSchema({ IsoDate: { sameOrAfter: date } })
+  }
+
+  between(fromDate: string, toDate: string, incl: Inclusiveness): this {
+    let schemaPatch: Partial<JsonSchema> = {}
+
+    if (incl === '[)') {
+      schemaPatch = { IsoDate: { sameOrAfter: fromDate, before: toDate } }
+    } else if (incl === '[]') {
+      schemaPatch = { IsoDate: { sameOrAfter: fromDate, sameOrBefore: toDate } }
+    }
+
+    return this.cloneAndUpdateSchema(schemaPatch)
+  }
+}
+
+export interface JsonSchemaIsoDateOptions {
+  before?: string
+  sameOrBefore?: string
+  after?: string
+  sameOrAfter?: string
+}
+
+export class JsonSchemaIsoMonthBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<
+  IsoMonth,
+  Opt
+> {
+  constructor() {
+    super({
+      type: 'string',
+      IsoMonth: {},
+    })
+  }
+}
+
+export interface JsonSchemaIsoMonthOptions {}
+
+export class JsonSchemaNumberBuilder<
+  OUT extends number | undefined = number,
+  Opt extends boolean = false,
+> extends JsonSchemaAnyBuilder<OUT, Opt> {
+  constructor() {
+    super({
+      type: 'number',
+    })
+  }
+
+  /**
+   * @param optionalValues List of values that should be considered/converted as `undefined`.
+   *
+   * This `optionalValues` feature only works when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   *
+   * Make sure this `optional()` call is at the end of your call chain.
+   *
+   * When `null` is included in optionalValues, the return type becomes `JsonSchemaTerminal`
+   * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
+   */
+  override 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> {
+    if (!optionalValues) {
+      return super.optional() as any
+    }
+
+    _typeCast<(number | null)[]>(optionalValues)
+
+    let newBuilder: JsonSchemaTerminal<OUT | undefined, true> = new JsonSchemaNumberBuilder<
+      OUT,
+      Opt
+    >().optional()
+    const alternativesSchema = j.enum(optionalValues)
+    Object.assign(newBuilder.getSchema(), {
+      anyOf: [this.build(), alternativesSchema.build()],
+      optionalValues,
+    })
+
+    // When `null` is specified, we want `null` to be stripped and the value to become `undefined`,
+    // so we must allow `null` values to be parsed by Ajv,
+    // but the typing should not reflect that.
+    // We also cannot accept more rules attached, since we're not building a NumberSchema anymore.
+    if (optionalValues.includes(null)) {
+      newBuilder = new JsonSchemaTerminal({
+        anyOf: [{ type: 'null', optionalValues }, newBuilder.build()],
+        optionalField: true,
+      })
+    }
+
+    return newBuilder as any
+  }
+
+  integer(): this {
+    return this.cloneAndUpdateSchema({ type: 'integer' })
+  }
+
+  branded<B extends number>(): JsonSchemaNumberBuilder<B, Opt> {
+    return this as unknown as JsonSchemaNumberBuilder<B, Opt>
+  }
+
+  multipleOf(multipleOf: number): this {
+    return this.cloneAndUpdateSchema({ multipleOf })
+  }
+
+  min(minimum: number): this {
+    return this.cloneAndUpdateSchema({ minimum })
+  }
+
+  exclusiveMin(exclusiveMinimum: number): this {
+    return this.cloneAndUpdateSchema({ exclusiveMinimum })
+  }
+
+  max(maximum: number): this {
+    return this.cloneAndUpdateSchema({ maximum })
+  }
+
+  exclusiveMax(exclusiveMaximum: number): this {
+    return this.cloneAndUpdateSchema({ exclusiveMaximum })
+  }
+
+  lessThan(value: number): this {
+    return this.exclusiveMax(value)
+  }
+
+  lessThanOrEqual(value: number): this {
+    return this.max(value)
+  }
+
+  moreThan(value: number): this {
+    return this.exclusiveMin(value)
+  }
+
+  moreThanOrEqual(value: number): this {
+    return this.min(value)
+  }
+
+  equal(value: number): this {
+    return this.min(value).max(value)
+  }
+
+  range(minimum: number, maximum: number, incl: Inclusiveness): this {
+    if (incl === '[)') {
+      return this.moreThanOrEqual(minimum).lessThan(maximum)
+    }
+    return this.moreThanOrEqual(minimum).lessThanOrEqual(maximum)
+  }
+
+  int32(): this {
+    const MIN_INT32 = -(2 ** 31)
+    const MAX_INT32 = 2 ** 31 - 1
+    const currentMin = this.schema.minimum ?? Number.MIN_SAFE_INTEGER
+    const currentMax = this.schema.maximum ?? Number.MAX_SAFE_INTEGER
+    const newMin = Math.max(MIN_INT32, currentMin)
+    const newMax = Math.min(MAX_INT32, currentMax)
+    return this.integer().min(newMin).max(newMax)
+  }
+
+  int64(): this {
+    const currentMin = this.schema.minimum ?? Number.MIN_SAFE_INTEGER
+    const currentMax = this.schema.maximum ?? Number.MAX_SAFE_INTEGER
+    const newMin = Math.max(Number.MIN_SAFE_INTEGER, currentMin)
+    const newMax = Math.min(Number.MAX_SAFE_INTEGER, currentMax)
+    return this.integer().min(newMin).max(newMax)
+  }
+
+  float(): this {
+    return this
+  }
+
+  double(): this {
+    return this
+  }
+
+  unixTimestamp(): JsonSchemaNumberBuilder<UnixTimestamp, Opt> {
+    return this.integer().min(0).max(TS_2500).branded<UnixTimestamp>()
+  }
+
+  unixTimestamp2000(): JsonSchemaNumberBuilder<UnixTimestamp, Opt> {
+    return this.integer().min(TS_2000).max(TS_2500).branded<UnixTimestamp>()
+  }
+
+  unixTimestampMillis(): JsonSchemaNumberBuilder<UnixTimestampMillis, Opt> {
+    return this.integer().min(0).max(TS_2500_MILLIS).branded<UnixTimestampMillis>()
+  }
+
+  unixTimestamp2000Millis(): JsonSchemaNumberBuilder<UnixTimestampMillis, Opt> {
+    return this.integer().min(TS_2000_MILLIS).max(TS_2500_MILLIS).branded<UnixTimestampMillis>()
+  }
+
+  utcOffset(): this {
+    return this.integer()
+      .multipleOf(15)
+      .min(-12 * 60)
+      .max(14 * 60)
+  }
+
+  utcOffsetHour(): this {
+    return this.integer().min(-12).max(14)
+  }
+
+  /**
+   * Specify the precision of the floating point numbers by the number of digits after the ".".
+   * Excess digits will be cut-off when the current schema is nested in an object or array schema,
+   * due to how mutability works in Ajv.
+   */
+  precision(numberOfDigits: number): this {
+    return this.cloneAndUpdateSchema({ precision: numberOfDigits })
+  }
+}
+
+export class JsonSchemaBooleanBuilder<
+  OUT extends boolean | undefined = boolean,
+  Opt extends boolean = false,
+> extends JsonSchemaAnyBuilder<OUT, Opt> {
+  constructor() {
+    super({
+      type: 'boolean',
+    })
+  }
+
+  /**
+   * @param optionalValue One of the two possible boolean values that should be considered/converted as `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.
+   */
+  override optional(optionalValue?: boolean): JsonSchemaBooleanBuilder<OUT | undefined, true> {
+    if (typeof optionalValue === 'undefined') {
+      return super.optional() as unknown as JsonSchemaBooleanBuilder<OUT | undefined, true>
+    }
+
+    const newBuilder = new JsonSchemaBooleanBuilder<OUT, Opt>().optional()
+    const alternativesSchema = j.enum([optionalValue])
+    Object.assign(newBuilder.getSchema(), {
+      anyOf: [this.build(), alternativesSchema.build()],
+      optionalValues: [optionalValue],
+    })
+
+    return newBuilder
+  }
+}
+
+export class JsonSchemaObjectBuilder<
+  OUT extends AnyObject,
+  Opt extends boolean = false,
+> extends JsonSchemaAnyBuilder<OUT, Opt> {
+  constructor(props?: AnyObject, opt?: JsonSchemaObjectBuilderOpts) {
+    super({
+      type: 'object',
+      properties: {},
+      required: [],
+      additionalProperties: false,
+      hasIsOfTypeCheck: opt?.hasIsOfTypeCheck ?? true,
+      patternProperties: opt?.patternProperties ?? undefined,
+      keySchema: opt?.keySchema ?? undefined,
+    })
+
+    if (props) this.addProperties(props)
+  }
+
+  addProperties(props: AnyObject): this {
+    const properties: Record<string, JsonSchema> = {}
+    const required: string[] = []
+
+    for (const [key, builder] of Object.entries(props)) {
+      const isOptional = (builder as JsonSchemaTerminal<any, any>).getSchema().optionalField
+      if (!isOptional) {
+        required.push(key)
+      }
+
+      const schema = builder.build()
+      properties[key] = schema
+    }
+
+    this.schema.properties = properties
+    this.schema.required = _uniq(required).sort()
+
+    return 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`
+   * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
+   */
+  override optional<N extends null | undefined = undefined>(
+    nullValue?: N,
+  ): N extends null
+    ? JsonSchemaTerminal<OUT | undefined, true>
+    : JsonSchemaAnyBuilder<OUT | undefined, true> {
+    if (nullValue === undefined) {
+      return super.optional() as any
+    }
+
+    // When `null` is specified, we want `null` to be stripped and the value to become `undefined`,
+    // so we must allow `null` values to be parsed by Ajv,
+    // but the typing should not reflect that.
+    // We also cannot accept more rules attached, since we're not building an ObjectSchema anymore.
+    return new JsonSchemaTerminal({
+      anyOf: [{ type: 'null', optionalValues: [null] }, this.build()],
+      optionalField: true,
+    }) as any
+  }
+
+  /**
+   * When set, the validation will not strip away properties that are not specified explicitly in the schema.
+   */
+
+  allowAdditionalProperties(): this {
+    return this.cloneAndUpdateSchema({ additionalProperties: true })
+  }
+
+  extend<P extends Record<string, JsonSchemaAnyBuilder<any, any>>>(
+    props: P,
+  ): JsonSchemaObjectBuilder<
+    Override<
+      OUT,
+      {
+        // required keys
+        [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
+      } & {
+        // optional keys
+        [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
+      }
+    >,
+    false
+  > {
+    const newBuilder = new JsonSchemaObjectBuilder()
+    _objectAssign(newBuilder.schema, deepCopyPreservingFunctions(this.schema))
+
+    const incomingSchemaBuilder = new JsonSchemaObjectBuilder(props)
+    mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
+
+    _objectAssign(newBuilder.schema, { hasIsOfTypeCheck: false })
+
+    return newBuilder as any
+  }
+
+  /**
+   * Concatenates another schema to the current schema.
+   *
+   * 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> {
+    const clone = this.clone()
+    mergeJsonSchemaObjects(clone.schema as any, other.schema as any)
+    _objectAssign(clone.schema, { hasIsOfTypeCheck: false })
+    return clone as unknown as JsonSchemaObjectBuilder<OUT & OUT2, false>
+  }
+
+  /**
+   * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
+   */
+  // oxlint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/explicit-module-boundary-types
+  dbEntity() {
+    return this.extend({
+      id: j.string(),
+      created: j.number().unixTimestamp2000(),
+      updated: j.number().unixTimestamp2000(),
+    })
+  }
+
+  minProperties(minProperties: number): this {
+    return this.cloneAndUpdateSchema({ minProperties, minProperties2: minProperties })
+  }
+
+  maxProperties(maxProperties: number): this {
+    return this.cloneAndUpdateSchema({ maxProperties })
+  }
+
+  exclusiveProperties(propNames: readonly (keyof OUT & string)[]): this {
+    const exclusiveProperties = this.schema.exclusiveProperties ?? []
+    return this.cloneAndUpdateSchema({ exclusiveProperties: [...exclusiveProperties, propNames] })
+  }
+}
+
+interface JsonSchemaObjectBuilderOpts {
+  hasIsOfTypeCheck?: false
+  patternProperties?: StringMap<JsonSchema<any>>
+  keySchema?: JsonSchema
+}
+
+export 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
+    } & {
+      [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
+    }
+  >,
+  Opt
+> {
+  constructor(props?: PROPS) {
+    super({
+      type: 'object',
+      properties: {},
+      required: [],
+      additionalProperties: false,
+    })
+
+    if (props) this.addProperties(props)
+  }
+
+  addProperties(props: PROPS): this {
+    const properties: Record<string, JsonSchema> = {}
+    const required: string[] = []
+
+    for (const [key, builder] of Object.entries(props)) {
+      const isOptional = (builder as JsonSchemaTerminal<any, any>).getSchema().optionalField
+      if (!isOptional) {
+        required.push(key)
+      }
+
+      const schema = builder.build()
+      properties[key] = schema
+    }
+
+    this.schema.properties = properties
+    this.schema.required = _uniq(required).sort()
+
+    return 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`
+   * (no further chaining allowed) because the schema is wrapped in an anyOf structure.
+   */
+  // @ts-expect-error override adds optional parameter which is compatible but TS can't verify complex mapped types
+  override 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
+            } & {
+              [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 JsonSchemaAnyBuilder<any, infer IsOpt>
+                ? IsOpt extends true
+                  ? K
+                  : never
+                : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer OUT, any> ? OUT : never
+            }
+          >
+        | undefined,
+        true
+      > {
+    if (nullValue === undefined) {
+      return super.optional() as any
+    }
+
+    // When `null` is specified, we want `null` to be stripped and the value to become `undefined`,
+    // so we must allow `null` values to be parsed by Ajv,
+    // but the typing should not reflect that.
+    // We also cannot accept more rules attached, since we're not building an ObjectSchema anymore.
+    return new JsonSchemaTerminal({
+      anyOf: [{ type: 'null', optionalValues: [null] }, this.build()],
+      optionalField: true,
+    }) as any
+  }
+
+  /**
+   * When set, the validation will not strip away properties that are not specified explicitly in the schema.
+   */
+
+  allowAdditionalProperties(): this {
+    return this.cloneAndUpdateSchema({ additionalProperties: true })
+  }
+
+  extend<NEW_PROPS extends Record<string, JsonSchemaAnyBuilder<any, any>>>(
+    props: NEW_PROPS,
+  ): JsonSchemaObjectInferringBuilder<
+    {
+      [K in keyof PROPS | keyof NEW_PROPS]: K extends keyof NEW_PROPS
+        ? NEW_PROPS[K]
+        : K extends keyof PROPS
+          ? PROPS[K]
+          : never
+    },
+    Opt
+  > {
+    const newBuilder = new JsonSchemaObjectInferringBuilder<PROPS, Opt>()
+    _objectAssign(newBuilder.schema, deepCopyPreservingFunctions(this.schema))
+
+    const incomingSchemaBuilder = new JsonSchemaObjectInferringBuilder<NEW_PROPS, false>(props)
+    mergeJsonSchemaObjects(newBuilder.schema as any, incomingSchemaBuilder.schema as any)
+
+    // This extend function is not type-safe as it is inferring,
+    // so even if the base schema was already type-checked,
+    // the new schema loses that quality.
+    _objectAssign(newBuilder.schema, { hasIsOfTypeCheck: false })
+
+    return newBuilder as unknown as JsonSchemaObjectInferringBuilder<
+      {
+        [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.
+   */
+  // oxlint-disable-next-line @typescript-eslint/explicit-function-return-type, @typescript-eslint/explicit-module-boundary-types
+  dbEntity() {
+    return this.extend({
+      id: j.string(),
+      created: j.number().unixTimestamp2000(),
+      updated: j.number().unixTimestamp2000(),
+    })
+  }
+}
+
+export class JsonSchemaArrayBuilder<OUT, Opt> extends JsonSchemaAnyBuilder<OUT[], Opt> {
+  constructor(itemsSchema: JsonSchemaAnyBuilder<OUT, Opt>) {
+    super({
+      type: 'array',
+      items: itemsSchema.build(),
+    })
+  }
+
+  minLength(minItems: number): this {
+    return this.cloneAndUpdateSchema({ minItems })
+  }
+
+  maxLength(maxItems: number): this {
+    return this.cloneAndUpdateSchema({ maxItems })
+  }
+
+  length(exactLength: number): this
+  length(minItems: number, maxItems: number): this
+  length(minItemsOrExact: number, maxItems?: number): this {
+    const maxItemsActual = maxItems ?? minItemsOrExact
+    return this.minLength(minItemsOrExact).maxLength(maxItemsActual)
+  }
+
+  exactLength(length: number): this {
+    return this.minLength(length).maxLength(length)
+  }
+
+  unique(): this {
+    return this.cloneAndUpdateSchema({ uniqueItems: true })
+  }
+}
+
+export class JsonSchemaSet2Builder<OUT, Opt> extends JsonSchemaAnyBuilder<Set2<OUT>, Opt> {
+  constructor(itemsSchema: JsonSchemaAnyBuilder<OUT, Opt>) {
+    super({
+      type: ['array', 'object'],
+      Set2: itemsSchema.build(),
+    })
+  }
+
+  min(minItems: number): this {
+    return this.cloneAndUpdateSchema({ minItems })
+  }
+
+  max(maxItems: number): this {
+    return this.cloneAndUpdateSchema({ maxItems })
+  }
+}
+
+export class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder<Buffer, false> {
+  constructor() {
+    super({
+      Buffer: true,
+    })
+  }
+}
+
+export class JsonSchemaEnumBuilder<
+  OUT extends string | number | boolean | null,
+  Opt extends boolean = false,
+> extends JsonSchemaAnyBuilder<OUT, Opt> {
+  constructor(enumValues: readonly OUT[], baseType: EnumBaseType, opt?: JsonBuilderRuleOpt) {
+    const jsonSchema: JsonSchema = { enum: enumValues }
+    // Specifying the base type helps in cases when we ask Ajv to coerce the types.
+    // Having only the `enum` in the schema does not trigger a coercion in Ajv.
+    if (baseType === 'string') jsonSchema.type = 'string'
+    if (baseType === 'number') jsonSchema.type = 'number'
+
+    super(jsonSchema)
+
+    if (opt?.name) this.setErrorMessage('pattern', `is not a valid ${opt.name}`)
+    if (opt?.msg) this.setErrorMessage('enum', opt.msg)
+  }
+
+  branded<B extends OUT>(): JsonSchemaEnumBuilder<B, Opt> {
+    return this as unknown as JsonSchemaEnumBuilder<B, Opt>
+  }
+}
+
+export class JsonSchemaTupleBuilder<
+  ITEMS extends JsonSchemaAnyBuilder<any, any>[],
+> extends JsonSchemaAnyBuilder<TupleOut<ITEMS>, false> {
+  constructor(items: ITEMS) {
+    super({
+      type: 'array',
+      prefixItems: items.map(i => i.build()),
+      minItems: items.length,
+      maxItems: items.length,
+    })
+  }
+}
+
+export class JsonSchemaAnyOfByBuilder<OUT> extends JsonSchemaAnyBuilder<OUT, false> {
+  constructor(
+    propertyName: string,
+    schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any>>,
+  ) {
+    const builtSchemaDictionary: Record<string, JsonSchema> = {}
+    for (const [key, schema] of Object.entries(schemaDictionary)) {
+      builtSchemaDictionary[key] = schema.build()
+    }
+
+    super({
+      type: 'object',
+      hasIsOfTypeCheck: true,
+      anyOfBy: {
+        propertyName,
+        schemaDictionary: builtSchemaDictionary,
+      },
+    })
+  }
+}
+
+export class JsonSchemaAnyOfTheseBuilder<OUT> extends JsonSchemaAnyBuilder<OUT, false> {
+  constructor(
+    propertyName: string,
+    schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any>>,
+  ) {
+    const builtSchemaDictionary: Record<string, JsonSchema> = {}
+    for (const [key, schema] of Object.entries(schemaDictionary)) {
+      builtSchemaDictionary[key] = schema.build()
+    }
+
+    super({
+      type: 'object',
+      hasIsOfTypeCheck: true,
+      anyOfBy: {
+        propertyName,
+        schemaDictionary: builtSchemaDictionary,
+      },
+    })
+  }
+}
+
+type EnumBaseType = 'string' | 'number' | 'other'
+
+export interface JsonSchema<OUT = unknown> {
+  readonly out?: OUT
+
+  $schema?: string
+  $id?: string
+  title?: string
+  description?: string
+  // $comment?: string
+  deprecated?: boolean
+  readOnly?: boolean
+  writeOnly?: boolean
+
+  type?: string | string[]
+  items?: JsonSchema
+  prefixItems?: JsonSchema[]
+  properties?: {
+    [K in keyof OUT]: JsonSchema<OUT[K]>
+  }
+  patternProperties?: StringMap<JsonSchema<any>>
+  required?: string[]
+  additionalProperties?: boolean
+  minProperties?: number
+  maxProperties?: number
+
+  default?: OUT
+
+  // https://json-schema.org/understanding-json-schema/reference/conditionals.html#id6
+  if?: JsonSchema
+  then?: JsonSchema
+  else?: JsonSchema
+
+  anyOf?: JsonSchema[]
+  oneOf?: JsonSchema[]
+
+  /**
+   * This is a temporary "intermediate AST" field that is used inside the parser.
+   * In the final schema this field will NOT be present.
+   */
+  optionalField?: true
+
+  pattern?: string
+  minLength?: number
+  maxLength?: number
+  format?: string
+
+  contentMediaType?: string
+  contentEncoding?: string // e.g 'base64'
+
+  multipleOf?: number
+  minimum?: number
+  exclusiveMinimum?: number
+  maximum?: number
+  exclusiveMaximum?: number
+  minItems?: number
+  maxItems?: number
+  uniqueItems?: boolean
+
+  enum?: any
+
+  hasIsOfTypeCheck?: boolean
+
+  // Below we add custom Ajv keywords
+
+  email?: JsonSchemaStringEmailOptions
+  Set2?: JsonSchema
+  Buffer?: true
+  IsoDate?: JsonSchemaIsoDateOptions
+  IsoDateTime?: true
+  IsoMonth?: JsonSchemaIsoMonthOptions
+  instanceof?: string | string[]
+  transform?: { trim?: true; toLowerCase?: true; toUpperCase?: true; truncate?: number }
+  errorMessages?: StringMap<string>
+  optionalValues?: (string | number | boolean | null)[]
+  keySchema?: JsonSchema
+  isUndefined?: true
+  minProperties2?: number
+  exclusiveProperties?: (readonly string[])[]
+  anyOfBy?: {
+    propertyName: string
+    schemaDictionary: Record<string, JsonSchema>
+  }
+  anyOfThese?: JsonSchema[]
+  precision?: number
+  customValidations?: CustomValidatorFn[]
+  customConversions?: CustomConverterFn<any>[]
+  postValidation?: PostValidatonFn<any, OUT>
+}
+
+function object(props: AnyObject): never
+function object<OUT extends AnyObject>(props: {
+  [K in keyof Required<OUT>]-?: JsonSchemaTerminal<OUT[K], any>
+}): JsonSchemaObjectBuilder<OUT, false>
+
+function object<OUT extends AnyObject>(props: {
+  [key in keyof OUT]: JsonSchemaTerminal<OUT[key], any>
+}): JsonSchemaObjectBuilder<OUT, false> {
+  return new JsonSchemaObjectBuilder<OUT, false>(props)
+}
+
+function objectInfer<P extends Record<string, JsonSchemaAnyBuilder<any, any>>>(
+  props: P,
+): JsonSchemaObjectInferringBuilder<P, false> {
+  return new JsonSchemaObjectInferringBuilder<P, false>(props)
+}
+
+function objectDbEntity(props: AnyObject): never
+function objectDbEntity<
+  OUT extends BaseDBEntity,
+  EXTRA_KEYS extends Exclude<keyof OUT, keyof BaseDBEntity> = Exclude<
+    keyof OUT,
+    keyof BaseDBEntity
+  >,
+>(
+  props: {
+    // ✅ all non-system fields must be explicitly provided
+    [K in EXTRA_KEYS]-?: BuilderFor<OUT[K]>
+  } &
+    // ✅ if `id` differs, it's required
+    (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>
+
+function objectDbEntity(props: AnyObject): any {
+  return j.object({
+    id: j.string(),
+    created: j.number().unixTimestamp2000(),
+    updated: j.number().unixTimestamp2000(),
+    ...props,
+  })
+}
+
+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
+> {
+  const keyJsonSchema = keySchema.build()
+  // Check if value schema is optional before build() strips the optionalField flag
+  const isValueOptional = (valueSchema as JsonSchemaTerminal<any, any>).getSchema().optionalField
+  const valueJsonSchema = valueSchema.build()
+
+  // When value schema is optional, wrap in anyOf to allow undefined values
+  const finalValueSchema: JsonSchema = isValueOptional
+    ? { anyOf: [{ isUndefined: true }, valueJsonSchema] }
+    : valueJsonSchema
+
+  return new JsonSchemaObjectBuilder<
+    Opt extends true
+      ? Partial<Record<SchemaOut<KS>, SchemaOut<VS>>>
+      : Record<SchemaOut<KS>, SchemaOut<VS>>,
+    false
+  >([], {
+    hasIsOfTypeCheck: false,
+    keySchema: keyJsonSchema,
+    patternProperties: {
+      ['^.*$']: finalValueSchema,
+    },
+  })
+}
+
+function withRegexKeys<S extends JsonSchemaAnyBuilder<any, any>>(
+  keyRegex: RegExp | string,
+  schema: S,
+): JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>, false> {
+  if (keyRegex instanceof RegExp) {
+    _assert(
+      !keyRegex.flags,
+      `Regex flags are not supported by JSON Schema. Received: /${keyRegex.source}/${keyRegex.flags}`,
+    )
+  }
+  const pattern = keyRegex instanceof RegExp ? keyRegex.source : keyRegex
+  const jsonSchema = schema.build()
+
+  return new JsonSchemaObjectBuilder<StringMap<SchemaOut<S>>, false>([], {
+    hasIsOfTypeCheck: false,
+    patternProperties: {
+      [pattern]: jsonSchema,
+    },
+  })
+}
+
+/**
+ * Builds the object schema with the indicated `keys` and uses the `schema` for their validation.
+ */
+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
+> {
+  let enumValues: readonly (string | number)[] | undefined
+  if (Array.isArray(keys)) {
+    _assert(
+      isEveryItemPrimitive(keys),
+      'Every item in the key list should be string, number or symbol',
+    )
+    enumValues = keys
+  } else if (typeof keys === 'object') {
+    const enumType = getEnumType(keys)
+    _assert(
+      enumType === 'NumberEnum' || enumType === 'StringEnum',
+      'The key list should be StringEnum or NumberEnum',
+    )
+    if (enumType === 'NumberEnum') {
+      enumValues = _numberEnumValues(keys as NumberEnum)
+    } else if (enumType === 'StringEnum') {
+      enumValues = _stringEnumValues(keys as StringEnum)
+    }
+  }
+
+  _assert(enumValues, 'The key list should be an array of values, NumberEnum or a StringEnum')
+
+  const typedValues = enumValues as readonly K[]
+  const props = Object.fromEntries(typedValues.map(key => [key, schema])) as any
+
+  return new JsonSchemaObjectBuilder<
+    Opt extends true ? { [P in K]?: SchemaOut<S> } : { [P in K]: SchemaOut<S> },
+    false
+  >(props, { hasIsOfTypeCheck: false })
+}
+
+function hasNoObjectSchemas(schema: JsonSchema): boolean {
+  if (Array.isArray(schema.type)) {
+    schema.type.every(type => ['string', 'number', 'integer', 'boolean', 'null'].includes(type))
+  } else if (schema.anyOf) {
+    return schema.anyOf.every(hasNoObjectSchemas)
+  } else if (schema.oneOf) {
+    return schema.oneOf.every(hasNoObjectSchemas)
+  } else if (schema.enum) {
+    return true
+  } else if (schema.type === 'array') {
+    return !schema.items || hasNoObjectSchemas(schema.items)
+  } else {
+    return !!schema.type && ['string', 'number', 'integer', 'boolean', 'null'].includes(schema.type)
+  }
+
+  return false
+}
+
+type Expand<T> = { [K in keyof T]: T[K] }
+
+type StripIndexSignatureDeep<T> = T extends readonly unknown[]
+  ? T
+  : T extends Record<string, any>
+    ? {
+        [K in keyof T as string extends K
+          ? never
+          : number extends K
+            ? never
+            : symbol extends K
+              ? never
+              : K]: StripIndexSignatureDeep<T[K]>
+      }
+    : T
+
+type RelaxIndexSignature<T> = T extends readonly unknown[]
+  ? T
+  : T extends AnyObject
+    ? { [K in keyof T]: RelaxIndexSignature<T[K]> }
+    : T
+
+type Override<T, U> = Omit<T, keyof U> & U
+
+declare const allowExtraKeysSymbol: unique symbol
+
+type HasAllowExtraKeys<T> = T extends { readonly [allowExtraKeysSymbol]?: true } ? true : false
+
+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
+}[number]
+
+type AnyOfByOut<D extends Record<PropertyKey, JsonSchemaTerminal<any, any>>> = {
+  [K in keyof D]: D[K] extends JsonSchemaTerminal<infer O, any> ? O : never
+}[keyof D]
+
+type BuilderFor<T> = JsonSchemaAnyBuilder<T, any>
+
+interface JsonBuilderRuleOpt {
+  /**
+   * Text of error message to return when the validation fails for the given rule:
+   *
+   * `{ msg: "is not a valid Oompa-loompa" } => "Object.property is not a valid Oompa-loompa"`
+   */
+  msg?: string
+  /**
+   * A friendly name for what we are validating, that will be used in error messages:
+   *
+   * `{ name: "Oompa-loompa" } => "Object.property is not a valid Oompa-loompa"`
+   */
+  name?: string
+}
+
+type EnumKeyUnion<T> =
+  // array of literals -> union of its elements
+  T extends readonly (infer U)[]
+    ? U
+    : // enum object -> union of its values
+      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
+}
+
+export type PostValidatonFn<OUT, OUT2> = (v: OUT) => OUT2
+export type CustomValidatorFn = (v: any) => string | undefined
+export type CustomConverterFn<OUT> = (v: any) => OUT
+
+/**
+ * Deep copy that preserves functions in customValidations/customConversions.
+ * Unlike structuredClone, this handles function references (which only exist in those two properties).
+ */
+function deepCopyPreservingFunctions<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') return obj
+  if (Array.isArray(obj)) return obj.map(deepCopyPreservingFunctions) as T
+  const copy = {} as T
+  for (const key of Object.keys(obj)) {
+    const value = (obj as any)[key]
+    // customValidations/customConversions are arrays of functions - shallow copy the array
+    ;(copy as any)[key] =
+      (key === 'customValidations' || key === 'customConversions') && Array.isArray(value)
+        ? [...value]
+        : deepCopyPreservingFunctions(value)
+  }
+  return copy
+}