@tstdl/base 0.91.0 → 0.91.1

package/authentication/authentication.api.d.ts

@@ -1,5 +1,5 @@
 import { type ApiDefinition } from '../api/types.js';
-import { ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
+import { type ObjectSchema, type ObjectSchemaOrType } from '../schema/index.js';
 import type { SchemaTestable } from '../schema/schema.js';
 import type { Record } from '../types.js';
 import type { TokenPayload } from './index.js';

package/enumerable/async-enumerable.d.ts

@@ -2,7 +2,7 @@ import type { CancellationSignal } from '../cancellation/token.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import type { AsyncComparator } from '../utils/sort.js';
 import type { Observable } from 'rxjs';
-import type { AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
+import type { AsyncGroupSelectors, AsyncIteratorFunction, AsyncPredicate, AsyncReducer, AsyncRetryPredicate, ParallelizableIteratorFunction, ParallelizablePredicate, ThrottleFunction } from '../utils/async-iterable-helpers/index.js';
 import type { IterableItemMetadata, TypePredicate } from '../utils/iterable-helpers/index.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
 import { Enumerable } from './enumerable.js';
@@ -33,9 +33,13 @@ export declare class AsyncEnumerable<T> implements EnumerableMethods, AsyncItera
     forceCast<TNew>(): AsyncEnumerable<TNew>;
     forEach(func: AsyncIteratorFunction<T, any>): Promise<void>;
     group<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
     groupSingle<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): AsyncEnumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): AsyncEnumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
     groupToMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T[]>>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>>;
     groupToSingleMap<TGroup>(selector: AsyncIteratorFunction<T, TGroup>): Promise<Map<TGroup, T>>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: AsyncGroupSelectors<T, TGroup>): Promise<Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>>;
     tap(tapper: AsyncIteratorFunction<T, any>): AsyncEnumerable<T>;
     interruptEvery(value: number): AsyncEnumerable<T>;
     interruptPerSecond(value: number): AsyncEnumerable<T>;

package/enumerable/async-enumerable.js

@@ -91,19 +91,19 @@ export class AsyncEnumerable {
     async forEach(func) {
         await forEachAsync(this.source, func);
     }
-    group(selector) {
-        const grouped = groupAsync(this.source, selector);
+    group(...selectors) {
+        const grouped = groupAsync(this.source, ...selectors);
         return new AsyncEnumerable(grouped);
     }
-    groupSingle(selector) {
-        const grouped = groupSingleAsync(this.source, selector);
+    groupSingle(...selectors) {
+        const grouped = groupSingleAsync(this.source, ...selectors);
         return new AsyncEnumerable(grouped);
     }
-    async groupToMap(selector) {
-        return groupToMapAsync(this.source, selector);
+    async groupToMap(...selectors) {
+        return groupToMapAsync(this.source, ...selectors);
     }
-    async groupToSingleMap(selector) {
-        return groupToSingleMapAsync(this.source, selector);
+    async groupToSingleMap(...selectors) {
+        return groupToSingleMapAsync(this.source, ...selectors);
     }
     tap(tapper) {
         const iterator = tapAsync(this.source, tapper);

package/enumerable/enumerable.d.ts

@@ -1,6 +1,6 @@
 import type { CancellationSignal } from '../cancellation/token.js';
 import type { Comparator } from '../utils/sort.js';
-import type { IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
+import type { GroupSelectors, IterableItemMetadata, IteratorFunction, Predicate, Reducer, TypePredicate } from '../utils/iterable-helpers/index.js';
 import { AsyncEnumerable } from './async-enumerable.js';
 import type { EnumerableMethods } from './enumerable-methods.js';
 export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
@@ -28,9 +28,13 @@ export declare class Enumerable<T> implements EnumerableMethods, Iterable<T> {
     forEach(func: IteratorFunction<T, void>): void;
     forceCast<TNew>(): Enumerable<TNew>;
     group<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T[]]>;
+    group<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]]>;
     groupSingle<TGroup>(selector: IteratorFunction<T, TGroup>): Enumerable<[TGroup, T]>;
+    groupSingle<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Enumerable<[TGroup['length'] extends 1 ? TGroup[0] : TGroup, T]>;
     groupToMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T[]>;
+    groupToMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T[]>;
     groupToSingleMap<TGroup>(selector: IteratorFunction<T, TGroup>): Map<TGroup, T>;
+    groupToSingleMap<TGroup extends [any, ...any[]]>(...selectors: GroupSelectors<T, TGroup>): Map<TGroup['length'] extends 1 ? TGroup[0] : TGroup, T>;
     tap(tapper: IteratorFunction<T, any>): Enumerable<T>;
     last<TPredicate extends T = T>(predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate;
     lastOrDefault<D, TPredicate extends T = T>(defaultValue: D, predicate?: Predicate<T> | TypePredicate<T, TPredicate>): TPredicate | D;

package/enumerable/enumerable.js

@@ -79,19 +79,19 @@ export class Enumerable {
     forceCast() {
         return this;
     }
-    group(selector) {
-        const grouped = group(this.source, selector);
+    group(...selectors) {
+        const grouped = group(this.source, ...selectors);
         return new Enumerable(grouped);
     }
-    groupSingle(selector) {
-        const grouped = groupSingle(this.source, selector);
+    groupSingle(...selectors) {
+        const grouped = groupSingle(this.source, ...selectors);
         return new Enumerable(grouped);
     }
-    groupToMap(selector) {
-        return groupToMap(this.source, selector);
+    groupToMap(...selectors) {
+        return groupToMap(this.source, ...selectors);
     }
-    groupToSingleMap(selector) {
-        return groupToSingleMap(this.source, selector);
+    groupToSingleMap(...selectors) {
+        return groupToSingleMap(this.source, ...selectors);
     }
     tap(tapper) {
         const iterator = tap(this.source, tapper);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.0",
+  "version": "0.91.1",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/schema-old/array-constraints/index.d.ts

@@ -1,2 +0,0 @@
-export * from './maximum-length.js';
-export * from './minimum-length.js';

package/schema-old/array-constraints/index.js

@@ -1,2 +0,0 @@
-export * from './maximum-length.js';
-export * from './minimum-length.js';

package/schema-old/array-constraints/maximum-length.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class ArrayMaximumLengthConstraint extends SchemaArrayConstraint {
-    private readonly maximumLength;
-    readonly expects: string;
-    constructor(maximumLength: number);
-    validate(value: any[], path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function ArrayMaximumLength(maximumLength: number): Decorator<'property' | 'accessor'>;

package/schema-old/array-constraints/maximum-length.js

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-export class ArrayMaximumLengthConstraint extends SchemaArrayConstraint {
-    maximumLength;
-    expects;
-    constructor(maximumLength) {
-        super();
-        this.maximumLength = maximumLength;
-        this.expects = `a maximum array length of ${this.maximumLength}`;
-    }
-    validate(value, path, context) {
-        if (value.length > this.maximumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function ArrayMaximumLength(maximumLength) {
-    return createSchemaArrayConstraintDecorator(new ArrayMaximumLengthConstraint(maximumLength));
-}

package/schema-old/array-constraints/minimum-length.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class MinimumArrayLengthConstraint extends SchemaArrayConstraint {
-    private readonly minimumLength;
-    readonly expects: string;
-    constructor(minimumLength: number);
-    validate(value: any[], path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare function MinimumArrayLength(minimumLength: number): Decorator<'property' | 'accessor'>;

package/schema-old/array-constraints/minimum-length.js

@@ -1,22 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaArrayConstraintDecorator } from '../decorators/index.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaArrayConstraint } from '../types/schema-array-constraint.js';
-export class MinimumArrayLengthConstraint extends SchemaArrayConstraint {
-    minimumLength;
-    expects;
-    constructor(minimumLength) {
-        super();
-        this.minimumLength = minimumLength;
-        this.expects = `a minimum array length of ${this.minimumLength}`;
-    }
-    validate(value, path, context) {
-        if (value.length < this.minimumLength) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, `an array length of ${value.length}`, path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export function MinimumArrayLength(minimumLength) {
-    return createSchemaArrayConstraintDecorator(new MinimumArrayLengthConstraint(minimumLength));
-}

package/schema-old/coercers/boolean.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class BooleanCoercer extends SchemaValueCoercer {
-    readonly sourceType: (NumberConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: BooleanConstructor;
-    coerce(value: number | string | bigint, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const booleanCoercer: BooleanCoercer;

package/schema-old/coercers/boolean.coercer.js

@@ -1,27 +0,0 @@
-import { isString } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class BooleanCoercer extends SchemaValueCoercer {
-    sourceType = [Number, String, BigInt];
-    targetType = Boolean;
-    coerce(value, path, context) {
-        const normalizedValue = isString(value) ? value.toLowerCase() : value;
-        switch (normalizedValue) {
-            case 1:
-            case 1n:
-            case 'true':
-            case '1':
-            case 'yes':
-                return { success: true, value: true };
-            case 0:
-            case 0n:
-            case 'false':
-            case '0':
-            case 'no':
-                return { success: true, value: false };
-            default:
-                return { success: false, error: SchemaError.couldNotCoerce(Boolean, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-    }
-}
-export const booleanCoercer = new BooleanCoercer();

package/schema-old/coercers/date.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class DateCoercer extends SchemaValueCoercer {
-    readonly sourceType: (NumberConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: DateConstructor;
-    coerce(value: number | string | bigint, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const dateCoercer: DateCoercer;

package/schema-old/coercers/date.coercer.js

@@ -1,16 +0,0 @@
-import { isBigInt } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class DateCoercer extends SchemaValueCoercer {
-    sourceType = [Number, String, BigInt];
-    targetType = Date;
-    coerce(value, path, context) {
-        const parseValue = isBigInt(value) ? Number(value) : value;
-        const date = new Date(parseValue);
-        if (Number.isNaN(date.getTime())) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { success: true, value: date };
-    }
-}
-export const dateCoercer = new DateCoercer();

package/schema-old/coercers/index.d.ts

@@ -1,6 +0,0 @@
-export * from './boolean.coercer.js';
-export * from './date.coercer.js';
-export * from './number.coercer.js';
-export * from './regexp.coercer.js';
-export * from './string.coercer.js';
-export * from './uint8-array.coercer.js';

package/schema-old/coercers/index.js

@@ -1,6 +0,0 @@
-export * from './boolean.coercer.js';
-export * from './date.coercer.js';
-export * from './number.coercer.js';
-export * from './regexp.coercer.js';
-export * from './string.coercer.js';
-export * from './uint8-array.coercer.js';

package/schema-old/coercers/number.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class NumberCoercer extends SchemaValueCoercer {
-    readonly sourceType: (BooleanConstructor | StringConstructor | BigIntConstructor)[];
-    readonly targetType: NumberConstructor;
-    coerce(value: string | bigint | boolean, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const numberCoercer: NumberCoercer;

package/schema-old/coercers/number.coercer.js

@@ -1,14 +0,0 @@
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class NumberCoercer extends SchemaValueCoercer {
-    sourceType = [String, BigInt, Boolean];
-    targetType = Number;
-    coerce(value, path, context) {
-        const result = Number(value);
-        if (Number.isNaN(result)) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, value.toString(), path, { fast: context.options.fastErrors, customMessage: 'Value is not a number.' }) };
-        }
-        return { success: true, value: result };
-    }
-}
-export const numberCoercer = new NumberCoercer();

package/schema-old/coercers/regexp.coercer.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class RegExpCoercer extends SchemaValueCoercer {
-    readonly sourceType: StringConstructor;
-    readonly targetType: RegExpConstructor;
-    readonly flags: string | undefined;
-    constructor(flags?: string);
-    coerce(value: string, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const regExpCoercer: RegExpCoercer;

package/schema-old/coercers/regexp.coercer.js

@@ -1,20 +0,0 @@
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class RegExpCoercer extends SchemaValueCoercer {
-    sourceType = String;
-    targetType = RegExp;
-    flags;
-    constructor(flags = 'u') {
-        super();
-        this.flags = flags;
-    }
-    coerce(value, path, context) {
-        try {
-            return { success: true, value: RegExp(value, this.flags) };
-        }
-        catch (error) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid regexp pattern', path, { fast: context.options.fastErrors, customMessage: error.message }) };
-        }
-    }
-}
-export const regExpCoercer = new RegExpCoercer();

package/schema-old/coercers/string.coercer.d.ts

@@ -1,9 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class StringCoercer extends SchemaValueCoercer {
-    readonly sourceType: (DateConstructor | NumberConstructor | BooleanConstructor | BigIntConstructor)[];
-    readonly targetType: StringConstructor;
-    coerce(value: number | boolean | bigint | Date, path: JsonPath, context: CoercerContext): CoerceResult;
-}
-export declare const stringCoercer: StringCoercer;

package/schema-old/coercers/string.coercer.js

@@ -1,14 +0,0 @@
-import { isDate, isValidDate } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class StringCoercer extends SchemaValueCoercer {
-    sourceType = [Number, Boolean, BigInt, Date];
-    targetType = String;
-    coerce(value, path, context) {
-        if (isDate(value) && !isValidDate(value)) {
-            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid date', path, { fast: context.options.fastErrors }) };
-        }
-        return { success: true, value: value.toString() };
-    }
-}
-export const stringCoercer = new StringCoercer();

package/schema-old/coercers/uint8-array.coercer.d.ts

@@ -1,11 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Schema } from '../schema.js';
-import type { CoerceResult, CoercerContext } from '../types/index.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export declare class Uint8ArrayCoercer extends SchemaValueCoercer {
-    static readonly byteNumberArraySchema: Schema<number[]>;
-    readonly sourceType: ArrayConstructor;
-    readonly targetType: Uint8ArrayConstructor;
-    coerce(value: any[], path: JsonPath, { options }: CoercerContext): CoerceResult;
-}
-export declare const uint8ArrayCoercer: Uint8ArrayCoercer;

package/schema-old/coercers/uint8-array.coercer.js

@@ -1,22 +0,0 @@
-import { lazyProperty } from '../../utils/object/lazy-property.js';
-import { SchemaError } from '../schema.error.js';
-import { testSchema } from '../schema.js';
-import { array } from '../schemas/array.js';
-import { number } from '../schemas/number.js';
-import { SchemaValueCoercer } from '../types/index.js';
-export class Uint8ArrayCoercer extends SchemaValueCoercer {
-    static byteNumberArraySchema;
-    static {
-        lazyProperty(this, 'byteNumberArraySchema', () => array(number({ integer: true, minimum: 0, maximum: 255 })));
-    }
-    sourceType = Array;
-    targetType = Uint8Array;
-    coerce(value, path, { options }) {
-        const testResult = testSchema(Uint8ArrayCoercer.byteNumberArraySchema, value, options, path);
-        if (!testResult.valid) {
-            return { success: false, error: SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
-        }
-        return { success: true, value: Uint8Array.from(testResult.value) };
-    }
-}
-export const uint8ArrayCoercer = new Uint8ArrayCoercer();

package/schema-old/constraints/enumeration.d.ts

@@ -1,13 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Enumeration, EnumerationValue, OneOrMany } from '../../types.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class EnumerationConstraint extends SchemaValueConstraint {
-    private readonly allowedValuesString;
-    readonly enumeration: Enumeration;
-    readonly allowedValuesSet: Set<EnumerationValue>;
-    readonly suitableTypes: SchemaValueConstraint['suitableTypes'];
-    readonly expects: OneOrMany<string>;
-    constructor(enumeration: Enumeration);
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/enumeration.js

@@ -1,29 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { enumValues } from '../../utils/enum.js';
-import { distinct } from '../../utils/iterable-helpers/distinct.js';
-import { isArray, isString } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { getValueType } from '../utils/value-type.js';
-export class EnumerationConstraint extends SchemaValueConstraint {
-    allowedValuesString;
-    enumeration;
-    allowedValuesSet;
-    suitableTypes;
-    expects;
-    constructor(enumeration) {
-        super();
-        this.enumeration = enumeration;
-        const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
-        this.allowedValuesSet = new Set(allowedValues);
-        this.allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : value)).join(', ');
-        this.suitableTypes = [...distinct(allowedValues.map((value) => getValueType(value)))];
-        this.expects = `one of [${this.allowedValuesString}]`;
-    }
-    validate(value, path, context) {
-        if (!this.allowedValuesSet.has(value)) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}

package/schema-old/constraints/generic.d.ts

@@ -1,20 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { OneOrMany } from '../../types.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export type GenericConstraintResult = {
-    success: true;
-    error?: undefined;
-} | {
-    success: false;
-    error: string | SchemaError;
-};
-export type GenericConstraintFunction<T> = (value: T, path: JsonPath) => boolean | ConstraintResult;
-export declare class GenericConstraint<T> extends SchemaValueConstraint {
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: OneOrMany<string>;
-    readonly constraintFunction: GenericConstraintFunction<T>;
-    constructor(constraintFunction: GenericConstraintFunction<T>, expects?: OneOrMany<string>);
-    validate(value: T, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/generic.js

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isBoolean } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-export class GenericConstraint extends SchemaValueConstraint {
-    suitableTypes = Number;
-    expects;
-    constraintFunction;
-    constructor(constraintFunction, expects = 'valid value') {
-        super();
-        this.constraintFunction = constraintFunction;
-        this.expects = expects;
-    }
-    validate(value, path, context) {
-        const result = this.constraintFunction(value, path);
-        if (isBoolean(result)) {
-            return result
-                ? { valid: true }
-                : { valid: false, error: SchemaError.expectedButGot(this.expects, 'invalid value', path, { fast: context.options.fastErrors }) };
-        }
-        return result;
-    }
-}

package/schema-old/constraints/index.d.ts

@@ -1,12 +0,0 @@
-export * from './enumeration.js';
-export * from './generic.js';
-export * from './integer.js';
-export * from './length.js';
-export * from './literal.js';
-export * from './maximum.js';
-export * from './maximum-date.js';
-export * from './maximum-length.js';
-export * from './minimum.js';
-export * from './minimum-date.js';
-export * from './minimum-length.js';
-export * from './pattern.js';

package/schema-old/constraints/index.js

@@ -1,12 +0,0 @@
-export * from './enumeration.js';
-export * from './generic.js';
-export * from './integer.js';
-export * from './length.js';
-export * from './literal.js';
-export * from './maximum.js';
-export * from './maximum-date.js';
-export * from './maximum-length.js';
-export * from './minimum.js';
-export * from './minimum-date.js';
-export * from './minimum-length.js';
-export * from './pattern.js';

package/schema-old/constraints/integer.d.ts

@@ -1,12 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import type { Decorator } from '../../reflection/index.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class IntegerConstraint extends SchemaValueConstraint {
-    readonly suitableTypes: NumberConstructor;
-    readonly expects: string;
-    constructor();
-    validate(value: number, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}
-export declare const integerConstraint: IntegerConstraint;
-export declare function Integer(): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/integer.js

@@ -1,23 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { typeSchema } from '../types/types.js';
-export class IntegerConstraint extends SchemaValueConstraint {
-    suitableTypes = Number;
-    expects;
-    constructor() {
-        super();
-        this.expects = 'an integer';
-    }
-    validate(value, path, context) {
-        if (!Number.isInteger(value)) {
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}
-export const integerConstraint = new IntegerConstraint();
-export function Integer() {
-    return createSchemaValueConstraintDecorator(integerConstraint, { schema: typeSchema(Number) });
-}

package/schema-old/constraints/length.d.ts

@@ -1,6 +0,0 @@
-import type { Decorator } from '../../reflection/index.js';
-export type LengthConstraintOptions = {
-    minimum?: number;
-    maximum?: number;
-};
-export declare function Length(options: LengthConstraintOptions): Decorator<'property' | 'accessor'>;

package/schema-old/constraints/length.js

@@ -1,15 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isDefined } from '../../utils/type-guards.js';
-import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
-import { MaximumLengthConstraint } from './maximum-length.js';
-import { MinimumLengthConstraint } from './minimum-length.js';
-export function Length(options) {
-    const constraints = [];
-    if (isDefined(options.minimum)) {
-        constraints.push(new MinimumLengthConstraint(options.minimum));
-    }
-    if (isDefined(options.maximum)) {
-        constraints.push(new MaximumLengthConstraint(options.maximum));
-    }
-    return createSchemaValueConstraintDecorator(constraints);
-}

package/schema-old/constraints/literal.d.ts

@@ -1,10 +0,0 @@
-import type { JsonPath } from '../../json-path/json-path.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import type { ConstraintContext, ConstraintResult } from '../types/types.js';
-export declare class LiteralConstraint extends SchemaValueConstraint {
-    readonly literal: any;
-    readonly suitableTypes: SchemaValueConstraint['suitableTypes'];
-    readonly expects: string;
-    constructor(literal: any);
-    validate(value: any, path: JsonPath, context: ConstraintContext): ConstraintResult;
-}

package/schema-old/constraints/literal.js

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-import { isPrimitive } from '../../utils/type-guards.js';
-import { SchemaError } from '../schema.error.js';
-import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
-import { getValueType, getValueTypeName } from '../utils/value-type.js';
-export class LiteralConstraint extends SchemaValueConstraint {
-    literal;
-    suitableTypes;
-    expects;
-    constructor(literal) {
-        super();
-        this.literal = literal;
-        this.suitableTypes = getValueType(literal);
-        const literalName = isPrimitive(literal) ? String(literal) : getValueTypeName(this.suitableTypes);
-        this.expects = `literal ${literalName}`;
-    }
-    validate(value, path, context) {
-        if (value !== this.literal) {
-            const valueType = getValueType(value);
-            return { valid: false, error: SchemaError.expectedButGot(this.expects, getValueTypeName(valueType), path, { fast: context.options.fastErrors }) };
-        }
-        return { valid: true };
-    }
-}