@tstdl/base 0.92.122 → 0.92.124

package/types/schema/schema.d.ts

@@ -0,0 +1,99 @@
+import type { IsEqual, Or } from 'type-fest';
+import { JsonPath } from '../../json-path/json-path.js';
+import type { AbstractConstructor } from '../../types.js';
+import type { SchemaError } from './schema.error.js';
+import type { Coercible, Maskable } from './types.js';
+export type SchemaTestOptions = Coercible & Maskable & {
+    /**
+     * Use fast errors which can improve performance a lot but misses detailed stack traces.
+     */
+    fastErrors?: boolean;
+};
+export type SchemaTestResult<T> = {
+    valid: true;
+    value: T;
+    error?: undefined;
+} | {
+    valid: false;
+    value?: undefined;
+    error: SchemaError;
+};
+type NormalizePrimitiveToConstructor<T> = Or<IsEqual<T, string>, IsEqual<T, String>> extends true ? typeof String : Or<IsEqual<T, number>, IsEqual<T, Number>> extends true ? typeof Number : Or<IsEqual<T, boolean>, IsEqual<T, Boolean>> extends true ? typeof Boolean : Or<IsEqual<T, bigint>, IsEqual<T, BigInt>> extends true ? typeof BigInt : Or<IsEqual<T, symbol>, IsEqual<T, Symbol>> extends true ? typeof Symbol : never;
+export type SchemaTestable<T = any> = Schema<T> | AbstractConstructor<T> | NormalizePrimitiveToConstructor<T>;
+export type SchemaOutput<T extends SchemaTestable> = T extends SchemaTestable<infer U> ? U : never;
+export declare const OPTIONAL: unique symbol;
+export type SchemaOptions<_T> = {
+    description?: string | null;
+    example?: any;
+};
+export declare abstract class Schema<T = unknown> {
+    readonly [OPTIONAL]: boolean;
+    readonly description: string | null;
+    readonly example: T | undefined;
+    abstract readonly name: string;
+    constructor(options?: SchemaOptions<T>);
+    /**
+     * Test an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to test against
+     * @param value value to test
+     * @param options validation options
+     * @returns test result
+     */
+    static readonly test: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => SchemaTestResult<T>;
+    /**
+     * Validate an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result
+     */
+    static readonly validate: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => boolean;
+    /**
+     * Asserts an unknown value to be valid according to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     */
+    static readonly assert: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => asserts value is T;
+    /**
+     * Parse an unknown value to comply with the scheme.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result
+     */
+    static readonly parse: <T>(schema: SchemaTestable<T>, value: unknown, options?: SchemaTestOptions) => T;
+    /**
+     * Test an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to test against
+     * @param value value to test
+     * @param options validation options
+     * @returns test result with either the value or validation error
+     */
+    test(value: any, options?: SchemaTestOptions): SchemaTestResult<T>;
+    /**
+     * Validate an unknown value to see whether it corresponds to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     * @returns validation result. Throws if validation fails
+     */
+    validate(value: any, options?: SchemaTestOptions): boolean;
+    /**
+     * Asserts an unknown value to be valid according to the schema.
+     * @param schema schema to validate against
+     * @param value value to validate
+     * @param options validation options
+     */
+    assert(value: any, options?: SchemaTestOptions): asserts value is T;
+    /**
+     * Parse an unknown value to comply with the scheme.
+     * @param schema schema to parse against
+     * @param value value to parse
+     * @param options validation options
+     * @returns parsed value
+     */
+    parse(value: any, options?: SchemaTestOptions): T;
+    abstract _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export {};

package/types/schema/schema.error.d.ts

@@ -0,0 +1,25 @@
+import { CustomError, type CustomErrorOptions } from '../../errors/custom.error.js';
+import type { JsonPath } from '../../json-path/index.js';
+import type { AbstractConstructor, OneOrMany, TypedOmit, UndefinableJson } from '../../types.js';
+import type { ErrorExtraInfo } from '../../utils/format-error.js';
+export type SchemaErrorOptions = Pick<CustomErrorOptions, 'fast'> & {
+    path: string | JsonPath;
+    details?: UndefinableJson;
+    inner?: OneOrMany<SchemaError>;
+    cause?: any;
+};
+export declare class SchemaError extends CustomError implements ErrorExtraInfo {
+    static readonly errorName = "SchemaError";
+    readonly path: string;
+    readonly details?: UndefinableJson;
+    readonly inner?: OneOrMany<SchemaError>;
+    readonly innerMessages?: string[];
+    constructor(message: string, options: SchemaErrorOptions, cause?: any);
+    static expectedButGot(expected: OneOrMany<string | AbstractConstructor>, got: string, path: string | JsonPath, options?: TypedOmit<SchemaErrorOptions, 'path'> & {
+        customMessage?: string;
+    }): SchemaError;
+    static couldNotCoerce(expected: OneOrMany<string | AbstractConstructor>, got: string, path: string | JsonPath, options: TypedOmit<SchemaErrorOptions, 'path'> & {
+        customMessage?: string;
+    }): SchemaError;
+    getExtraInfo(includeMessage?: boolean): UndefinableJson | undefined;
+}

package/types/schema/schemas/array.d.ts

@@ -0,0 +1,20 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { TypedOmit } from '../../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { Coercible } from '../types.js';
+export type ArraySchemaOptions<T> = SchemaOptions<T[]> & Coercible & {
+    minimum?: number;
+    maximum?: number;
+};
+export declare class ArraySchema<T> extends Schema<T[]> {
+    #private;
+    readonly name: string;
+    readonly itemSchema: Schema<T>;
+    readonly minimum: number | null;
+    readonly maximum: number | null;
+    constructor(itemSchema: SchemaTestable<T>, options?: ArraySchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T[]>;
+}
+export declare function array<T>(schema: SchemaTestable<T>, options?: ArraySchemaOptions<T>): ArraySchema<T>;
+export declare function Array(schema: SchemaTestable, options?: ArraySchemaOptions<unknown> & TypedOmit<SchemaDecoratorOptions, 'array'>): SchemaPropertyDecorator;

package/types/schema/schemas/defaulted.d.ts

@@ -0,0 +1,13 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type DefaultSchemaOptions<T, D> = SchemaOptions<T | D>;
+export declare class DefaultSchema<T, D> extends Schema<T | D> {
+    readonly name: string;
+    readonly schema: Schema<T>;
+    readonly defaultValue: D;
+    constructor(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | D>;
+}
+export declare function defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D>): DefaultSchema<T, D>;
+export declare function Defaulted<T, D>(schema: SchemaTestable<T>, defaultValue: D, options?: DefaultSchemaOptions<T, D> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/deferred.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class DeferredSchema<T extends SchemaTestable> extends Schema<SchemaOutput<T>> {
+    readonly name: string;
+    readonly testable: T;
+    readonly schema: Schema<SchemaOutput<T>>;
+    constructor(schema: () => T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<SchemaOutput<T>>;
+}
+export declare function deferred<T extends SchemaTestable>(schema: () => T): DeferredSchema<T>;
+export declare function Deferred(schema: () => SchemaTestable, options?: SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/enumeration.d.ts

@@ -0,0 +1,13 @@
+import type { Enumeration as EnumerationType, EnumerationValue } from '../../../types.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type EnumerationSchemaOptions<T extends EnumerationType> = SimpleSchemaOptions<EnumerationValue<T>>;
+export declare class EnumerationSchema<const T extends EnumerationType> extends SimpleSchema<EnumerationValue<T>> {
+    #private;
+    readonly name: string;
+    readonly enumeration: EnumerationType;
+    readonly allowedValues: readonly EnumerationValue<T>[];
+    constructor(enumeration: T, options?: EnumerationSchemaOptions<T>);
+}
+export declare function enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T>): EnumerationSchema<T>;
+export declare function Enumeration<const T extends EnumerationType>(enumeration: T, options?: EnumerationSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/function.d.ts

@@ -0,0 +1,23 @@
+import type { AbstractConstructor, Function } from '../../../types.js';
+import { type CombinedSchemaDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import type { Schema, SchemaTestable } from '../schema.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type FunctionSchemaOptions<T extends Function> = SimpleSchemaOptions<T> & {
+    parameterNames?: (string | null)[];
+};
+type MappedParameters<T> = {
+    [I in keyof T]: SchemaTestable<T[I]>;
+};
+export declare class FunctionSchema<T extends (...args: any[]) => any> extends SimpleSchema<T> {
+    readonly name = "function";
+    readonly parameterSchemas: MappedParameters<Parameters<T>> | null;
+    readonly parameterNames: (string | null)[];
+    readonly returnValueSchema: SchemaTestable<ReturnType<T>> | null;
+    constructor(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>);
+}
+export declare function func<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T>): FunctionSchema<T>;
+export declare function Method<T extends (...args: any[]) => any>(options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
+export declare function Method<T extends (...args: any[]) => any>(parameterSchemas: MappedParameters<Parameters<T>> | null, returnValueSchema: SchemaTestable<ReturnType<T>> | null, options?: FunctionSchemaOptions<T> & SchemaDecoratorOptions): CombinedSchemaDecorator;
+export declare function getFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any>;
+export declare function tryGetFunctionSchemaFromReflection(type: AbstractConstructor, method: string | symbol): Schema<Function> | FunctionSchema<(...args: any[]) => any> | null;
+export {};

package/types/schema/schemas/instance.d.ts

@@ -0,0 +1,13 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { AbstractConstructor } from '../../../types.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type InstanceSchemaOptions<T extends AbstractConstructor> = SchemaOptions<InstanceType<T>>;
+export declare class InstanceSchema<T extends AbstractConstructor> extends Schema<InstanceType<T>> {
+    readonly name: string;
+    readonly type: T;
+    constructor(type: T, options?: InstanceSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<InstanceType<T>>;
+}
+export declare function instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T>): InstanceSchema<T>;
+export declare function Instance<T extends AbstractConstructor>(type: T, options?: InstanceSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/literal.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type LiteralSchemaOptions<T> = SchemaOptions<T>;
+export declare class LiteralSchema<const T> extends Schema<T> {
+    readonly name: string;
+    readonly value: T;
+    constructor(value: T, options?: LiteralSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function literal<const T>(value: T, options?: LiteralSchemaOptions<T>): LiteralSchema<T>;
+export declare function Literal<const T>(value: T, options?: LiteralSchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/never.d.ts

@@ -0,0 +1,8 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type NeverSchemaOptions = SchemaOptions<never>;
+export declare class NeverSchema extends Schema<never> {
+    readonly name = "never";
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<never>;
+}
+export declare function never(options?: NeverSchemaOptions): NeverSchema;

package/types/schema/schemas/nullable.d.ts

@@ -0,0 +1,12 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { TypedOmit } from '../../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class NullableSchema<T> extends Schema<T | null> {
+    readonly name: string;
+    readonly schema: Schema<T>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | null>;
+}
+export declare function nullable<T>(schema: SchemaTestable<T>): NullableSchema<T>;
+export declare function Nullable<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'nullable'>): SchemaPropertyDecorator;

package/types/schema/schemas/number.d.ts

@@ -0,0 +1,19 @@
+import type { TypedOmit } from '../../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { SimpleSchema, type SimpleSchemaOptions } from './simple.js';
+export type NumberSchemaOptions = SimpleSchemaOptions<number> & {
+    integer?: boolean;
+    minimum?: number;
+    maximum?: number;
+};
+export declare class NumberSchema extends SimpleSchema<number> {
+    readonly name: string;
+    readonly integer: boolean;
+    readonly minimum: number | null;
+    readonly maximum: number | null;
+    constructor(options?: NumberSchemaOptions);
+}
+export declare function number(options?: NumberSchemaOptions): NumberSchema;
+export declare function integer(options?: TypedOmit<NumberSchemaOptions, 'integer'>): NumberSchema;
+export declare function NumberProperty(options?: SchemaDecoratorOptions & NumberSchemaOptions): SchemaPropertyDecorator;
+export declare function Integer(options?: SchemaDecoratorOptions & TypedOmit<NumberSchemaOptions, 'integer'>): SchemaPropertyDecorator;

package/types/schema/schemas/object.d.ts

@@ -0,0 +1,91 @@
+import type { EmptyObject, Merge } from 'type-fest';
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { type Decorator } from '../../../reflection/index.js';
+import type { AbstractConstructor, OneOrMany, PartialProperty, Record as RecordType, SimplifyObject, Type, TypedOmit } from '../../../types.js';
+import { type SchemaDecoratorOptions } from '../decorators/index.js';
+import { type OPTIONAL, Schema, type SchemaOptions, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export type Record<K extends PropertyKey = PropertyKey, V = any> = RecordType<K, V>;
+export type ObjectSchemaFactoryFunction<T> = (data: T) => T;
+export type ObjectSchemaFactory<T> = {
+    type: Type<T>;
+} | ObjectSchemaFactoryFunction<T>;
+export type ObjectSchemaProperties<T extends Record = Record> = {
+    [P in keyof T]-?: SchemaTestable<T[P]>;
+};
+export type NormalizedObjectSchemaProperties<T extends Record> = {
+    [P in keyof T]-?: Schema<T[P]>;
+};
+export type ObjectSchemaOptions<T extends Record = Record, K extends PropertyKey = PropertyKey, V = unknown> = SchemaOptions<T> & {
+    name?: string;
+    mask?: boolean | null;
+    unknownPropertiesKey?: SchemaTestable<K> | null;
+    unknownProperties?: SchemaTestable<V> | null;
+    factory?: ObjectSchemaFactory<T> | null;
+};
+export type ObjectSchemaOrType<T extends Record = any> = ObjectSchema<T> | AbstractConstructor<T>;
+export type OptionalProperties<T> = {
+    [P in keyof T]: T[P] extends {
+        [OPTIONAL]: true;
+    } ? P : never;
+}[keyof T];
+export type ObjectSchemaPropertiesType<TP extends ObjectSchemaProperties> = SimplifyObject<{
+    -readonly [P in keyof PartialProperty<TP, OptionalProperties<TP>>]: SchemaOutput<TP[P]>;
+}>;
+export declare const tryGetSchemaFromReflection: typeof _tryGetSchemaFromReflection;
+export declare class ObjectSchema<T extends Record = Record> extends Schema<T> {
+    private readonly propertyKeys;
+    private readonly allowUnknownProperties;
+    readonly name: string;
+    readonly properties: NormalizedObjectSchemaProperties<T>;
+    readonly mask: boolean | null;
+    readonly unknownProperties: Schema | null;
+    readonly unknownPropertiesKey: Schema<PropertyKey> | null;
+    readonly factory: ObjectSchemaFactory<T> | null;
+    constructor(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export declare function object<const K extends PropertyKey, const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Partial<Record<K, V>>>;
+export declare function object<const K extends PropertyKey>(properties: Record<never>, options: ObjectSchemaOptions<Record<K, unknown>> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<Partial<Record<K, unknown>>>;
+export declare function object<const V>(properties: Record<never>, options: ObjectSchemaOptions<Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<Partial<Record<PropertyKey, V>>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, V>> & {
+    unknownProperties: SchemaTestable<V>;
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<K, unknown>> & {
+    unknownPropertiesKey: SchemaTestable<K>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, unknown>>>;
+export declare function object<const TP extends ObjectSchemaProperties, const V>(properties: TP, options: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP> & Record<PropertyKey, V>> & {
+    unknownProperties: SchemaTestable<V>;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<PropertyKey, V>>>;
+export declare function object<const TP extends ObjectSchemaProperties>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>> & {
+    unknownProperties?: undefined;
+    unknownPropertiesKey?: undefined;
+}): ObjectSchema<ObjectSchemaPropertiesType<TP>>;
+export declare function object<const TP extends ObjectSchemaProperties, const K extends PropertyKey, const V>(properties: TP, options?: ObjectSchemaOptions<ObjectSchemaPropertiesType<TP>, K, V>): ObjectSchema<ObjectSchemaPropertiesType<TP> & Partial<Record<K, V>>>;
+export declare function explicitObject<const T extends Record>(properties: ObjectSchemaProperties<T>, options?: ObjectSchemaOptions<T>): ObjectSchema<T>;
+export declare function record<const K extends PropertyKey, const V>(keys: K[], value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Record<K, V>>;
+export declare function record<const K extends PropertyKey, const V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'>): ObjectSchema<Partial<Record<K, V>>>;
+export declare function assign<const T1 extends Record, const T2 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>): ObjectSchema<Merge<T1, T2>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>): ObjectSchema<Merge<Merge<T1, T2>, T3>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>): ObjectSchema<Merge<Merge<Merge<T1, T2>, T3>, T4>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>): ObjectSchema<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>>;
+export declare function assign<const T1 extends Record, const T2 extends Record, const T3 extends Record, const T4 extends Record, const T5 extends Record, const T6 extends Record>(a: ObjectSchemaOrType<T1>, b: ObjectSchemaOrType<T2>, c: ObjectSchemaOrType<T3>, d: ObjectSchemaOrType<T4>, e: ObjectSchemaOrType<T5>, f: ObjectSchemaOrType<T6>): ObjectSchema<Merge<Merge<Merge<Merge<Merge<T1, T2>, T3>, T4>, T5>, T6>>;
+export declare function partial<const T extends Record>(schema: ObjectSchemaOrType<T>): ObjectSchema<Partial<T>>;
+export declare function partial<const T extends Record, const K extends keyof T>(schema: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<PartialProperty<T, K>>;
+export declare function pick<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Pick<T, K>>>;
+export declare function omit<const T extends Record, const K extends keyof T>(schemaOrType: ObjectSchemaOrType<T>, keys: OneOrMany<K>): ObjectSchema<SimplifyObject<Omit<T, K>>>;
+export declare function getSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T>;
+declare function _tryGetSchemaFromReflection<T extends Record>(type: AbstractConstructor<T>): Schema<T> | ObjectSchema<T> | null;
+export declare function getObjectSchema<T extends Record>(schemaOrType: SchemaTestable<T>): ObjectSchema<T>;
+export declare function Record<K extends PropertyKey, V>(key: SchemaTestable<K>, value: SchemaTestable<V>, options?: TypedOmit<ObjectSchemaOptions<Record<K, V>>, 'unknownProperties' | 'unknownPropertiesKey'> & SchemaDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;
+export declare const emptyObjectSchema: ObjectSchema<EmptyObject>;
+export {};

package/types/schema/schemas/one-or-many.d.ts

@@ -0,0 +1,15 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { OneOrMany as OneOrManyType } from '../../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { Schema, type SchemaOptions, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import { type ArraySchemaOptions } from './array.js';
+export type OneOrManySchemaOptions<T> = SchemaOptions<T | T[]> & Pick<ArraySchemaOptions<T>, 'minimum' | 'maximum'>;
+export type OneOrMany<T> = OneOrManyType<T>;
+export declare class OneOrManySchema<T> extends Schema<T | T[]> {
+    readonly name: string;
+    readonly schema: Schema<T | T[]>;
+    constructor(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | T[]>;
+}
+export declare function oneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T>): OneOrManySchema<T>;
+export declare function OneOrMany<T>(schema: SchemaTestable<T>, options?: OneOrManySchemaOptions<T> & SchemaDecoratorOptions): SchemaPropertyDecorator;

package/types/schema/schemas/optional.d.ts

@@ -0,0 +1,13 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { TypedOmit } from '../../../types.js';
+import { type SchemaDecoratorOptions, type SchemaPropertyDecorator } from '../decorators/index.js';
+import { type OPTIONAL, Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class OptionalSchema<T> extends Schema<T | undefined> {
+    readonly name: string;
+    readonly [OPTIONAL]: true;
+    readonly schema: Schema<T>;
+    constructor(schema: SchemaTestable<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T | undefined>;
+}
+export declare function optional<T>(schema: SchemaTestable<T>): OptionalSchema<T>;
+export declare function Optional<T>(schema?: SchemaTestable<T>, options?: TypedOmit<SchemaDecoratorOptions, 'optional'>): SchemaPropertyDecorator;

package/types/schema/schemas/simple.d.ts

@@ -0,0 +1,27 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import type { AbstractConstructor, OneOrMany } from '../../../types.js';
+import { Schema, type SchemaOptions, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+import type { CoerceResult, Coercible, ConstraintResult } from '../types.js';
+export type SimpleSchemaOptions<T> = SchemaOptions<T> & Coercible;
+type SimpleSchemaRefinements<T> = {
+    coercers?: SimpleSchemaCoercers<T>;
+    constraints?: (SimpleSchemaConstraint<T> | null)[];
+    gotValueFormatter?: SimpleSchemaGotValueFormatter;
+};
+export type SimpleSchemaCoercers<T> = {
+    string?: (value: string, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    number?: (value: number, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    boolean?: (value: boolean, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    bigint?: (value: bigint, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    undefined?: (value: undefined, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    null?: (value: null, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+    all?: (value: unknown, path: JsonPath, options: SchemaTestOptions) => CoerceResult<T>;
+};
+export type SimpleSchemaConstraint<T> = (value: T) => ConstraintResult;
+export type SimpleSchemaGotValueFormatter = (value: unknown) => string;
+export declare abstract class SimpleSchema<T> extends Schema<T> {
+    #private;
+    constructor(expected: OneOrMany<string | AbstractConstructor>, guardFn: (value: any) => value is T, options?: SimpleSchemaOptions<T>, refinements?: SimpleSchemaRefinements<T>);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<T>;
+}
+export {};

package/types/schema/schemas/transform.d.ts

@@ -0,0 +1,10 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { Schema, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+export declare class TransformSchema<I, O> extends Schema<O> {
+    readonly name: string;
+    readonly schema: Schema<I>;
+    readonly transformFn: (value: I) => O;
+    constructor(schema: SchemaTestable<I>, transformFn: (value: I) => O);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<O>;
+}
+export declare function transform<I, O>(schema: Schema<I>, transformFn: (value: I) => O): TransformSchema<I, O>;

package/types/schema/schemas/union.d.ts

@@ -0,0 +1,15 @@
+import type { JsonPath } from '../../../json-path/json-path.js';
+import { type SchemaPropertyDecorator, type SchemaDecoratorOptions } from '../decorators/index.js';
+import { Schema, type SchemaOutput, type SchemaTestable, type SchemaTestOptions, type SchemaTestResult } from '../schema.js';
+type UnionSchemaType<T extends [SchemaTestable, ...SchemaTestable[]]> = T[number] extends SchemaTestable<infer V> ? V : never;
+export declare class UnionSchema<T extends [SchemaTestable, ...SchemaTestable[]]> extends Schema<UnionSchemaType<T>> {
+    readonly name: string;
+    readonly schemas: {
+        [P in keyof T]: T[P] extends Schema ? T[P] : Schema<SchemaOutput<T[P]>>;
+    };
+    constructor(schemas: T);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<UnionSchemaType<T>>;
+}
+export declare function union<T extends [SchemaTestable, ...SchemaTestable[]]>(...schemas: T): UnionSchema<T>;
+export declare function Union(...schemasAndOptions: [SchemaTestable, ...SchemaTestable[]] | [SchemaTestable, ...SchemaTestable[], options: SchemaDecoratorOptions]): SchemaPropertyDecorator;
+export {};

package/types/search-index/elastic/config.d.ts

@@ -0,0 +1,8 @@
+import type { Entity } from '../../../database/index.js';
+import type { Resolvable, resolveArgumentType } from '../../../injector/interfaces.js';
+export type ElasticSearchIndexConfigArgument<T extends Entity = Entity> = string | ElasticSearchIndexConfig<T>;
+export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Resolvable<ElasticSearchIndexConfigArgument> {
+    readonly indexName: string;
+    readonly [resolveArgumentType]: ElasticSearchIndexConfigArgument<T>;
+    constructor(indexNameOrConfig: string | ElasticSearchIndexConfig<T>);
+}

package/types/search-index/elastic/model/index-mapping.d.ts

@@ -0,0 +1,26 @@
+import type { estypes } from '@elastic/elasticsearch';
+import type { Entity } from '../../../../database/index.js';
+import type { DeepFlatten, StringMap, TypedOmit } from '../../../../types.js';
+export type ElasticIndexMapping<T extends Entity = Entity> = TypedOmit<estypes.MappingTypeMapping, 'properties'> & ElasticNestedIndexMapping<TypedOmit<T, 'id'>>;
+export type ElasticNestedIndexMapping<T> = {
+    properties: {
+        [P in keyof Required<T>]: ElasticIndexMappingItem<DeepFlatten<Required<T>[P]>>;
+    };
+};
+type StrippedBaseType<T extends estypes.MappingPropertyBase> = TypedOmit<T, 'properties' | 'fields'>;
+type ElasticIndexMappingItemBase = {
+    index?: boolean;
+    fields?: StringMap<ElasticIndexMappingItem>;
+};
+export type MappingNumberProperty = estypes.MappingByteNumberProperty | estypes.MappingDoubleNumberProperty | estypes.MappingFloatNumberProperty | estypes.MappingHalfFloatNumberProperty | estypes.MappingIntegerNumberProperty | estypes.MappingLongNumberProperty | estypes.MappingShortNumberProperty | estypes.MappingScaledFloatNumberProperty | estypes.MappingUnsignedLongNumberProperty;
+export type ElasticKeywordIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingKeywordProperty>;
+export type ElasticTextIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingTextProperty>;
+export type ElasticNumberIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<MappingNumberProperty>;
+export type ElasticBooleanIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingBooleanProperty>;
+export type ElasticDateIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingDateProperty>;
+export type ElasticGeoPointIndexMappingItem = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingGeoPointProperty>;
+export type ElasticObjectIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingObjectProperty> & ElasticNestedIndexMapping<T>;
+export type ElasticNestedIndexMappingItem<T> = ElasticIndexMappingItemBase & StrippedBaseType<estypes.MappingNestedProperty> & ElasticNestedIndexMapping<T>;
+export type ElasticIndexMappingItem<T = any> = ElasticKeywordIndexMappingItem | ElasticTextIndexMappingItem | ElasticNumberIndexMappingItem | ElasticBooleanIndexMappingItem | ElasticDateIndexMappingItem | ElasticGeoPointIndexMappingItem | ElasticObjectIndexMappingItem<T> | ElasticNestedIndexMappingItem<T>;
+export declare function mergeElasticSearchMappings<T extends Entity>(mappings: ElasticIndexMapping<T>[]): ElasticIndexMapping<T>;
+export {};

package/types/search-index/elastic/model/sort.d.ts

@@ -0,0 +1,8 @@
+import type { Entity } from '../../../../database/index.js';
+import type { estypes } from '@elastic/elasticsearch';
+export type SortOrder = estypes.SortOrder;
+export type Sort<T extends Entity = Entity> = SortCombinations<T> | SortCombinations<T>[];
+export type SortCombinations<T extends Entity = Entity> = keyof T | SortOptions<T>;
+export type SortOptions<T extends Entity = Entity> = estypes.SortOptionsKeys & {
+    [P in keyof T]?: estypes.SortOptions[string];
+};

package/types/search-index/elastic/module.d.ts

@@ -0,0 +1,10 @@
+import type { ClientOptions } from '@elastic/elasticsearch';
+import type { ElasticSearchIndexConfigArgument } from './config.js';
+import { ElasticSearchIndexConfig } from './config.js';
+export type ElasticsearchModuleConfig = {
+    defaultOptions: ClientOptions;
+    logPrefix: string;
+};
+export declare const elasticsearchModuleConfig: ElasticsearchModuleConfig;
+export declare const ELASTIC_SEARCH_INDEX_CONFIG: import("../../../injector/token.js").InjectionToken<ElasticSearchIndexConfig<import("../../database/entity.js").Entity>, ElasticSearchIndexConfigArgument>;
+export declare function configureElasticsearch(config?: Partial<ElasticsearchModuleConfig>): void;

package/types/search-index/elastic/query-converter.d.ts

@@ -0,0 +1,9 @@
+import type { Entity } from '../../../database/index.js';
+import type { LogicalAndQuery, LogicalNorQuery, LogicalOrQuery, Query, TextSpanQueryMode } from '../../../database/query.js';
+import type { estypes } from '@elastic/elasticsearch';
+import type { ElasticQuery } from './model/index.js';
+export declare function convertQuery<T extends Entity>(query: Query<T>): ElasticQuery;
+export declare function convertLogicalAndQuery<T extends Entity>(andQuery: LogicalAndQuery<T>['$and']): ElasticQuery;
+export declare function convertLogicalOrQuery<T extends Entity>(orQuery: LogicalOrQuery<T>['$or']): ElasticQuery;
+export declare function convertLogicalNorQuery<T extends Entity>(norQuery: LogicalNorQuery<T>['$nor']): ElasticQuery;
+export declare function convertTextSpanQueryMode(mode: TextSpanQueryMode | undefined): estypes.QueryDslTextQueryType | undefined;

package/types/search-index/elastic/search-index.d.ts

@@ -0,0 +1,30 @@
+import type { Client, estypes } from '@elastic/elasticsearch';
+import type { Entity, Query, QueryOptions } from '../../../database/index.js';
+import type { AfterResolve } from '../../../injector/interfaces.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import type { Logger } from '../../../logger/index.js';
+import type { SearchResult } from '../../../search-index/index.js';
+import { SearchIndex } from '../../../search-index/index.js';
+import type { ElasticSearchIndexConfig } from './config.js';
+import { KeywordRewriter } from './keyword-rewriter.js';
+import type { ElasticIndexMapping } from './model/index.js';
+export declare class ElasticSearchIndex<T extends Entity> extends SearchIndex<T> implements AfterResolve {
+    private readonly logger;
+    readonly client: Client;
+    readonly indexName: string;
+    readonly indexSettings: estypes.IndicesIndexSettings;
+    readonly indexMapping: ElasticIndexMapping<T>;
+    readonly keywordRewriter: KeywordRewriter;
+    constructor(client: Client, config: ElasticSearchIndexConfig<T>, indexSettings: estypes.IndicesIndexSettings, indexMapping: ElasticIndexMapping<T>, keywordRewrites: Iterable<string>, logger: Logger);
+    [afterResolve](): Promise<void>;
+    initialize(): Promise<void>;
+    refresh(): Promise<void>;
+    updateSettings(): Promise<void>;
+    index(entities: T[]): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteByQuery(query: Query<T>): Promise<void>;
+    search(searchQueryOrCursor: Query<T> | string, options?: QueryOptions<T>): Promise<SearchResult<T>>;
+    count(query?: Query<T>, options?: QueryOptions<T>): Promise<number>;
+    drop(): Promise<void>;
+    exists(): Promise<boolean>;
+}

package/types/search-index/elastic/sort-converter.d.ts

@@ -0,0 +1,4 @@
+import type { Entity, Sort } from '../../../database/index.js';
+import type { KeywordRewriter } from './keyword-rewriter.js';
+import type { SortCombinations } from './model/index.js';
+export declare function convertSort<T extends Entity>(sort: Sort<T>, keywordRewriter: KeywordRewriter): SortCombinations<T>;

package/types/search-index/error.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from '../../errors/custom.error.js';
+export declare class SearchIndexError extends CustomError {
+    static readonly errorName = "SearchIndexError";
+    readonly type: string;
+    readonly raw: unknown;
+    constructor(type: string, message: string, { raw, cause }?: {
+        raw?: unknown;
+        cause?: Error;
+    });
+}

package/types/search-index/memory/memory-search-index.d.ts

@@ -0,0 +1,19 @@
+import type { Entity, Query, QueryOptions } from '../../../database/index.js';
+import { SearchIndex } from '../search-index.js';
+import type { SearchResult } from '../search-result.js';
+export declare class MemorySearchIndex<T extends Entity> extends SearchIndex<T> {
+    private readonly indexedFields;
+    private readonly allSet;
+    private readonly idMap;
+    private readonly indexMap;
+    constructor(indexedFields: (keyof T)[]);
+    index(entities: T[]): Promise<void>;
+    delete(id: string): Promise<void>;
+    deleteByQuery(query: Query<T>): Promise<void>;
+    search(queryOrCursor: string | Query<T>, options?: QueryOptions<T>): Promise<SearchResult<T>>;
+    count(query?: Query<T>, options?: QueryOptions<T> | undefined): Promise<number>;
+    drop(): Promise<void>;
+    private _delete;
+    private indexEntity;
+    private deleteEntity;
+}