@naturalcycles/js-lib 15.46.1 → 15.47.0

package/dist/promise/pProps.js

@@ -15,6 +15,6 @@
 export async function pProps(input) {
     const keys = Object.keys(input);
     // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+    // oxlint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }

package/dist/promise/pTimeout.js

@@ -44,7 +44,7 @@ export async function pTimeout(fn, opt) {
                     _typeCast(err);
                     // keep original stack
                     err.stack = fakeError.stack.replace('Error: TimeoutError', err.name + ': ' + err.message);
-                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                    // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
                     reject(_errorDataAppend(err, opt.errorData));
                 }
                 return;

package/dist/semver.js

@@ -58,6 +58,7 @@ export class Semver {
 class SemverFactory {
     fromInput(input) {
         const s = this.fromInputOrUndefined(input);
+        // oxlint-disable-next-line typescript/restrict-template-expressions
         _assert(s, `Cannot parse "${input}" into Semver`, {
             input,
         });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/js-lib",
   "type": "module",
-  "version": "15.46.1",
+  "version": "15.47.0",
   "dependencies": {
     "tslib": "^2",
     "undici": "^7",
@@ -29,7 +29,6 @@
     "./error": "./dist/error/index.js",
     "./error/*.js": "./dist/error/*.js",
     "./http": "./dist/http/index.js",
-    "./json-schema": "./dist/json-schema/index.js",
     "./log": "./dist/log/commonLogger.js",
     "./math": "./dist/math/index.js",
     "./math/*.js": "./dist/math/*.js",

package/src/promise/pProps.ts

@@ -17,7 +17,7 @@ export async function pProps<T>(input: { [K in keyof T]: T[K] | Promise<T[K]> })
 }> {
   const keys = Object.keys(input)
   // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+  // oxlint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
   return Object.fromEntries(
     (await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]),
   ) as any

package/src/promise/pTimeout.ts

@@ -88,7 +88,7 @@ export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions)
           _typeCast<Error>(err)
           // keep original stack
           err.stack = fakeError.stack!.replace('Error: TimeoutError', err.name + ': ' + err.message)
-          // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+          // oxlint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
           reject(_errorDataAppend(err, opt.errorData))
         }
         return

package/src/semver.ts

@@ -68,6 +68,7 @@ class SemverFactory {
   fromInput(input: SemverInput): Semver {
     const s = this.fromInputOrUndefined(input)
 
+    // oxlint-disable-next-line typescript/restrict-template-expressions
     _assert(s, `Cannot parse "${input}" into Semver`, {
       input,
     })

package/src/types.ts

@@ -34,7 +34,7 @@ export type AnyEnum = NumberEnum
 export type NumberEnum = Record<string, number | string>
 export type StringEnum = Record<string, string>
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type CreatedUpdated = {
   created: UnixTimestamp
   updated: UnixTimestamp
@@ -44,12 +44,12 @@ export interface CreatedUpdatedId extends CreatedUpdated {
   id: string
 }
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type ObjectWithId = {
   id: string
 }
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type PartialObjectWithId = {
   id?: string
 }
@@ -61,7 +61,7 @@ export interface AnyObjectWithId extends AnyObject, ObjectWithId {}
 /**
  * Base interface for any Entity that was saved to DB.
  */
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 export type BaseDBEntity = {
   id: string
 

package/src/zod/zod.shared.schemas.ts

@@ -108,7 +108,7 @@ const baseDBEntitySchema = z.object({
   updated: unixTimestamp2000(),
 })
 
-// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+// oxlint-disable-next-line @typescript-eslint/consistent-type-definitions
 type BaseDBEntityZodShape = {
   id: ZodString
   created: ZodBrandedInt<UnixTimestamp>

package/dist/json-schema/from-data/generateJsonSchemaFromData.d.ts

@@ -1,8 +0,0 @@
-import { type AnyObject } from '../../types.js';
-import type { JsonSchemaObject } from '../jsonSchema.model.js';
-/**
- * Each row must be an object (current limitation).
- *
- * `additionalProperties` is set to `true`, cause it's safer.
- */
-export declare function generateJsonSchemaFromData<T extends AnyObject = AnyObject>(rows: AnyObject[]): JsonSchemaObject<T>;

package/dist/json-schema/from-data/generateJsonSchemaFromData.js

@@ -1,87 +0,0 @@
-import { _uniq } from '../../array/index.js';
-import { _stringMapEntries } from '../../types.js';
-/**
- * Each row must be an object (current limitation).
- *
- * `additionalProperties` is set to `true`, cause it's safer.
- */
-export function generateJsonSchemaFromData(rows) {
-    return objectToJsonSchema(rows);
-}
-function objectToJsonSchema(rows) {
-    const typesByKey = {};
-    rows.forEach(r => {
-        Object.keys(r).forEach(key => {
-            typesByKey[key] ||= new Set();
-            typesByKey[key].add(getTypeOfValue(r[key]));
-        });
-    });
-    const s = {
-        type: 'object',
-        properties: {},
-        required: [],
-        additionalProperties: true,
-    };
-    _stringMapEntries(typesByKey).forEach(([key, types]) => {
-        const schema = mergeTypes([...types], rows.map(r => r[key]));
-        if (!schema)
-            return;
-        s.properties[key] = schema;
-    });
-    // console.log(typesByKey)
-    return s;
-}
-function mergeTypes(types, samples) {
-    // skip "undefined" types
-    types = types.filter(t => t !== 'undefined');
-    if (!types.length)
-        return undefined;
-    if (types.length > 1) {
-        // oneOf
-        const s = {
-            oneOf: types.map(type => mergeTypes([type], samples)),
-        };
-        return s;
-    }
-    const type = types[0];
-    if (type === 'null') {
-        return {
-            type: 'null',
-        };
-    }
-    if (type === 'boolean') {
-        return {
-            type: 'boolean',
-        };
-    }
-    if (type === 'string') {
-        return {
-            type: 'string',
-        };
-    }
-    if (type === 'number') {
-        return {
-            type: 'number',
-        };
-    }
-    if (type === 'object') {
-        return objectToJsonSchema(samples.filter((r) => r && typeof r === 'object'));
-    }
-    if (type === 'array') {
-        // possible feature: detect if it's a tuple
-        // currently assume no-tuple
-        const items = samples.filter(r => Array.isArray(r)).flat();
-        const itemTypes = _uniq(items.map(i => getTypeOfValue(i)));
-        return {
-            type: 'array',
-            items: mergeTypes(itemTypes, items),
-        };
-    }
-}
-function getTypeOfValue(v) {
-    if (v === null)
-        return 'null';
-    if (Array.isArray(v))
-        return 'array';
-    return typeof v;
-}

package/dist/json-schema/index.d.ts

@@ -1 +0,0 @@
-export * from './from-data/generateJsonSchemaFromData.js';

package/dist/json-schema/index.js

@@ -1 +0,0 @@
-export * from './from-data/generateJsonSchemaFromData.js';

package/dist/json-schema/jsonSchema.cnst.d.ts

@@ -1,2 +0,0 @@
-import type { JsonSchema, JsonSchemaAny, JsonSchemaNumber, JsonSchemaObject, JsonSchemaString } from './jsonSchema.model.js';
-export declare const JSON_SCHEMA_ORDER: (keyof JsonSchema | keyof JsonSchemaAny | keyof JsonSchemaObject | keyof JsonSchemaString | keyof JsonSchemaNumber)[];

package/dist/json-schema/jsonSchema.cnst.js

@@ -1,38 +0,0 @@
-export const JSON_SCHEMA_ORDER = [
-    '$schema',
-    '$id',
-    'title',
-    'description',
-    'deprecated',
-    'readOnly',
-    'writeOnly',
-    'type',
-    'default',
-    // Object,
-    'properties',
-    'required',
-    'minProperties',
-    'maxProperties',
-    'patternProperties',
-    'propertyNames',
-    // Array
-    'properties',
-    'required',
-    'minProperties',
-    'maxProperties',
-    'patternProperties',
-    'propertyNames',
-    // String
-    'pattern',
-    'minLength',
-    'maxLength',
-    'format',
-    'transform',
-    // Number
-    'format',
-    'multipleOf',
-    'minimum',
-    'exclusiveMinimum',
-    'maximum',
-    'exclusiveMaximum',
-];

package/dist/json-schema/jsonSchema.model.d.ts

@@ -1,121 +0,0 @@
-import type { AnyObject, StringMap } from '../types.js';
-export type JsonSchema<T = unknown> = JsonSchemaAny<T> | JsonSchemaOneOf<T> | JsonSchemaAllOf<T> | JsonSchemaAnyOf<T> | JsonSchemaNot<T> | JsonSchemaRef<T> | JsonSchemaConst<T> | JsonSchemaEnum<T> | JsonSchemaString | JsonSchemaNumber | JsonSchemaBoolean | JsonSchemaNull | JsonSchemaObject<T extends AnyObject ? T : AnyObject> | JsonSchemaArray<T> | JsonSchemaTuple<T>;
-export interface JsonSchemaAny<T = unknown> {
-    $schema?: string;
-    $id?: string;
-    title?: string;
-    description?: string;
-    deprecated?: boolean;
-    readOnly?: boolean;
-    writeOnly?: boolean;
-    type?: string | string[];
-    default?: T;
-    if?: JsonSchema;
-    then?: JsonSchema;
-    else?: JsonSchema;
-    /**
-     * https://ajv.js.org/packages/ajv-keywords.html#instanceof
-     *
-     * Useful for Node.js Buffer, you can use it like:
-     * `instanceof: 'Buffer'`
-     */
-    instanceof?: string | string[];
-    /**
-     * 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;
-}
-/**
- * Union type
- */
-export interface JsonSchemaOneOf<T = unknown> extends JsonSchemaAny<T> {
-    oneOf: JsonSchema[];
-}
-/**
- * Intersection type
- */
-export interface JsonSchemaAllOf<T = unknown> extends JsonSchemaAny<T> {
-    allOf: JsonSchema[];
-}
-export interface JsonSchemaAnyOf<T = unknown> extends JsonSchemaAny<T> {
-    anyOf: JsonSchema[];
-}
-export interface JsonSchemaNot<T = unknown> extends JsonSchemaAny<T> {
-    not: JsonSchema;
-}
-export interface JsonSchemaConst<T = unknown> extends JsonSchemaAny<T> {
-    const: T;
-}
-export interface JsonSchemaString<T extends string = string> extends JsonSchemaAny<T> {
-    type: 'string';
-    pattern?: string;
-    minLength?: number;
-    maxLength?: number;
-    format?: string;
-    contentMediaType?: string;
-    contentEncoding?: string;
-    /**
-     * https://ajv.js.org/packages/ajv-keywords.html#transform
-     */
-    transform?: ('trim' | 'toLowerCase' | 'toUpperCase')[];
-}
-export interface JsonSchemaNumber<T extends number = number> extends JsonSchemaAny<T> {
-    type: 'number' | 'integer';
-    format?: string;
-    multipleOf?: number;
-    minimum?: number;
-    exclusiveMinimum?: number;
-    maximum?: number;
-    exclusiveMaximum?: number;
-}
-export interface JsonSchemaBoolean extends JsonSchemaAny<boolean> {
-    type: 'boolean';
-}
-export interface JsonSchemaNull extends JsonSchemaAny<null> {
-    type: 'null';
-}
-export interface JsonSchemaEnum<T = unknown> extends JsonSchemaAny<T> {
-    enum: T[];
-}
-export interface JsonSchemaRef<T = unknown> extends JsonSchemaAny<T> {
-    $ref: string;
-}
-export interface JsonSchemaRootObject<T extends AnyObject = AnyObject> extends JsonSchemaObject<T> {
-    $id: string;
-}
-export interface JsonSchemaObject<T extends AnyObject = AnyObject> extends JsonSchemaAny<T> {
-    type: 'object';
-    properties: {
-        [k in keyof T]: JsonSchema;
-    };
-    required: (keyof T)[];
-    additionalProperties: boolean;
-    minProperties?: number;
-    maxProperties?: number;
-    patternProperties?: StringMap<JsonSchema>;
-    propertyNames?: JsonSchema;
-    /**
-     * @example
-     *
-     * dependentRequired: {
-     *   credit_card: ['billing_address']
-     * }
-     */
-    dependentRequired?: StringMap<string[]>;
-    dependentSchemas?: StringMap<JsonSchema>;
-    dependencies?: StringMap<string[]>;
-}
-export interface JsonSchemaArray<ITEM = unknown> extends JsonSchemaAny<ITEM[]> {
-    type: 'array';
-    items: JsonSchema<ITEM>;
-    minItems?: number;
-    maxItems?: number;
-    uniqueItems?: boolean;
-}
-export interface JsonSchemaTuple<T = unknown> extends JsonSchemaAny<T> {
-    type: 'array';
-    items: JsonSchema[];
-    minItems: number;
-    maxItems: number;
-}

package/dist/json-schema/jsonSchema.model.js

@@ -1 +0,0 @@
-export {};

package/dist/json-schema/jsonSchema.util.d.ts

@@ -1,8 +0,0 @@
-import type { AnyObject } from '../types.js';
-import type { JsonSchemaObject } from './jsonSchema.model.js';
-/**
- * Merges s2 into s1 (mutates s1) and returns s1.
- * Does not mutate s2.
- * API similar to Object.assign(s1, s2)
- */
-export declare function mergeJsonSchemaObjects<T1 extends AnyObject, T2 extends AnyObject>(s1: JsonSchemaObject<T1>, s2: JsonSchemaObject<T2>): JsonSchemaObject<T1 & T2>;

package/dist/json-schema/jsonSchema.util.js

@@ -1,27 +0,0 @@
-import { _uniq } from '../array/array.util.js';
-import { _filterNullishValues } from '../object/object.util.js';
-/**
- * Merges s2 into s1 (mutates s1) and returns s1.
- * Does not mutate s2.
- * API similar to Object.assign(s1, s2)
- */
-export function mergeJsonSchemaObjects(s1, s2) {
-    // Merge `properties`
-    Object.entries(s2.properties).forEach(([k, v]) => {
-        ;
-        s1.properties[k] = v;
-    });
-    // Merge `patternProperties`
-    Object.entries(s2.patternProperties || {}).forEach(([k, v]) => {
-        ;
-        s1.patternProperties[k] = v;
-    });
-    s1.propertyNames = s2.propertyNames || s1.propertyNames;
-    s1.minProperties = s2.minProperties ?? s1.minProperties;
-    s1.maxProperties = s2.maxProperties ?? s1.maxProperties;
-    // Merge `required`
-    s1.required.push(...s2.required);
-    s1.required = _uniq(s1.required).sort();
-    // `additionalProperties` remains the same
-    return _filterNullishValues(s1, { mutate: true });
-}

package/dist/json-schema/jsonSchemaBuilder.d.ts

@@ -1,159 +0,0 @@
-import { type AnyObject, type BaseDBEntity, type IsoDate, type IsoDateTime, type NumberEnum, type StringEnum, type UnixTimestamp, type UnixTimestampMillis } from '../types.js';
-import type { JsonSchema, JsonSchemaAllOf, JsonSchemaAny, JsonSchemaArray, JsonSchemaBoolean, JsonSchemaConst, JsonSchemaEnum, JsonSchemaNull, JsonSchemaNumber, JsonSchemaObject, JsonSchemaOneOf, JsonSchemaRef, JsonSchemaString, JsonSchemaTuple } from './jsonSchema.model.js';
-export interface JsonSchemaBuilder<T = unknown> {
-    build: () => JsonSchema<T>;
-}
-/**
- * Fluent (chainable) API to manually create Json Schemas.
- * Inspired by Joi and Zod.
- */
-export declare const j: {
-    any<T = unknown>(): JsonSchemaAnyBuilder<T, JsonSchemaAny<T>, false>;
-    const<T extends string | number | boolean | null>(value: T): JsonSchemaAnyBuilder<T, JsonSchemaConst<T>, false>;
-    null(): JsonSchemaAnyBuilder<null, JsonSchemaNull, false>;
-    ref<T = unknown>($ref: string): JsonSchemaAnyBuilder<T, JsonSchemaRef<T>, false>;
-    enum<const T extends readonly (string | number | boolean | null)[] | StringEnum | NumberEnum>(input: T): JsonSchemaAnyBuilder<T extends readonly (infer U)[] ? U : T extends StringEnum ? T[keyof T] : T extends NumberEnum ? T[keyof T] : never, JsonSchemaEnum<any>, false>;
-    boolean(): JsonSchemaAnyBuilder<boolean, JsonSchemaBoolean, false>;
-    buffer(): JsonSchemaAnyBuilder<Buffer<ArrayBufferLike>, JsonSchemaAny<Buffer<ArrayBufferLike>>, false>;
-    number<T extends number = number>(): JsonSchemaNumberBuilder<T, false>;
-    integer<T extends number = number>(): JsonSchemaNumberBuilder<T, false>;
-    string<T extends string = string>(): JsonSchemaStringBuilder<T, false>;
-    object: typeof object;
-    dbEntity<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props: P): JsonSchemaObjectBuilder<BaseDBEntity & { [K in keyof P]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never; }>;
-    rootObject<T extends AnyObject>(props: { [K in keyof T]: JsonSchemaAnyBuilder<T[K]>; }): JsonSchemaObjectBuilder<T, false>;
-    array<T extends JsonSchemaAnyBuilder<any>>(itemSchema: T): JsonSchemaArrayBuilder<T["infer"], false>;
-    tuple<T extends any[] = unknown[]>(items: JsonSchemaAnyBuilder[]): JsonSchemaTupleBuilder<T>;
-    oneOf<Builders extends JsonSchemaAnyBuilder<any, any, any>[]>(items: [...Builders]): JsonSchemaAnyBuilder<Builders[number] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never, JsonSchemaOneOf<Builders[number] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never>>;
-    allOf<T = unknown>(items: JsonSchemaAnyBuilder[]): JsonSchemaAnyBuilder<T, JsonSchemaAllOf<T>, false>;
-};
-export declare class JsonSchemaAnyBuilder<T = unknown, SCHEMA_TYPE extends JsonSchema<T> = JsonSchema<T>, Opt extends boolean = false> implements JsonSchemaBuilder<T> {
-    protected schema: SCHEMA_TYPE;
-    constructor(schema: SCHEMA_TYPE);
-    /**
-     * Used in ObjectBuilder to access schema.optionalProperty
-     */
-    getSchema(): SCHEMA_TYPE;
-    $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<T | undefined, JsonSchema<T | undefined>, true>;
-    optional(optional: true): JsonSchemaAnyBuilder<T | undefined, JsonSchema<T | undefined>, true>;
-    optional(optional: false): JsonSchemaAnyBuilder<Exclude<T, undefined>, JsonSchema<Exclude<T, undefined>>, false>;
-    nullable(): JsonSchemaAnyBuilder<T | null, JsonSchema<T | null>, Opt>;
-    /**
-     * Produces a "clean schema object" without methods.
-     * Same as if it would be JSON.stringified.
-     */
-    build(): SCHEMA_TYPE;
-    clone(): JsonSchemaAnyBuilder<T, SCHEMA_TYPE, Opt>;
-    /**
-     * @experimental
-     */
-    infer: T;
-}
-export declare class JsonSchemaNumberBuilder<T extends number = number, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaNumber<T>, Opt> {
-    constructor();
-    integer(): this;
-    multipleOf(multipleOf: number): this;
-    min(minimum: number): this;
-    exclusiveMin(exclusiveMinimum: number): this;
-    max(maximum: number): this;
-    exclusiveMax(exclusiveMaximum: number): this;
-    /**
-     * Both ranges are inclusive.
-     */
-    range(minimum: number, maximum: number): this;
-    format(format: string): this;
-    int32: () => this;
-    int64: () => this;
-    float: () => this;
-    double: () => this;
-    unixTimestamp: () => JsonSchemaNumberBuilder<UnixTimestamp>;
-    unixTimestamp2000: () => JsonSchemaNumberBuilder<UnixTimestamp>;
-    unixTimestampMillis: () => JsonSchemaNumberBuilder<UnixTimestampMillis>;
-    unixTimestampMillis2000: () => JsonSchemaNumberBuilder<UnixTimestampMillis>;
-    utcOffset: () => this;
-    utcOffsetHours: () => this;
-    branded<B extends number>(): JsonSchemaNumberBuilder<B>;
-}
-export declare class JsonSchemaStringBuilder<T extends string = string, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaString<T>, Opt> {
-    constructor();
-    regex(pattern: RegExp): this;
-    pattern(pattern: string): this;
-    min(minLength: number): this;
-    max(maxLength: number): this;
-    length(minLength: number, maxLength: number): this;
-    format(format: string): this;
-    email: () => this;
-    url: () => this;
-    ipv4: () => this;
-    ipv6: () => this;
-    password: () => this;
-    id: () => this;
-    slug: () => this;
-    semVer: () => this;
-    languageTag: () => this;
-    countryCode: () => this;
-    currency: () => this;
-    trim(trim?: boolean): this;
-    toLowerCase(toLowerCase?: boolean): this;
-    toUpperCase(toUpperCase?: boolean): this;
-    truncate(toLength: number): this;
-    branded<B extends string>(): JsonSchemaStringBuilder<B>;
-    /**
-     * Accepts only the `YYYY-MM-DD` shape from all ISO 8601 variants.
-     */
-    isoDate(): JsonSchemaStringBuilder<IsoDate>;
-    /**
-     * Accepts strings that start with the `YYYY-MM-DDTHH:MM:SS` shape
-     * and optionally end with either a `Z` or a `+/-hh:mm` timezone part.
-     */
-    isoDateTime(): JsonSchemaStringBuilder<IsoDateTime>;
-    jwt(): this;
-}
-export declare class JsonSchemaObjectBuilder<T extends AnyObject, Opt extends boolean = false> extends JsonSchemaAnyBuilder<T, JsonSchemaObject<T>, Opt> {
-    constructor();
-    addProperties(props?: {
-        [k in keyof T]: JsonSchemaBuilder<T[k]>;
-    }): this;
-    /**
-     * Ensures `required` is always sorted and _uniq
-     */
-    required(required: (keyof T)[]): this;
-    addRequired(required: (keyof T)[]): this;
-    minProps(minProperties: number): this;
-    maxProps(maxProperties: number): this;
-    additionalProps(additionalProperties: boolean): this;
-    baseDBEntity(): JsonSchemaObjectBuilder<T & BaseDBEntity>;
-    extend<T2 extends AnyObject>(s2: JsonSchemaObjectBuilder<T2>): JsonSchemaObjectBuilder<T & T2 extends infer O ? {
-        [K in keyof O]: O[K];
-    } : never>;
-}
-export declare class JsonSchemaArrayBuilder<ITEM, Opt extends boolean = false> extends JsonSchemaAnyBuilder<ITEM[], JsonSchemaArray<ITEM>, Opt> {
-    constructor(itemsSchema: JsonSchemaBuilder<ITEM>);
-    min(minItems: number): this;
-    max(maxItems: number): this;
-    unique(uniqueItems?: boolean): this;
-}
-export declare class JsonSchemaTupleBuilder<T extends any[]> extends JsonSchemaAnyBuilder<T, JsonSchemaTuple<T>> {
-    constructor(items: JsonSchemaBuilder[]);
-}
-declare function object<P extends Record<string, JsonSchemaAnyBuilder<any, any, any>>>(props?: {
-    [K in keyof P]: P[K] & JsonSchemaAnyBuilder<any, any, any>;
-}): JsonSchemaObjectBuilder<{
-    [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? never : K : never]: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;
-} & {
-    [K in keyof P as P[K] extends JsonSchemaAnyBuilder<any, any, infer Opt> ? Opt extends true ? K : never : never]?: P[K] extends JsonSchemaAnyBuilder<infer U, any, any> ? U : never;
-} extends infer O ? {
-    [K in keyof O]: O[K];
-} : never>;
-declare function object<T extends AnyObject>(props?: {
-    [K in keyof T]: JsonSchemaAnyBuilder<T[K]>;
-}): JsonSchemaObjectBuilder<T>;
-export {};