@tstdl/base 0.92.123 → 0.92.124

package/reflection/decorators.d.ts

@@ -1,15 +0,0 @@
-import 'reflect-metadata/lite';
-import type { ConstructorParameterDecorator } from '../types.js';
-import type { Decorator, DecoratorHandler } from './types.js';
-import { type CreateDecoratorOptions, type SpecificCreateDecoratorOptions } from './utils.js';
-export declare function Decorate({ handler, ...options }?: CreateDecoratorOptions & {
-    handler?: DecoratorHandler;
-}): Decorator;
-export declare function Class(options?: SpecificCreateDecoratorOptions<'class'>): ClassDecorator;
-export declare function Property(options?: SpecificCreateDecoratorOptions<'property'>): PropertyDecorator;
-export declare function Accessor(options?: SpecificCreateDecoratorOptions<'accessor'>): MethodDecorator;
-export declare function PropertyOrAccessor(options?: SpecificCreateDecoratorOptions<'property' | 'accessor'>): Decorator<'property' | 'accessor'>;
-export declare function Method(options?: SpecificCreateDecoratorOptions<'method'>): MethodDecorator;
-export declare function MethodParameter(options?: SpecificCreateDecoratorOptions<'methodParameter'>): ParameterDecorator;
-export declare function ConstructorParameter(options?: SpecificCreateDecoratorOptions<'constructorParameter'>): ConstructorParameterDecorator;
-export declare function Parameter(options?: SpecificCreateDecoratorOptions<'parameter'>): ParameterDecorator & ConstructorParameterDecorator;

package/reflection/registry.d.ts

@@ -1,61 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;