@decaf-ts/decorator-validation 1.20.0 → 1.21.0

package/lib/types/utils/DateBuilder.d.ts

@@ -1,121 +0,0 @@
-type DateBuilderField = "Years" | "Months" | "Days" | "Hours" | "Minutes" | "Seconds";
-export type DateBuilderInstance = DateBuilder<DateBuilderField>;
-export type DateTarget = Date | DateBuilderInstance;
-export type OffsetValues = {
-    years: number;
-    months: number;
-    days: number;
-    hours: number;
-    minutes: number;
-    seconds: number;
-};
-export declare function offsetDate(date: Date, direction: 1 | -1, values: OffsetValues): Date;
-type RemoveField<Input extends DateBuilderField, Field extends DateBuilderField> = Input extends Field ? never : Input;
-interface DateBuilderUtilityMethods {
-    Now(): Date;
-    Tomorrow(): Date;
-    Yesterday(): Date;
-    DaysAgo(count: number): Date;
-    NextDays(count: number): Date;
-    YearsAgo(count: number): Date;
-    NextYears(count: number): Date;
-    MonthsAgo(count: number): Date;
-    NextMonths(count: number): Date;
-    HoursAgo(count: number): Date;
-    NextHours(count: number): Date;
-    MinutesAgo(count: number): Date;
-    NextMinutes(count: number): Date;
-    SecondsAgo(count: number): Date;
-    NextSeconds(count: number): Date;
-}
-interface DateBuilderCoreMethods extends DateBuilderUtilityMethods {
-    build(reference?: DateTarget): Date;
-    from(reference: DateTarget): Date;
-    past(reference: DateTarget): Date;
-    after(reference: DateTarget): Date;
-    until(reference: DateTarget): Date;
-    before(reference: DateTarget): Date;
-    ago(reference?: DateTarget): Date;
-}
-export type DateBuilderChain<Remaining extends DateBuilderField = DateBuilderField> = DateBuilderCoreMethods & {
-    [Field in Remaining]: (value: number) => DateBuilderChain<RemoveField<Remaining, Field>>;
-};
-/**
- * Fluent builder for producing dates relative to a reference point.
- */
-export declare class DateBuilder<Remaining extends DateBuilderField = DateBuilderField> implements DateBuilderCoreMethods {
-    private years;
-    private months;
-    private days;
-    private hours;
-    private minutes;
-    private seconds;
-    private constructor();
-    static Years(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Years">>;
-    static Months(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Months">>;
-    static Days(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Days">>;
-    static Hours(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Hours">>;
-    static Minutes(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Minutes">>;
-    static Seconds(value: number): DateBuilderChain<RemoveField<DateBuilderField, "Seconds">>;
-    static Now(): Date;
-    static Tomorrow(): Date;
-    static Yesterday(): Date;
-    static DaysAgo(count: number): Date;
-    static NextDays(count: number): Date;
-    static YearsAgo(count: number): Date;
-    static NextYears(count: number): Date;
-    static MonthsAgo(count: number): Date;
-    static NextMonths(count: number): Date;
-    static HoursAgo(count: number): Date;
-    static NextHours(count: number): Date;
-    static MinutesAgo(count: number): Date;
-    static NextMinutes(count: number): Date;
-    static SecondsAgo(count: number): Date;
-    static NextSeconds(count: number): Date;
-    Years(value: number): DateBuilderChain<RemoveField<Remaining, "Years">>;
-    Months(value: number): DateBuilderChain<RemoveField<Remaining, "Months">>;
-    Days(value: number): DateBuilderChain<RemoveField<Remaining, "Days">>;
-    Hours(value: number): DateBuilderChain<RemoveField<Remaining, "Hours">>;
-    Minutes(value: number): DateBuilderChain<RemoveField<Remaining, "Minutes">>;
-    Seconds(value: number): DateBuilderChain<RemoveField<Remaining, "Seconds">>;
-    build(reference?: DateTarget): Date;
-    from(reference: DateTarget): Date;
-    past(reference: DateTarget): Date;
-    after(reference: DateTarget): Date;
-    until(reference: DateTarget): Date;
-    before(reference: DateTarget): Date;
-    ago(reference?: DateTarget): Date;
-    Now(): Date;
-    Tomorrow(): Date;
-    Yesterday(): Date;
-    DaysAgo(count: number): Date;
-    NextDays(count: number): Date;
-    YearsAgo(count: number): Date;
-    NextYears(count: number): Date;
-    MonthsAgo(count: number): Date;
-    NextMonths(count: number): Date;
-    HoursAgo(count: number): Date;
-    NextHours(count: number): Date;
-    MinutesAgo(count: number): Date;
-    NextMinutes(count: number): Date;
-    SecondsAgo(count: number): Date;
-    NextSeconds(count: number): Date;
-    private offsets;
-}
-export declare const Dates: typeof DateBuilder;
-export declare const Now: () => Date;
-export declare const Tomorrow: () => Date;
-export declare const Yesterday: () => Date;
-export declare const DaysAgo: (count: number) => Date;
-export declare const NextDays: (count: number) => Date;
-export declare const YearsAgo: (count: number) => Date;
-export declare const NextYears: (count: number) => Date;
-export declare const MonthsAgo: (count: number) => Date;
-export declare const NextMonths: (count: number) => Date;
-export declare const HoursAgo: (count: number) => Date;
-export declare const NextHours: (count: number) => Date;
-export declare const MinutesAgo: (count: number) => Date;
-export declare const NextMinutes: (count: number) => Date;
-export declare const SecondsAgo: (count: number) => Date;
-export declare const NextSeconds: (count: number) => Date;
-export {};

package/lib/types/utils/PathProxy.d.ts

@@ -1,43 +0,0 @@
-/**
- * Proxy object that provides path-based access to nested properties
- * @template T - The type of the target object being proxied
- */
-export type PathProxy<T> = T & {
-    getValueFromPath: (path: string, fallback?: any) => any;
-};
-/**
- * Standard path resolution utility for accessing nested object properties.
- * Provides consistent dot-notation access to both parent and child properties
- * across complex object structures.
- *
- * - Dot-notation path resolution ('object.child.property')
- * - Parent traversal using '../' notation
- * - Configurable property access behavior
- * - Null/undefined safety checks
- */
-export declare class PathProxyEngine {
-    /**
-     * Creates a path-aware proxy for the target object
-     * @template T - The type of the target object
-     * @param {T} rootTarget - The target object to proxy
-     * @param opts - Configuration options
-     * @param opts.getValue - Custom function to get property value
-     * @param opts.getParent - Custom function to get parent object
-     * @param opts.ignoreUndefined - Whether to ignore undefined values in paths
-     * @param opts.ignoreNull - Whether to ignore null values in paths
-     * @returns A proxy object with path access capabilities
-     */
-    static create<T extends object>(rootTarget: T, opts?: {
-        getValue?: (target: T, prop: string) => any;
-        getParent?: (target: T) => any;
-        ignoreUndefined: boolean;
-        ignoreNull: boolean;
-    }): PathProxy<T>;
-    /**
-     * Parses a path string into individual components
-     * @param path - The path string to parse (e.g., "user.address.city")
-     * @returns An array of path components
-     * @throws Error if the path is invalid
-     */
-    private static parsePath;
-}

package/lib/types/utils/constants.d.ts

@@ -1,32 +0,0 @@
-/**
- * @description Enum containing metadata keys used for reflection in the model system
- * @summary Defines the various Model keys used for reflection and metadata storage.
- * These keys are used throughout the library to store and retrieve metadata about models,
- * their properties, and their behavior.
- *
- * @property {string} TYPE - Key for storing design type information
- * @property {string} MODEL - Key for identifying model metadata
- * @property {string} ANCHOR - Anchor key that serves as a ghost property in the model
- * @property {string} CONSTRUCTION - Key for storing construction information
- * @property {string} ATTRIBUTE - Key for storing attribute metadata
- * @property {string} HASHING - Key for storing hashing configuration
- * @property {string} SERIALIZATION - Key for storing serialization configuration
- *
- * @enum {string}
- * @readonly
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare enum ModelKeys {
-    DESCRIPTION = "description",
-    TYPE = "design:type",
-    MODEL = "model",
-    ANCHOR = "__model",
-    CONSTRUCTION = "constructed-by",
-    ATTRIBUTE = "__attributes",
-    HASHING = "hashing",
-    SERIALIZATION = "serialization",
-    DECORATORS = "decorators",
-    CONSTRUCTOR = "__original"
-}
-export declare const DefaultSerializationMethod = "json";

package/lib/types/utils/dates.d.ts

@@ -1,86 +0,0 @@
-/**
- * @summary Reverses the process from {@link formatDate}
- *
- * @param {string} date the date string to be converted back into date
- * @param {string} format the date format
- * @return {Date} the date from the format or the standard new Date({@prop date}) if the string couldn't be parsed (are you sure the format matches the string?)
- *
- * @function dateFromFormat
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function dateFromFormat(date: string, format: string): Date;
-/**
- * @description Binds a specific date format to a Date object's toString and toISOString methods using a Proxy
- * @summary Wraps a Date object in a Proxy to return a formatted string when toString or toISOString is called.
- * This function uses the Proxy API to intercept method calls and return the date formatted according
- * to the specified format string, while maintaining all other Date functionality.
- * The proxied Date maintains instanceof Date checks and behaves identically to a Date object.
- * @param {Date} [date] The Date object to modify
- * @param {string} [format] The format string to use for formatting the date
- * @return {Date|undefined} A proxied Date object or undefined if no date was provided
- * @function bindDateToString
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function bindDateToString(date: Date | undefined, format: string): Date | undefined;
-/**
- * @description Safely checks if a value is a valid Date object
- * @summary A utility function that determines if a value is a valid Date object.
- * This function is more reliable than using instanceof Date as it also checks
- * that the date is not NaN, which can happen with invalid date strings.
- * @param {any} date The value to check
- * @return {boolean} True if the value is a valid Date object, false otherwise
- * @function isValidDate
- * @memberOf module:decorator-validation
- * @category Validation
- */
-export declare function isValidDate(date: any): boolean;
-/**
- * @summary Util function to pad numbers
- * @param {number} num
- *
- * @return {string}
- *
- * @function twoDigitPad
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function twoDigitPad(num: number): string;
-/**
- * @summary Date Format Handling
- * @description Code from {@link https://stackoverflow.com/questions/3552461/how-to-format-a-javascript-date}
- *
- * <pre>
- *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
- *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
- *      You can display date, time, AM/PM, etc.
- *
- *      Date and Time Patterns
- *      yy = 2-digit year; yyyy = full year
- *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
- *      EEEE = full weekday name; EEE = short weekday name
- *      d = digit day; dd = 2-digit day
- *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
- *      m = minutes; mm = 2-digit minutes; aaa = AM/PM
- *      s = seconds; ss = 2-digit seconds
- *      S = miliseconds
- * </pre>
- *
- * @param {Date} date
- * @param {string} [patternStr] defaults to 'yyyy/MM/dd'
- * @return {string} the formatted date
- *
- * @function formatDate
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function formatDate(date: Date, patternStr?: string): string;
-/**
- * @summary Parses a date from a specified format
- * @param {string} format
- * @param {string | Date | number} [v]
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function parseDate(format: string, v?: string | Date | number): Date | undefined;

package/lib/types/utils/equality.d.ts

@@ -1,56 +0,0 @@
-/**
- * @description Enhanced algorithm for deep comparison of any two values with optional ignored properties
- * @summary Performs a deep equality check between two values, handling various types including primitives, objects, arrays, dates, and more
- * @param {unknown} a - First value to compare
- * @param {unknown} b - Second value to compare
- * @param {string[]} propsToIgnore - A list of property names to ignore during comparison
- * @return {boolean} Returns true if the values are deeply equal, false otherwise
- * @function isEqual
- * @mermaid
- * sequenceDiagram
- *   participant Caller
- *   participant isEqual
- *   participant Recursion
- *
- *   Caller->>isEqual: isEqual(a, b, propsToIgnore)
- *   Note over isEqual: Check simple cases (identity, null, primitives)
- *
- *   alt a === b
- *     isEqual-->>Caller: true (with special case for +0/-0)
- *   else a or b is null
- *     isEqual-->>Caller: a === b
- *   else different types
- *     isEqual-->>Caller: false
- *   else both NaN
- *     isEqual-->>Caller: true
- *   else primitive types
- *     isEqual-->>Caller: a === b
- *   else both Date objects
- *     isEqual-->>Caller: Compare timestamps
- *   else both RegExp objects
- *     isEqual-->>Caller: Compare string representations
- *   else both Error objects
- *     isEqual-->>Caller: Compare name and message
- *   else both Arrays
- *     Note over isEqual: Check length
- *     loop For each element
- *       isEqual->>Recursion: isEqual(a[i], b[i], propsToIgnore)
- *     end
- *   else both Maps or Sets
- *     Note over isEqual: Compare size and entries
- *   else both TypedArrays
- *     Note over isEqual: Compare byte by byte
- *   else both Objects
- *     Note over isEqual: Filter keys by propsToIgnore
- *     Note over isEqual: Compare key counts
- *     loop For each key
- *       isEqual->>Recursion: isEqual(a[key], b[key], propsToIgnore)
- *     end
- *     Note over isEqual: Check Symbol properties
- *     Note over isEqual: Compare prototypes
- *   end
- *
- *   isEqual-->>Caller: Comparison result
- * @memberOf module:decorator-validation
- */
-export declare function isEqual(a: unknown, b: unknown, ...propsToIgnore: string[]): boolean;

package/lib/types/utils/hashing.d.ts

@@ -1,82 +0,0 @@
-/**
- * @summary Mimics Java's String's Hash implementation
- *
- * @param {string | number | symbol | Date} obj
- * @return {number} hash value of obj
- *
- * @function hashCode
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function hashCode(obj: string | number | symbol | Date): string;
-/**
- * @summary Defines teh type for a Hashing function
- * @memberOf module:decorator-validation
- * @category Model
- */
-export type HashingFunction = (value: any, ...args: any[]) => string;
-/**
- * @summary Hashes an object by combining the hash of all its properties
- *
- * @param {Record<string, any>} obj
- * @return {string} the resulting hash
- *
- * @function hashObj
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function hashObj(obj: Record<string, any> | any[]): string;
-export declare const DefaultHashingMethod = "default";
-/**
- * @description Manages hashing methods and provides a unified hashing interface
- * @summary A utility class that provides a registry for different hashing functions and methods to hash objects.
- * The class maintains a cache of registered hashing functions and allows setting a default hashing method.
- * It prevents direct instantiation and provides static methods for registration and hashing.
- *
- * @class Hashing
- * @category Model
- *
- * @example
- * ```typescript
- * // Register a custom hashing function
- * Hashing.register('md5', (obj) => createMD5Hash(obj), true);
- *
- * // Hash an object using default method
- * const hash1 = Hashing.hash(myObject);
- *
- * // Hash using specific method
- * const hash2 = Hashing.hash(myObject, 'md5');
- * ```
- */
-export declare class Hashing {
-    /**
-     * @description Current default hashing method identifier
-     * @private
-     */
-    private static current;
-    /**
-     * @description Cache of registered hashing functions
-     * @private
-     */
-    private static cache;
-    private constructor();
-    /**
-     * @description Retrieves a registered hashing function
-     * @summary Fetches a hashing function from the cache by its key. Throws an error if the method is not registered.
-     *
-     * @param {string} key - The identifier of the hashing function to retrieve
-     * @return {HashingFunction} The requested hashing function
-     * @private
-     */
-    private static get;
-    /**
-     * @description Registers a new hashing function
-     * @summary Adds a new hashing function to the registry. Optionally sets it as the default method.
-     * Throws an error if a method with the same key is already registered.
-     *
-     * @param {string} key - The identifier for the hashing function
-     */
-    static register(key: string, func: HashingFunction, setDefault?: boolean): void;
-    static hash(obj: any, method?: string, ...args: any[]): any;
-    static setDefault(method: string): void;
-}

package/lib/types/utils/index.d.ts

@@ -1,11 +0,0 @@
-export * from "./constants";
-export * from "./DateBuilder";
-export * from "./dates";
-export * from "./equality";
-export * from "./hashing";
-export * from "./PathProxy";
-export * from "./registry";
-export * from "./serializers";
-export * from "./serialization";
-export * from "./strings";
-export * from "./types";

package/lib/types/utils/registry.d.ts

@@ -1,68 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @summary Basic interface for Registries
- *
- * @interface IRegistry
- *
- * @category Model
- */
-export interface IRegistry<T> {
-    /**
-     * @summary Registers an Object
-     *
-     * @param {T} obj
-     * @param {any[]} args
-     *
-     * @method
-     */
-    register(obj: T | any, ...args: any[]): void;
-    /**
-     * @summary Retrieves an Object if it can find it
-     *
-     * @param {any} key
-     * @param {any[]} args
-     * @return {T | undefined}
-     *
-     * @method
-     */
-    get(key: any, ...args: any[]): T | undefined;
-}
-/**
- * @summary Basic Builder Registry Interface
- *
- * @template T
- * @interface BuilderRegistry<T>
- *
- * @category Model
- */
-export interface BuilderRegistry<T> extends IRegistry<Constructor<T>> {
-    /**
-     * @summary Retrieves an Builder Object by name if it can
-     *
-     * @param {string} name
-     * @param {any[]} args
-     *
-     * @method
-     */
-    get(name: string, ...args: any[]): Constructor<T> | undefined;
-    /**
-     * @summary Registers a constructor by name
-     *
-     * @param {Constructor<T>} [constructor]
-     * @param {name} name
-     * @param {any[]} args
-     *
-     * @method
-     */
-    register(constructor: Constructor<T>, name?: string, ...args: any[]): void;
-    /**
-     * @summary Builds an Object by name
-     *
-     * @param {{}} obj
-     * @param {any[]} args
-     * @return T
-     *
-     * @method
-     */
-    build(obj: Record<string, any> | T, ...args: any[]): T;
-}

package/lib/types/utils/serialization.d.ts

@@ -1,12 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-import { Serializer } from "./types";
-export declare class Serialization {
-    private static current;
-    private static cache;
-    private constructor();
-    private static get;
-    static register(key: string, func: Constructor<Serializer<any>>, setDefault?: boolean): void;
-    static serialize(obj: any, method?: string, ...args: any[]): any;
-    static deserialize(obj: string, method?: string, ...args: any[]): any;
-    static setDefault(method: string): void;
-}

package/lib/types/utils/serializers.d.ts

@@ -1,41 +0,0 @@
-import { Serializer } from "./types";
-import { Model } from "../model/Model";
-/**
- * @summary Concrete implementation of a {@link Serializer} in JSON format
- * @description JS's native JSON.stringify (used here) is not deterministic
- * and therefore should not be used for hashing purposes
- *
- * To keep dependencies low, we will not implement this, but we recommend
- * implementing a similar {@link JSONSerializer} using 'deterministic-json' libraries
- *
- * @class JSONSerializer
- * @implements Serializer
- *
- * @category Model
- */
-export declare class JSONSerializer<T extends Model<boolean>> implements Serializer<T> {
-    constructor();
-    /**
-     * @summary prepares the model for serialization
-     * @description returns a shallow copy of the object, containing an enumerable {@link ModelKeys#ANCHOR} property
-     * so the object can be recognized upon deserialization
-     *
-     * @param {T} model
-     * @protected
-     */
-    protected preSerialize(model: T, ...args: any[]): Record<string, any>;
-    /**
-     * @summary Rebuilds a model from a serialization
-     * @param {string} str
-     *
-     * @throws {Error} If it fails to parse the string, or to build the model
-     */
-    deserialize(str: string, ...args: any[]): T;
-    /**
-     * @summary Serializes a model
-     * @param {T} model
-     *
-     * @throws {Error} if fails to serialize
-     */
-    serialize(model: T, ...args: any[]): string;
-}

package/lib/types/utils/strings.d.ts

@@ -1,25 +0,0 @@
-/**
- * @summary Util function to provide string format functionality similar to C#'s string.format
- *
- * @param {string} string
- * @param {Array<string | number>} [args] replacements made by order of appearance (replacement0 wil replace {0} and so on)
- * @return {string} formatted string
- *
- * @function stringFormat
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare function stringFormat(string: string, ...args: (string | number)[]): string;
-/**
- * @summary Util function to provide string format functionality similar to C#'s string.format
- * @description alias for {@link stringFormat}
- *
- * @param {string} string
- * @param {string} args replacements made by order of appearance (replacement0 wil replace {0} and so on)
- * @return {string} formatted string
- *
- * @function sf
- * @memberOf module:decorator-validation
- * @category Model
- */
-export declare const sf: typeof stringFormat;

package/lib/types/utils/types.d.ts

@@ -1,35 +0,0 @@
-import { Model } from "../model";
-/**
- * @description Interface for serializing and deserializing model objects
- * @summary Defines the contract for classes that can convert model objects to and from string representations.
- * Serializers are used to persist models or transmit them over networks.
- *
- * @interface Serializer
- * @template T Type of model that can be serialized, must extend Model
- * @memberOf module:decorator-validation
- * @category Model
- */
-export interface Serializer<M extends Model> {
-    /**
-     * @description Converts a model object to a string representation
-     * @summary Serializes a model instance into a string format that can be stored or transmitted.
-     * Additional arguments can be provided to customize the serialization process.
-     *
-     * @param {T} model - The model instance to serialize
-     * @param {...any} args - Additional arguments for the serialization process
-     * @return {string} The serialized representation of the model
-     * @throws {Error} If the model cannot be serialized
-     */
-    serialize(model: M, ...args: any[]): string;
-    /**
-     * @description Reconstructs a model object from its string representation
-     * @summary Deserializes a string back into a model instance.
-     * Additional arguments can be provided to customize the deserialization process.
-     *
-     * @param {string} str - The serialized string to convert back to a model
-     * @param {...any} args - Additional arguments for the deserialization process
-     * @return {T} The reconstructed model instance
-     * @throws {Error} If the string cannot be deserialized into a valid model
-     */
-    deserialize(str: string, ...args: any[]): M;
-}

package/lib/types/validation/Validation.d.ts

@@ -1,53 +0,0 @@
-import { Validator } from "./Validators/Validator";
-import { IValidatorRegistry, ValidatorDefinition } from "./types";
-/**
- * @summary Static class acting as a namespace for the Validation
- *
- * @class Validation
- * @static
- *
- * @category Validation
- */
-export declare class Validation {
-    private static actingValidatorRegistry?;
-    private constructor();
-    /**
-     * @summary Defines the acting ValidatorRegistry
-     *
-     * @param {IValidatorRegistry} validatorRegistry the new implementation of the validator Registry
-     * @param {function(Validator): Validator} [migrationHandler] the method to map the validator if required;
-     */
-    static setRegistry(validatorRegistry: IValidatorRegistry<Validator>, migrationHandler?: (validator: Validator) => Validator): void;
-    /**
-     * @summary Returns the current ValidatorRegistry
-     *
-     * @return IValidatorRegistry, defaults to {@link ValidatorRegistry}
-     */
-    private static getRegistry;
-    /**
-     * @summary Retrieves a validator
-     *
-     * @param {string} validatorKey one of the {@link ValidationKeys}
-     * @return {Validator | undefined} the registered Validator or undefined if there is nono matching the provided key
-     */
-    static get<T extends Validator>(validatorKey: string): T | undefined;
-    /**
-     * @summary Registers the provided validators onto the registry
-     *
-     * @param {T[] | ValidatorDefinition[]} validator
-     */
-    static register<T extends Validator>(...validator: (ValidatorDefinition | T)[]): void;
-    /**
-     * @summary Builds the key to store as Metadata under Reflections
-     * @description concatenates {@link ValidationKeys#REFLECT} with the provided key
-     *
-     * @param {string} key
-     */
-    static key(key: string): string;
-    /**
-     * @summary Returns all registered validation keys
-     */
-    static keys(): string[];
-    static registerDecorator(key: string, decorator: (...args: any[]) => PropertyDecorator): void;
-    static decoratorFromKey(key: string): any;
-}