@tstdl/base 0.92.124 → 0.92.125

package/types/queue/queue.d.ts

@@ -1,91 +0,0 @@
-import type { CancellationSignal } from '../../cancellation/token.js';
-import { type EnumType } from '../../enumeration/enumeration.js';
-import type { Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { Logger } from '../../logger/logger.js';
-import { QueueEnqueueBatch } from './enqueue-batch.js';
-export type ProcessWorker<T> = (job: Job<T>) => void | Promise<void>;
-export type ProcessBatchWorker<T> = (jobs: Job<T>[]) => void | Promise<void>;
-export type JobTag = string | null;
-export type Job<T> = {
-    id: string;
-    /**
-     * The lower the number, the higher the priority.
-     * @default 1000
-     */
-    priority: number;
-    tag: JobTag;
-    data: T;
-    enqueueTimestamp: number;
-    lastDequeueTimestamp: number | null;
-    tries: number;
-};
-export declare const defaultJobPriority = 1000;
-export declare const UniqueTagStrategy: {
-    readonly KeepOld: 0;
-    readonly TakeNew: 1;
-};
-export type UniqueTagStrategy = EnumType<typeof UniqueTagStrategy>;
-export type EnqueueOptions = {
-    tag?: JobTag;
-    priority?: number;
-};
-export type EnqueueOneOptions = {
-    tag?: JobTag;
-    uniqueTag?: UniqueTagStrategy;
-    priority?: number;
-};
-export type EnqueueManyItem<T> = EnqueueOptions & {
-    data: T;
-};
-export type EnqueueManyOptions = {
-    uniqueTag?: UniqueTagStrategy;
-    returnJobs?: boolean;
-};
-export type QueueConfig = {
-    processTimeout?: number;
-    maxTries?: number;
-};
-export type QueueArgument = string | (QueueConfig & {
-    name: string;
-});
-export declare const defaultQueueConfig: Required<QueueConfig>;
-export declare abstract class Queue<T> implements Resolvable<QueueArgument> {
-    readonly [resolveArgumentType]: QueueArgument;
-    abstract readonly processTimeout: number;
-    abstract readonly maxTries: number;
-    batch(): QueueEnqueueBatch<T>;
-    abstract enqueue(data: T, options?: EnqueueOneOptions): Promise<Job<T>>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions & {
-        returnJobs?: false;
-    }): Promise<void>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options: EnqueueManyOptions & {
-        returnJobs: true;
-    }): Promise<Job<T>[]>;
-    abstract enqueueMany(items: EnqueueManyItem<T>[], options?: EnqueueManyOptions): Promise<Job<T>[] | undefined>;
-    abstract has(id: string): Promise<boolean>;
-    abstract countByTag(tag: JobTag): Promise<number>;
-    abstract get(id: string): Promise<Job<T> | undefined>;
-    abstract getByTag(tag: JobTag): Promise<Job<T>[]>;
-    abstract getByTags(tags: JobTag[]): Promise<Job<T>[]>;
-    abstract cancel(id: string): Promise<void>;
-    abstract cancelMany(ids: string[]): Promise<void>;
-    abstract cancelByTag(tag: JobTag): Promise<void>;
-    abstract cancelByTags(tags: JobTag[]): Promise<void>;
-    abstract dequeue(): Promise<Job<T> | undefined>;
-    abstract dequeueMany(count: number): Promise<Job<T>[]>;
-    abstract acknowledge(job: Job<T>): Promise<void>;
-    abstract acknowledgeMany(jobs: Job<T>[]): Promise<void>;
-    abstract getConsumer(cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>>;
-    abstract getBatchConsumer(size: number, cancellationSignal: CancellationSignal): AsyncIterableIterator<Job<T>[]>;
-    process({ concurrency, cancellationSignal }: {
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-    }, handler: ProcessWorker<T>, logger: Logger): void;
-    processBatch({ batchSize, concurrency, cancellationSignal }: {
-        batchSize?: number;
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-    }, handler: ProcessBatchWorker<T>, logger: Logger): void;
-    private processWorker;
-    private processBatchWorker;
-}

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