@naturalcycles/nodejs-lib 15.90.2 → 15.91.0

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

@@ -1,9 +1,8 @@
 import type { ValidationFunction, ValidationFunctionResult } from '@naturalcycles/js-lib';
-import type { AnyObject } from '@naturalcycles/js-lib/types';
+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';
-import { JsonSchemaTerminal } from './jsonSchemaBuilder.js';
-import type { JsonSchema } from './jsonSchemaBuilder.js';
 /**
  * On creation - compiles ajv validation function.
  * Provides convenient methods, error reporting, etc.
@@ -106,3 +105,660 @@ export interface AjvSchemaCfg {
     lazy?: boolean;
 }
 export type SchemaHandledByAjv<IN, OUT = IN> = JsonSchemaTerminal<IN, OUT, any> | JsonSchema<IN, OUT> | AjvSchema<IN, 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, any, false>;
+    string(): JsonSchemaStringBuilder<string, string, false>;
+    number(): JsonSchemaNumberBuilder<number, number, false>;
+    boolean(): JsonSchemaBooleanBuilder<boolean, boolean, false>;
+    object: typeof object & {
+        dbEntity: typeof objectDbEntity;
+        infer: typeof objectInfer;
+        any(): JsonSchemaObjectBuilder<AnyObject, AnyObject, false>;
+        stringMap<S extends JsonSchemaTerminal<any, any, any>>(schema: S): JsonSchemaObjectBuilder<StringMap<SchemaIn<S>>, StringMap<SchemaOut<S>>, false>;
+        /**
+         * @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: typeof 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: typeof withEnumKeys;
+        withRegexKeys: typeof withRegexKeys;
+    };
+    array<IN, OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>): JsonSchemaArrayBuilder<IN, OUT, Opt>;
+    tuple<const S extends JsonSchemaAnyBuilder<any, any, any>[]>(items: S): JsonSchemaTupleBuilder<S>;
+    set<IN, OUT, Opt>(itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>): JsonSchemaSet2Builder<IN, 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, 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`.
+     *
+     * 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, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
+    /**
+     * 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, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
+    /**
+     * 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<P extends string, D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>, IN = AnyOfByIn<D>, OUT = AnyOfByOut<D>>(propertyName: P, schemaDictionary: D): JsonSchemaAnyOfByBuilder<IN, OUT, P>;
+    /**
+     * 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, any, boolean>[], IN = BuilderInUnion<B>, OUT = BuilderOutUnion<B>>(items: [...B]): JsonSchemaAnyBuilder<IN, OUT, false>;
+    and(): {
+        silentBob: () => never;
+    };
+    literal<const V extends string | number | boolean | null>(v: V): JsonSchemaEnumBuilder<V, V, false>;
+};
+export declare class JsonSchemaTerminal<IN, OUT, Opt> {
+    protected [HIDDEN_AJV_SCHEMA]: AjvSchema<any, any> | undefined;
+    protected schema: JsonSchema;
+    constructor(schema: JsonSchema);
+    get ajvSchema(): AjvSchema<any, any>;
+    getSchema(): JsonSchema;
+    /**
+     * Produces a "clean schema object" without methods.
+     * Same as if it would be JSON.stringified.
+     */
+    build(): JsonSchema<IN, OUT>;
+    clone(): this;
+    cloneAndUpdateSchema(schema: Partial<JsonSchema>): this;
+    validate(input: any, opt?: AjvValidationOptions<IN>): OUT;
+    isValid(input: any, opt?: AjvValidationOptions<IN>): boolean;
+    getValidationResult(input: any, opt?: AjvValidationOptions<IN>): ValidationFunctionResult<OUT, AjvValidationError>;
+    getValidationFunction(): ValidationFunction<any, OUT, AjvValidationError>;
+    /**
+     * @experimental
+     */
+    in: IN;
+    out: OUT;
+    opt: Opt;
+}
+export declare class JsonSchemaAnyBuilder<IN, OUT, Opt> extends JsonSchemaTerminal<IN, 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;
+    $schemaDraft7(): this;
+    $id($id: string): this;
+    title(title: string): this;
+    description(description: string): this;
+    deprecated(deprecated?: boolean): this;
+    type(type: string): this;
+    default(v: any): this;
+    instanceof(of: string): this;
+    optional(): JsonSchemaAnyBuilder<IN | undefined, OUT | undefined, true>;
+    nullable(): JsonSchemaAnyBuilder<IN | null, 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, T, Opt>;
+    /**
+     * Locks the given schema chain and no other modification can be done to it.
+     */
+    final(): JsonSchemaTerminal<IN, 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<IN, 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<IN, OUT2, Opt>;
+}
+export declare class JsonSchemaStringBuilder<IN extends string | undefined = string, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+    constructor();
+    /**
+     * @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.
+     */
+    optional<T extends readonly (string | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JsonSchemaTerminal<IN | undefined, OUT | undefined, true> : JsonSchemaStringBuilder<IN | undefined, OUT | undefined, true> : JsonSchemaStringBuilder<IN | undefined, OUT | undefined, true>;
+    regex(pattern: RegExp, opt?: JsonBuilderRuleOpt): this;
+    pattern(pattern: string, opt?: JsonBuilderRuleOpt): this;
+    minLength(minLength: number): this;
+    maxLength(maxLength: number): this;
+    length(exactLength: number): this;
+    length(minLength: number, maxLength: number): this;
+    email(opt?: Partial<JsonSchemaStringEmailOptions>): this;
+    trim(): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+    truncate(toLength: number): this;
+    branded<B extends string>(): JsonSchemaStringBuilder<B, 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 | IN, IsoDateTime, Opt>;
+    isoMonth(): JsonSchemaIsoMonthBuilder;
+    /**
+     * Validates the string format to be JWT.
+     * Expects the JWT to be signed!
+     */
+    jwt(): this;
+    url(): this;
+    ipv4(): this;
+    ipv6(): this;
+    slug(): this;
+    semVer(): this;
+    languageTag(): this;
+    countryCode(): this;
+    currency(): this;
+    /**
+     * 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<string | IANATimezone, IANATimezone, false>;
+    base64Url(): this;
+    uuid(): this;
+}
+export interface JsonSchemaStringEmailOptions {
+    checkTLD: boolean;
+}
+export declare class JsonSchemaIsoDateBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<string | IsoDate, IsoDate, Opt> {
+    constructor();
+    /**
+     * @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.
+     */
+    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JsonSchemaTerminal<string | IsoDate | null | undefined, IsoDate | undefined, true> : JsonSchemaAnyBuilder<string | IsoDate | undefined, IsoDate | undefined, true>;
+    before(date: string): this;
+    sameOrBefore(date: string): this;
+    after(date: string): this;
+    sameOrAfter(date: string): this;
+    between(fromDate: string, toDate: string, incl: Inclusiveness): this;
+}
+export interface JsonSchemaIsoDateOptions {
+    before?: string;
+    sameOrBefore?: string;
+    after?: string;
+    sameOrAfter?: string;
+}
+export declare class JsonSchemaIsoMonthBuilder<Opt extends boolean = false> extends JsonSchemaAnyBuilder<string | IsoDate, IsoMonth, Opt> {
+    constructor();
+}
+export interface JsonSchemaIsoMonthOptions {
+}
+export declare class JsonSchemaNumberBuilder<IN extends number | undefined = number, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+    constructor();
+    /**
+     * @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.
+     */
+    optional<T extends readonly (number | null)[] | undefined = undefined>(optionalValues?: T): T extends readonly (infer U)[] ? null extends U ? JsonSchemaTerminal<IN | undefined, OUT | undefined, true> : JsonSchemaNumberBuilder<IN | undefined, OUT | undefined, true> : JsonSchemaNumberBuilder<IN | undefined, OUT | undefined, true>;
+    integer(): this;
+    branded<B extends number>(): JsonSchemaNumberBuilder<B, B, Opt>;
+    multipleOf(multipleOf: number): this;
+    min(minimum: number): this;
+    exclusiveMin(exclusiveMinimum: number): this;
+    max(maximum: number): this;
+    exclusiveMax(exclusiveMaximum: number): this;
+    lessThan(value: number): this;
+    lessThanOrEqual(value: number): this;
+    moreThan(value: number): this;
+    moreThanOrEqual(value: number): this;
+    equal(value: number): this;
+    range(minimum: number, maximum: number, incl: Inclusiveness): this;
+    int32(): this;
+    int64(): this;
+    float(): this;
+    double(): this;
+    unixTimestamp(): JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, Opt>;
+    unixTimestamp2000(): JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, Opt>;
+    unixTimestampMillis(): JsonSchemaNumberBuilder<UnixTimestampMillis, UnixTimestampMillis, Opt>;
+    unixTimestamp2000Millis(): JsonSchemaNumberBuilder<UnixTimestampMillis, UnixTimestampMillis, Opt>;
+    utcOffset(): this;
+    utcOffsetHour(): this;
+    /**
+     * 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;
+}
+export declare class JsonSchemaBooleanBuilder<IN extends boolean | undefined = boolean, OUT = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+    constructor();
+    /**
+     * @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.
+     */
+    optional(optionalValue?: boolean): JsonSchemaBooleanBuilder<IN | undefined, OUT | undefined, true>;
+}
+export declare class JsonSchemaObjectBuilder<IN extends AnyObject, OUT extends AnyObject, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+    constructor(props?: AnyObject, opt?: JsonSchemaObjectBuilderOpts);
+    addProperties(props: AnyObject): 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.
+     */
+    optional<N extends null | undefined = undefined>(nullValue?: N): N extends null ? JsonSchemaTerminal<IN | null | undefined, OUT | undefined, true> : JsonSchemaAnyBuilder<IN | undefined, 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, any>>>(props: P): JsonSchemaObjectBuilder<RelaxIndexSignature<OptionalDbEntityFields<Override<IN, {
+        [K in keyof P]?: P[K] extends JsonSchemaAnyBuilder<infer IN2, any, any> ? IN2 : never;
+    }>>>, Override<OUT, {
+        [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: P[K] extends JsonSchemaAnyBuilder<any, infer OUT2, any> ? OUT2 : never;
+    } & {
+        [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: P[K] extends JsonSchemaAnyBuilder<any, infer OUT2, any> ? OUT2 : never;
+    }>, false>;
+    /**
+     * 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<IN2 extends AnyObject, OUT2 extends AnyObject>(other: JsonSchemaObjectBuilder<IN2, OUT2, any>): JsonSchemaObjectBuilder<IN & IN2, OUT & OUT2, false>;
+    /**
+     * Extends the current schema with `id`, `created` and `updated` according to NC DB conventions.
+     */
+    dbEntity(): JsonSchemaObjectBuilder<RelaxIndexSignature<OptionalDbEntityFields<Override<IN, {
+        id?: string | undefined;
+        created?: any;
+        updated?: any;
+    }>>>, Override<OUT, {
+        id: string;
+        created: any;
+        updated: any;
+    } & {}>, false>;
+    minProperties(minProperties: number): this;
+    maxProperties(maxProperties: number): this;
+    exclusiveProperties(propNames: readonly (keyof IN & string)[]): this;
+}
+interface JsonSchemaObjectBuilderOpts {
+    hasIsOfTypeCheck?: false;
+    patternProperties?: StringMap<JsonSchema<any, any>>;
+    keySchema?: JsonSchema;
+}
+export declare class JsonSchemaObjectInferringBuilder<PROPS extends Record<string, JsonSchemaAnyBuilder<any, any, any>>, Opt extends boolean = false> extends JsonSchemaAnyBuilder<Expand<{
+    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+} & {
+    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+}>, Expand<{
+    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+} & {
+    [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<any, 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`
+     * (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, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+    } & {
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+    }> | undefined, Expand<{
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+    } & {
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+    }> | undefined, true> : JsonSchemaAnyBuilder<Expand<{
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+    } & {
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+    }> | undefined, Expand<{
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? never : K : never]: PROPS[K] extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+    } & {
+        [K in keyof PROPS as PROPS[K] extends JsonSchemaAnyBuilder<any, any, infer IsOpt> ? IsOpt extends true ? K : never : never]?: PROPS[K] extends JsonSchemaAnyBuilder<any, 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, 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>;
+    /**
+     * 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, string, false>;
+        created: JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, false>;
+        updated: JsonSchemaNumberBuilder<UnixTimestamp, UnixTimestamp, false>;
+    }[K] : K extends keyof PROPS ? PROPS[K] : never; }, Opt>;
+}
+export declare class JsonSchemaArrayBuilder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<IN[], OUT[], Opt> {
+    constructor(itemsSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>);
+    minLength(minItems: number): this;
+    maxLength(maxItems: number): this;
+    length(exactLength: number): this;
+    length(minItems: number, maxItems: number): this;
+    exactLength(length: number): this;
+    unique(): this;
+}
+export declare class JsonSchemaSet2Builder<IN, OUT, Opt> extends JsonSchemaAnyBuilder<Iterable<IN>, Set2<OUT>, Opt> {
+    constructor(itemsSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>);
+    min(minItems: number): this;
+    max(maxItems: number): this;
+}
+export declare class JsonSchemaBufferBuilder extends JsonSchemaAnyBuilder<string | any[] | ArrayBuffer | Buffer, Buffer, false> {
+    constructor();
+}
+export declare class JsonSchemaEnumBuilder<IN extends string | number | boolean | null, OUT extends IN = IN, Opt extends boolean = false> extends JsonSchemaAnyBuilder<IN, OUT, Opt> {
+    constructor(enumValues: readonly IN[], baseType: EnumBaseType, opt?: JsonBuilderRuleOpt);
+    branded<B extends IN>(): JsonSchemaEnumBuilder<B | IN, B, Opt>;
+}
+export declare class JsonSchemaTupleBuilder<ITEMS extends JsonSchemaAnyBuilder<any, any, any>[]> extends JsonSchemaAnyBuilder<TupleIn<ITEMS>, TupleOut<ITEMS>, false> {
+    private readonly _items;
+    constructor(items: ITEMS);
+}
+export declare class JsonSchemaAnyOfByBuilder<IN, OUT, _P extends string = string> extends JsonSchemaAnyBuilder<AnyOfByInput<IN, _P> | IN, OUT, false> {
+    in: IN;
+    constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any, any>>);
+}
+export declare class JsonSchemaAnyOfTheseBuilder<IN, OUT, _P extends string = string> extends JsonSchemaAnyBuilder<AnyOfByInput<IN, _P> | IN, OUT, false> {
+    in: IN;
+    constructor(propertyName: string, schemaDictionary: Record<PropertyKey, JsonSchemaTerminal<any, any, any>>);
+}
+type EnumBaseType = 'string' | 'number' | 'other';
+export interface JsonSchema<IN = unknown, OUT = IN> {
+    readonly in?: IN;
+    readonly out?: OUT;
+    $schema?: string;
+    $id?: string;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    type?: string | string[];
+    items?: JsonSchema;
+    prefixItems?: JsonSchema[];
+    properties?: {
+        [K in keyof IN & keyof OUT]: JsonSchema<IN[K], OUT[K]>;
+    };
+    patternProperties?: StringMap<JsonSchema<any, any>>;
+    required?: string[];
+    additionalProperties?: boolean;
+    minProperties?: number;
+    maxProperties?: number;
+    default?: IN;
+    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;
+    multipleOf?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    enum?: any;
+    hasIsOfTypeCheck?: boolean;
+    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>[];
+}
+declare function object(props: AnyObject): never;
+declare function object<IN extends AnyObject>(props: {
+    [K in keyof Required<IN>]-?: JsonSchemaTerminal<any, IN[K], any>;
+}): JsonSchemaObjectBuilder<IN, IN, false>;
+declare function objectInfer<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props: P): JsonSchemaObjectInferringBuilder<P, false>;
+declare function objectDbEntity(props: AnyObject): never;
+declare function objectDbEntity<IN extends BaseDBEntity, EXTRA_KEYS extends Exclude<keyof IN, keyof BaseDBEntity> = Exclude<keyof IN, keyof BaseDBEntity>>(props: {
+    [K in EXTRA_KEYS]-?: BuilderFor<IN[K]>;
+} & (ExactMatch<IN['id'], BaseDBEntity['id']> extends true ? {
+    id?: BuilderFor<BaseDBEntity['id']>;
+} : {
+    id: BuilderFor<IN['id']>;
+}) & (ExactMatch<IN['created'], BaseDBEntity['created']> extends true ? {
+    created?: BuilderFor<BaseDBEntity['created']>;
+} : {
+    created: BuilderFor<IN['created']>;
+}) & (ExactMatch<IN['updated'], BaseDBEntity['updated']> extends true ? {
+    updated?: BuilderFor<BaseDBEntity['updated']>;
+} : {
+    updated: BuilderFor<IN['updated']>;
+})): JsonSchemaObjectBuilder<IN, IN, false>;
+declare function record<KS extends JsonSchemaAnyBuilder<any, any, any>, VS extends JsonSchemaAnyBuilder<any, any, any>, Opt extends boolean = SchemaOpt<VS>>(keySchema: KS, valueSchema: VS): JsonSchemaObjectBuilder<Opt extends true ? Partial<Record<SchemaIn<KS>, SchemaIn<VS>>> : Record<SchemaIn<KS>, SchemaIn<VS>>, Opt extends true ? Partial<Record<SchemaOut<KS>, SchemaOut<VS>>> : Record<SchemaOut<KS>, SchemaOut<VS>>, false>;
+declare function withRegexKeys<S extends JsonSchemaAnyBuilder<any, any, any>, Opt extends boolean = SchemaOpt<S>>(keyRegex: RegExp | string, schema: S): JsonSchemaObjectBuilder<Opt extends true ? StringMap<SchemaIn<S>> : StringMap<SchemaIn<S>>, Opt extends true ? StringMap<SchemaOut<S>> : 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, any>, K extends string | number = EnumKeyUnion<T>, Opt extends boolean = SchemaOpt<S>>(keys: T, schema: S): JsonSchemaObjectBuilder<Opt extends true ? {
+    [P in K]?: SchemaIn<S>;
+} : {
+    [P in K]: SchemaIn<S>;
+}, Opt extends true ? {
+    [P in K]?: SchemaOut<S>;
+} : {
+    [P in K]: SchemaOut<S>;
+}, 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 OptionalDbEntityFields<T> = T extends BaseDBEntity ? Omit<T, keyof BaseDBEntity> & Partial<Pick<T, keyof BaseDBEntity>> : T;
+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, any>[]> = {
+    [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<any, infer O, any> ? O : never;
+}[number];
+type BuilderInUnion<B extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
+    [K in keyof B]: B[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never;
+}[number];
+type AnyOfByIn<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+    [K in keyof D]: D[K] extends JsonSchemaTerminal<infer I, any, any> ? I : never;
+}[keyof D];
+type AnyOfByOut<D extends Record<PropertyKey, JsonSchemaTerminal<any, any, any>>> = {
+    [K in keyof D]: D[K] extends JsonSchemaTerminal<any, infer O, any> ? O : never;
+}[keyof D];
+type AnyOfByDiscriminant<IN, P extends string> = IN extends {
+    [K in P]: infer V;
+} ? V : never;
+type AnyOfByInput<IN, P extends string, D = AnyOfByDiscriminant<IN, P>> = IN extends unknown ? Omit<Partial<IN>, P> & {
+    [K in P]?: D;
+} : never;
+type BuilderFor<T> = JsonSchemaAnyBuilder<any, 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> = T extends readonly (infer U)[] ? U : T extends StringEnum | NumberEnum ? T[keyof T] : never;
+type SchemaIn<S> = S extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : never;
+type SchemaOut<S> = S extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never;
+type SchemaOpt<S> = S extends JsonSchemaAnyBuilder<any, any, infer Opt> ? (Opt extends true ? true : false) : false;
+type TupleIn<T extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
+    [K in keyof T]: T[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never;
+};
+type TupleOut<T extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
+    [K in keyof T]: T[K] extends JsonSchemaAnyBuilder<any, infer O, any> ? O : never;
+};
+export type CustomValidatorFn = (v: any) => string | undefined;
+export type CustomConverterFn<OUT> = (v: any) => OUT;
+export {};