@tstdl/base 0.92.124 → 0.92.126

package/reflection/registry.d.ts

@@ -0,0 +1,61 @@
+import type { AbstractConstructor } from '../types.js';
+import { ContextDataMap } from '../data-structures/context-data-map.js';
+import type { DecoratorData } from './types.js';
+export type ReflectionMetadata = TypeMetadata | PropertyMetadata | MethodMetadata | ConstructorParameterMetadata | MethodParameterMetadata;
+export type MetadataType = 'type' | 'property' | 'method' | 'method-parameter' | 'constructor-parameter';
+export type MetadataBase<T extends MetadataType> = {
+    metadataType: T;
+};
+export type TypeMetadata = MetadataBase<'type'> & {
+    readonly constructor: AbstractConstructor;
+    readonly parent: AbstractConstructor | null;
+    /** Undefined if class has no constructor */
+    readonly parameters: ConstructorParameterMetadata[] | undefined;
+    readonly properties: ReadonlyMap<string | symbol, PropertyMetadata>;
+    readonly staticProperties: ReadonlyMap<string | symbol, PropertyMetadata>;
+    readonly methods: ReadonlyMap<string | symbol, MethodMetadata>;
+    readonly staticMethods: ReadonlyMap<string | symbol, MethodMetadata>;
+    readonly data: ContextDataMap;
+};
+export type PropertyMetadata = MetadataBase<'property'> & {
+    key: string | symbol;
+    type: AbstractConstructor;
+    isAccessor: boolean;
+    data: ContextDataMap;
+    inherited: boolean;
+};
+export type MethodMetadata = MetadataBase<'method'> & {
+    parameters: MethodParameterMetadata[];
+    returnType: AbstractConstructor | undefined;
+    data: ContextDataMap;
+    inherited: boolean;
+};
+export type ConstructorParameterMetadata = MetadataBase<'constructor-parameter'> & {
+    type: AbstractConstructor | undefined;
+    index: number;
+    data: ContextDataMap;
+};
+export type MethodParameterMetadata = MetadataBase<'method-parameter'> & {
+    type: AbstractConstructor;
+    index: number;
+    data: ContextDataMap;
+};
+export type ParameterMetadata = ConstructorParameterMetadata | MethodParameterMetadata;
+export declare class ReflectionRegistry {
+    #private;
+    private readonly metadataMap;
+    private readonly finalizedTypesSet;
+    constructor();
+    hasType(type: AbstractConstructor): boolean;
+    getMetadata(type: AbstractConstructor): TypeMetadata | undefined;
+    register(target: object, propertyKey?: string | symbol, descriptorOrParameterIndex?: PropertyDescriptor | number): DecoratorData;
+    registerDecoratorData(data: DecoratorData): ReflectionMetadata;
+    /**
+     * Unregister a type. Can be useful if you replace a class with an decorator.
+     * However, this should not be necessary since WeakRefs are used.
+     * @param type Type to unregister
+     */
+    unregister(type: AbstractConstructor): void;
+    getOrInitializeMetadata(type: AbstractConstructor): TypeMetadata;
+}
+export declare const reflectionRegistry: ReflectionRegistry;

package/reflection/types.d.ts

@@ -0,0 +1,90 @@
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, Record } from '../types.js';
+import type { UnionToIntersection } from 'type-fest';
+import type { ConstructorParameterMetadata, MethodMetadata, MethodParameterMetadata, ParameterMetadata, PropertyMetadata, TypeMetadata } from './registry.js';
+export type DecoratorType = 'class' | 'property' | 'accessor' | 'method' | 'parameter' | 'methodParameter' | 'constructorParameter';
+export type DecoratorHandler<T extends DecoratorType = DecoratorType> = (data: DecoratorData<T>, metadata: DecoratorMetadata<T>, originalArguments: Parameters<DecoratorUnion<T>>) => DecoratorHandlerReturnType<T>;
+export type DecoratorHandlerReturnType<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorHandlerReturnTypeMap, T>;
+export type Decorator<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMapIntersection<DecoratorMap, T>;
+export type DecoratorUnion<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorMap, T>;
+export type DecoratorData<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorDataMap, T>;
+export type DecoratorMetadata<T extends DecoratorType = DecoratorType> = DecoratorOptionsTypeMap<DecoratorMetadataMap, T>;
+export type CombinedDecoratorParameters = [target: object, propertyKey?: string | symbol, descriptorOrParameterIndex?: PropertyDescriptor | number];
+export type DecoratorTypeMap<T extends Record<DecoratorType> = Record<DecoratorType>> = T;
+export type DecoratorOptionsTypeMap<T extends DecoratorTypeMap, U extends DecoratorType> = {
+    [D in U]: T[D];
+}[U];
+export type DecoratorOptionsTypeMapIntersection<T extends DecoratorTypeMap, U extends DecoratorType> = UnionToIntersection<DecoratorOptionsTypeMap<T, U>>;
+export type DecoratorDataMap = DecoratorTypeMap<{
+    class: ClassDecoratorData;
+    property: PropertyDecoratorData;
+    accessor: AccessorDecoratorData;
+    method: MethodDecoratorData;
+    parameter: ParameterDecoratorData;
+    methodParameter: MethodParameterDecoratorData;
+    constructorParameter: ConstructorParameterDecoratorData;
+}>;
+export type DecoratorMetadataMap = DecoratorTypeMap<{
+    class: TypeMetadata;
+    property: PropertyMetadata;
+    accessor: PropertyMetadata;
+    method: MethodMetadata;
+    parameter: ParameterMetadata;
+    methodParameter: MethodParameterMetadata;
+    constructorParameter: ConstructorParameterMetadata;
+}>;
+export type DecoratorHandlerReturnTypeMap = DecoratorTypeMap<{
+    class: void | undefined | Constructor;
+    property: void;
+    accessor: void | undefined | TypedPropertyDescriptor<any>;
+    method: void | undefined | PropertyDescriptor;
+    parameter: void;
+    methodParameter: void;
+    constructorParameter: void;
+}>;
+export type DecoratorMap = DecoratorTypeMap<{
+    class: ClassDecorator;
+    property: PropertyDecorator;
+    accessor: MethodDecorator;
+    method: MethodDecorator;
+    parameter: ParameterDecorator & ConstructorParameterDecorator;
+    methodParameter: ParameterDecorator;
+    constructorParameter: ConstructorParameterDecorator;
+}>;
+export type DecoratorDataBase<Type extends string> = {
+    type: Type;
+    constructor: AbstractConstructor;
+    prototype: object;
+};
+export type ClassDecoratorData = DecoratorDataBase<'class'>;
+export type PropertyDecoratorData = DecoratorDataBase<'property'> & {
+    static: boolean;
+    propertyKey: string | symbol;
+};
+export type AccessorDecoratorData = DecoratorDataBase<'accessor'> & {
+    static: boolean;
+    propertyKey: string | symbol;
+    descriptor: PropertyDescriptor;
+};
+export type PropertyOrAccessorDecoratorData = PropertyDecoratorData | AccessorDecoratorData;
+export type MethodDecoratorData = DecoratorDataBase<'method'> & {
+    static: boolean;
+    methodKey: string | symbol;
+    descriptor: PropertyDescriptor;
+};
+export type MethodParameterDecoratorData = DecoratorDataBase<'method-parameter'> & {
+    static: boolean;
+    methodKey: string | symbol;
+    index: number;
+};
+export type ConstructorParameterDecoratorData = DecoratorDataBase<'constructor-parameter'> & {
+    index: number;
+};
+export type ParameterDecoratorData = MethodParameterDecoratorData | ConstructorParameterDecoratorData;
+export type ClassDecoratorHandler = DecoratorHandler<'class'>;
+export type PropertyDecoratorHandler = DecoratorHandler<'property'>;
+export type AccessorDecoratorHandler = DecoratorHandler<'accessor'>;
+export type PropertyOrAccessorDecoratorHandler = DecoratorHandler<'property' | 'accessor'>;
+export type MethodDecoratorHandler = DecoratorHandler<'method'>;
+export type ParameterDecoratorHandler = DecoratorHandler<'parameter'>;
+export type ConstructorParameterDecoratorHandler = DecoratorHandler<'constructorParameter'>;
+export type MethodParameterDecoratorHandler = DecoratorHandler<'methodParameter'>;

package/reflection/utils.d.ts

@@ -0,0 +1,33 @@
+import type { AbstractConstructor, Constructor, ConstructorParameterDecorator, OneOrMany, PropertiesOfType, Record, TypedOmit } from '../types.js';
+import type { CombinedDecoratorParameters, Decorator, DecoratorData, DecoratorHandler, DecoratorMetadata, DecoratorType, DecoratorUnion } from './types.js';
+export type CreateDecoratorTypeOptions = Partial<Record<DecoratorType, boolean>>;
+export type CreateDecoratorOptions = {
+    data?: Record<string | symbol>;
+    /** Merge data values instead of replacing them (requires them to be objects, arrays, maps or sets) */
+    mergeData?: boolean;
+    /** Return values of these decorators are not used */
+    include?: OneOrMany<DecoratorUnion>;
+};
+export type SpecificCreateDecoratorOptions<T extends DecoratorType> = TypedOmit<CreateDecoratorOptions, 'include'> & {
+    handler?: DecoratorHandler<T>;
+    include?: OneOrMany<DecoratorUnion<T>>;
+};
+export type WrapDecoratorOptions = CreateDecoratorOptions & {
+    handler?: (data: DecoratorData, metadata: DecoratorMetadata, originalArguments: CombinedDecoratorParameters) => void;
+};
+type CreateDecoratorType<T extends CreateDecoratorOptions> = Extract<PropertiesOfType<T, true>, DecoratorType>;
+export declare function createDecorator<T extends CreateDecoratorTypeOptions & CreateDecoratorOptions>(options: T, handler?: DecoratorHandler<CreateDecoratorType<T>>): Decorator<CreateDecoratorType<T>>;
+export declare function createClassDecorator(options?: SpecificCreateDecoratorOptions<'class'>): ClassDecorator;
+export declare function createPropertyDecorator(options?: SpecificCreateDecoratorOptions<'property'>): PropertyDecorator;
+export declare function createAccessorDecorator(options?: SpecificCreateDecoratorOptions<'accessor'>): MethodDecorator;
+export declare function createPropertyOrAccessorDecorator(options?: SpecificCreateDecoratorOptions<'property' | 'accessor'>): Decorator<'property' | 'accessor'>;
+export declare function createMethodDecorator(options?: SpecificCreateDecoratorOptions<'method'>): MethodDecorator;
+export declare function createMethodParameterDecorator(options?: SpecificCreateDecoratorOptions<'methodParameter'>): ParameterDecorator;
+export declare function createConstructorParameterDecorator(options?: SpecificCreateDecoratorOptions<'constructorParameter'>): ConstructorParameterDecorator;
+export declare function createParameterDecorator(options?: SpecificCreateDecoratorOptions<'parameter'>): ParameterDecorator & ConstructorParameterDecorator;
+export declare function wrapDecoratorFactory<T extends (...args: any[]) => DecoratorUnion>(decoratorFactory: T, options?: WrapDecoratorOptions): T;
+export declare function wrapDecorator<T extends DecoratorUnion>(decorator: T, options?: WrapDecoratorOptions): T;
+export declare function getConstructor<T extends AbstractConstructor = AbstractConstructor>(constructorOrTarget: object): T;
+export declare function getTypeInfoString(type: AbstractConstructor): string;
+export declare function printType(type: Constructor): void;
+export {};

package/rpc/model.d.ts

@@ -0,0 +1,64 @@
+import type { SerializationOptions } from '../serializer/types.js';
+import type { Constructor, Record } from '../types.js';
+export type RpcConstructor<T extends Constructor> = T extends Constructor<any, infer R> ? Constructor<Promise<RpcRemote<InstanceType<T>>>, R> : never;
+export type RpcFunction<T extends (...args: any) => any> = T extends (...args: infer Args) => infer R ? (...args: Args) => Promise<Awaited<R>> : never;
+export type RpcObject<T extends Record> = {
+    [P in keyof T]: T[P] extends (...args: any) => any ? RpcFunction<T[P]> : Promise<Awaited<T[P]>>;
+};
+export type RpcRemoteInput = ((...args: any) => any) | Record;
+export type RpcRemote<T extends RpcRemoteInput = RpcRemoteInput> = T extends Constructor ? RpcConstructor<T> : T extends (...args: any) => any ? RpcFunction<T> : RpcObject<T>;
+export type RpcMessageBase<Type extends string = string> = {
+    type: Type;
+};
+export type RpcConnectMessage = RpcMessageBase<'connect'> & {
+    name: string;
+};
+export type RpcControlRequestMessage = RpcConnectMessage;
+export type RpcProxyApplyMessage = RpcMessageBase<'apply'> & {
+    path: PropertyKey[];
+    args: RpcValue[];
+};
+export type RpcProxyConstructMessage = RpcMessageBase<'construct'> & {
+    path: PropertyKey[];
+    args: RpcValue[];
+};
+export type RpcProxyGetMessage = RpcMessageBase<'get'> & {
+    path: PropertyKey[];
+};
+export type RpcProxySetMessage = RpcMessageBase<'set'> & {
+    path: PropertyKey[];
+    value: RpcValue;
+};
+export type RpcProxyRequestMessage = RpcProxyApplyMessage | RpcProxyConstructMessage | RpcProxyGetMessage | RpcProxySetMessage;
+export type RpcMessageRawValue = {
+    type: 'raw';
+    value: any;
+};
+export type RpcMessageSerializedValue = {
+    type: 'serialized';
+    value: any;
+    options?: SerializationOptions;
+};
+export type RpcMessageProxyValue = {
+    type: 'proxy';
+    channel: string;
+};
+export type RpcMessageAdapterValue = {
+    type: 'adapter';
+    adapter: string;
+    channel: string;
+    data: any;
+};
+export type RpcMessageThrowValue = {
+    type: 'throw';
+    error: unknown;
+};
+export type RpcValue = RpcMessageRawValue | RpcMessageSerializedValue | RpcMessageProxyValue | RpcMessageAdapterValue | RpcMessageThrowValue;
+export type RpcPostMessageArrayData = {
+    value: RpcValue[];
+    transfer?: any[];
+};
+export type RpcPostMessageData = {
+    value: RpcValue;
+    transfer?: any[];
+};

package/rpc/rpc.adapter.d.ts

@@ -0,0 +1,19 @@
+import type { NonPrimitive } from '../serializer/types.js';
+import type { RpcChannel } from './rpc.endpoint.js';
+export type AdaptSourceResult<Data> = Data extends void ? (void | {
+    data?: undefined;
+    transfer?: any[];
+}) : {
+    data: Data;
+    transfer?: any[];
+};
+export type RpcAdapterNonPrimitive = NonPrimitive<string, RpcAdapterNonPrimitiveData>;
+export type RpcAdapterNonPrimitiveData = {
+    channel: string;
+    data: any;
+};
+export interface RpcAdapter<T extends object = any, Data = any, ChannelData = any, Req = any, Res = any> {
+    name: string;
+    adaptSource(value: T, channel: RpcChannel<ChannelData, Req, Res>): AdaptSourceResult<Data>;
+    adaptTarget(data: Data, channel: RpcChannel<ChannelData, Req, Res>): T;
+}

package/rpc/rpc.d.ts

@@ -0,0 +1,21 @@
+import { type SerializationOptions } from '../serializer/index.js';
+import type { RpcRemote, RpcRemoteInput } from './model.js';
+import type { RpcAdapter } from './rpc.adapter.js';
+import type { RpcEndpoint } from './rpc.endpoint.js';
+export declare const Rpc: {
+    listen(endpoint: RpcEndpoint): void;
+    connect<T extends RpcRemoteInput>(endpoint: RpcEndpoint, name?: string): Promise<RpcRemote<T>>;
+    expose(object: RpcRemoteInput, name?: string): void;
+    registerAdapter<T extends object, Data>(adapter: RpcAdapter<T, Data>): void;
+    /**
+     * mark object for proxy forward
+     * @param object object to forward as proxy
+     * @param root if object is a child of the actual passed value (to function calls, returns or whatever), this must be set to to mark the parent for serialization (required for children proxies)
+     * @returns
+     */
+    proxy<T extends object>(object: T, root?: object): T;
+    transfer<T extends object>(object: T, transfer: any[]): T;
+    serialize<T extends object>(object: T, options?: SerializationOptions): T;
+    adapt<T extends object>(object: T, adapter: RpcAdapter<T>, root?: object): T;
+    isProxied(object: object): boolean;
+};

package/rpc/rpc.error.d.ts

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

package/rxjs-utils/retry-backoff.d.ts

@@ -0,0 +1,4 @@
+import { type BackoffOptions } from '../utils/backoff.js';
+import { type MonoTypeOperatorFunction, type ObservableInput } from 'rxjs';
+export declare function retryBackoff<T>(count: number, options: BackoffOptions): MonoTypeOperatorFunction<T>;
+export declare function retryBackoffHandled<T>(count: number, options: BackoffOptions, handler: (error: Error, count: number) => void | undefined | ObservableInput<void>): MonoTypeOperatorFunction<T>;

package/schema/converters/openapi-converter.d.ts

@@ -0,0 +1,3 @@
+import type { UndefinableJsonObject } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+export declare function convertToOpenApiSchema(testable: SchemaTestable): UndefinableJsonObject;

package/schema/decorators/class.d.ts

@@ -0,0 +1,3 @@
+import { type Decorator } from '../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Class(options?: SchemaTypeReflectionData): Decorator<'class'>;

package/schema/decorators/description.d.ts

@@ -0,0 +1,3 @@
+import { type Decorator } from '../../reflection/index.js';
+import type { SchemaTypeReflectionData } from './types.js';
+export declare function Description(options?: SchemaTypeReflectionData): Decorator<'class' | 'property'>;

package/schema/decorators/schema.d.ts

@@ -0,0 +1,21 @@
+import type { SetRequired } from 'type-fest';
+import { type Decorator } from '../../reflection/index.js';
+import type { TypedOmit } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { CombinedSchemaDecorator, SchemaReflectionData, SchemaTestableProvider } from './types.js';
+export type SchemaDecoratorOptions = SchemaReflectionData;
+export type SchemaDecoratorOptionsWithRequiredSchema = SetRequired<SchemaReflectionData, 'schema'>;
+export type SchemaDecoratorOptionsWithoutSchema = TypedOmit<SchemaReflectionData, 'schema'>;
+export declare function createSchemaDecorator(data?: SchemaReflectionData): CombinedSchemaDecorator;
+export declare function SchemaDecorator(schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;
+export declare function SchemaDecorator(options: SchemaDecoratorOptionsWithRequiredSchema): CombinedSchemaDecorator;
+export declare function Parameter(name: string, schema: SchemaTestable, options?: SchemaDecoratorOptionsWithoutSchema): Decorator<'parameter'>;
+export declare function Parameter(name: string, options: SchemaDecoratorOptions): Decorator<'parameter'>;
+export declare const Property: typeof SchemaDecorator;
+/**
+ * @deprecated use @Property instead
+ * @param schemaTestableProvider
+ * @param options
+ * @returns
+ */
+export declare function PropertySchema(schemaTestableProvider: SchemaTestableProvider, options?: SchemaDecoratorOptionsWithoutSchema): CombinedSchemaDecorator;

package/schema/decorators/types.d.ts

@@ -0,0 +1,24 @@
+import type { Decorator } from '../../reflection/types.js';
+import type { SchemaOptions, SchemaTestable } from '../schema.js';
+import type { ObjectSchemaFactory, ObjectSchemaOptions } from '../schemas/object.js';
+export type SchemaClassDecorator = Decorator<'class'>;
+export type SchemaPropertyDecorator = Decorator<'property' | 'accessor'>;
+export type SchemaMethodDecorator = Decorator<'method'>;
+export type CombinedSchemaDecorator = Decorator<'property' | 'accessor' | 'parameter'>;
+export type SchemaTypeReflectionData = Partial<Pick<ObjectSchemaOptions, 'mask' | 'unknownProperties' | 'unknownPropertiesKey' | 'description' | 'example'>> & {
+    schema?: SchemaTestable;
+    factory?: ObjectSchemaFactory<any>;
+};
+export type SchemaTestableProvider = (data: SchemaReflectionData) => SchemaTestable;
+export type SchemaReflectionData = Partial<Pick<SchemaOptions<any>, 'description' | 'example'>> & {
+    schema?: SchemaTestableProvider;
+    array?: boolean;
+    optional?: boolean;
+    nullable?: boolean;
+    method?: {
+        returnType?: SchemaTestableProvider;
+    };
+    parameter?: {
+        name?: string;
+    };
+};

package/schema/decorators/utils.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractConstructor } from '../../types.js';
+import type { SchemaTestable } from '../schema.js';
+import type { SchemaReflectionData } from './types.js';
+export declare function schemaReflectionDataToSchema(reflectionData: SchemaReflectionData | undefined, fallbackType: AbstractConstructor | null, source: {
+    type: AbstractConstructor;
+    key: string | symbol;
+}): SchemaTestable;

package/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/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/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/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/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/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/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/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/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/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;