@decaf-ts/decorator-validation 1.20.0 → 1.21.1

package/lib/types/model/types.d.ts

@@ -1,145 +0,0 @@
-import type { ConditionalAsync } from "../types";
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import { Model } from "./Model";
-/**
- * @description Function type for building model instances from objects
- * @summary Type definition for a model builder function that populates model properties
- * @template T
- * @param {T} self - The target model instance to populate
- * @param {T | Record<string, any>} [obj] - The source object containing properties to copy
- * @return {T} - The populated model instance
- * @typedef ModelBuilderFunction
- * @memberOf module:decorator-validation
- */
-export type ModelBuilderFunction = <T extends Model>(self: T, obj?: T | Record<string, any>) => T;
-/**
- * @description Type representing valid argument types for model constructors
- * @summary Definition of a Model Constructor Argument that can be a complete model, partial model, or plain object
- * @template T
- * @typedef ModelArg
- * @memberOf module:decorator-validation
- * @see ModelConstructor
- */
-export type ModelArg<T> = T | Partial<T> | Record<string, any>;
-/**
- * @description Specialized constructor type for Model classes
- * @summary Definition of a Model Constructor that creates instances of Model subclasses
- * @template T
- * @param {ModelArg<T>} [model] - Initial data to populate the model with
- * @param {any[]} [args] - Additional constructor arguments
- * @return {T} - An instance of the model class
- * @typedef ModelConstructor
- * @memberOf module:decorator-validation
- */
-export type ModelConstructor<T extends Model> = {
-    new (model?: ModelArg<T>, ...args: any[]): T;
-};
-/**
- * @description Interface for objects that can be validated.
- * @summary Defines the Validation API for validation behavior on models, supporting both synchronous and asynchronous validations.
- * Implementers must provide a `hasErrors` method that performs the validation and returns either validation errors or undefined if validation passes.
- *
- * @template Async - A boolean flag indicating whether the validation is asynchronous (`true`) or synchronous (`false`).
- *
- * @param {any[]} [args] - Optional arguments to control validation behavior passed to the validation method.
- *
- * @interface Validatable
- * @category Model
- * @memberOf module:decorator-validation
- *
- * @example
- * ```typescript
- * // Synchronous validation example
- * class SyncModel implements Validatable<false> {
- *   hasErrors(...args: any[]): ModelErrorDefinition | undefined {
- *     // perform synchronous validation logic
- *     return undefined; // or return errors if invalid
- *   }
- * }
- *
- * // Asynchronous validation example
- * class AsyncModel implements Validatable<true> {
- *   async hasErrors(...args: any[]): Promise<ModelErrorDefinition | undefined> {
- *     // perform asynchronous validation logic
- *     return undefined; // or return errors if invalid
- *   }
- * }
- * ```
- */
-export interface Validatable<Async extends boolean = false> {
-    /**
-     * @description Validates the object against its validation rules.
-     * @summary Validates the model and returns the {@link ModelErrorDefinition} if any errors exist, or `undefined` if no errors.
-     *
-     * @param {any[]} [args] - Optional arguments that may influence validation logic.
-     * @return {ConditionalAsync<Async, ModelErrorDefinition | undefined>} Validation errors or undefined, conditionally wrapped in a Promise if asynchronous.
-     *
-     * @method
-     */
-    hasErrors(...args: any[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;
-}
-/**
- * @description Interface for objects that can be serialized to string
- * @summary Defines the serialization API for model objects
- * @interface Serializable
- * @memberOf module:decorator-validation
- * @category Model
- */
-export interface Serializable {
-    /**
-     * @description Converts the object to a serialized string representation
-     * @summary Serializes the model to a string format
-     * @return {string} - The serialized string representation
-     * @method
-     */
-    serialize(...args: any[]): string;
-}
-/**
- * @description Interface for objects that can generate a hash representation
- * @summary Defines the hashing API for model objects
- * @interface Hashable
- * @memberOf module:decorator-validation
- * @category Model
- */
-export interface Hashable {
-    /**
-     * @description Generates a unique hash string for the object
-     * @summary Creates a hash string representation of the object
-     * @return {string} - Hash value representing the object
-     * @method
-     */
-    hash(...args: any[]): string;
-}
-/**
- * @description Interface for objects that can be compared with other objects
- * @summary Defines the equality comparison API for model objects
- * @template T
- * @interface Comparable
- * @memberOf module:decorator-validation
- * @category Model
- */
-export interface Comparable {
-    /**
-     * @description Determines if this object is equal to another object
-     * @summary Compares this object with another for equality
-     * @param {T} other - The object to compare with
-     * @param {any[]} [args] - Additional arguments for comparison
-     * @return {boolean} - True if the objects are equal, false otherwise
-     * @method
-     */
-    equals<T extends Model>(this: T, other: T, ...args: any[]): boolean;
-    compare<T extends Model>(this: T, other: T, ...args: any[]): Comparison<T> | undefined;
-}
-export type SetterKeyFor<OBJ, K extends keyof OBJ> = `set${Capitalize<string & K>}`;
-export type SetterFor<OBJ, K extends keyof OBJ, R> = (value: OBJ[K]) => R;
-export type Builder<OUT, ARGS extends any[] = any[], IN = OUT> = {
-    [K in keyof OUT as K extends keyof Model | "build" ? never : K]: OUT[K];
-} & {
-    [K in keyof OUT as K extends keyof Model | "build" ? never : SetterKeyFor<OUT, K>]: SetterFor<OUT, K, IN>;
-} & {
-    build: (...args: ARGS) => OUT | Promise<OUT>;
-};
-export type Comparison<M, K extends keyof M = keyof M> = Record<K, {
-    other: M[K] | undefined;
-    current: M[K] | undefined;
-}>;

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

@@ -1,13 +0,0 @@
-import { ConditionalAsync } from "../types";
-/**
- * Wraps a value in a Promise if the `async` flag is true.
- *
- * @template T - The type of the value being wrapped.
- * @template Async - A boolean type that determines if the result should be wrapped in a Promise.
- *
- * @param value - The value to return directly or wrap in a Promise.
- * @param async - If true, the value is wrapped in a resolved Promise. If false or undefined, the value is returned as-is.
- *
- * @returns The original value or a Promise resolving to it, depending on the `async` flag.
- */
-export declare function toConditionalPromise<T, Async extends boolean>(value: T, async?: Async): ConditionalAsync<Async, T>;

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

@@ -1,92 +0,0 @@
-import { ModelErrorDefinition } from "./ModelErrorDefinition";
-import type { Model } from "./Model";
-import { ConditionalAsync } from "../types";
-export declare function validateChildValue<M extends Model>(prop: string, childValue: any, parentModel: M, allowedTypes: string[], async: boolean, ...propsToIgnore: string[]): string | undefined | ModelErrorDefinition | Promise<string | undefined | ModelErrorDefinition>;
-/**
- * @description Retrieves nested properties to ignore for child validation
- * @param parentProp - The property of the parent model
- * @param propsToIgnore - Properties to ignore from the parent model
- * @returns An array of properties to ignore for the child model
- */
-export declare function getChildNestedPropsToIgnore(parentProp: string, ...propsToIgnore: string[]): string[];
-export declare function validateDecorator<M extends Model, Async extends boolean = false>(model: M, value: any, decorator: any, async?: Async): ConditionalAsync<Async, string | undefined>;
-/**
- * @description
- * Executes validation logic for a set of decorators applied to a model's property, handling both
- * synchronous and asynchronous validations, including support for nested validations and lists.
- *
- * @summary
- * Iterates over an array of decorator metadata objects and applies each validation rule to the
- * provided value. For list decorators (`ValidationKeys.LIST`), it performs element-wise validation,
- * supporting nested model validation and type checks. If the `async` flag is set, asynchronous
- * validation is supported using `Promise.all`. The result is a record mapping validation keys to
- * error messages, or `undefined` if no errors are found.
- *
- * @template M - A type parameter extending `Model`, representing the model type being validated.
- * @template Async - A boolean indicating whether validation should be performed asynchronously.
- *
- * @param {M} model - The model instance that the validation is associated with.
- * @param {string} prop - The model field name
- * @param {any} value - The value to be validated against the provided decorators.
- * @param {DecoratorMetadataAsync} decorators - An object of metadata representing validation decorators.
- * @param {Async} [async] - Optional flag indicating whether validation should be performed asynchronously.
- *
- * @return {ConditionalAsync<Async, Record<string, string>> | undefined}
- * Returns either a record of validation errors (keyed by the decorator key) or `undefined` if no errors are found.
- * If `async` is true, the return value is a Promise resolving to the same structure.
- *
- * @function validateDecorators
- */
-export declare function validateDecorators<M extends Model, Async extends boolean = false>(model: M, prop: string, value: any, decorators: any, async?: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, Record<string, string> | undefined>;
-/**
- * @function validate
- * @template M
- * @template Async
- * @memberOf module:decorator-validation
- * @category Model
- *
- * @description
- * Validates the properties of a {@link Model} instance using registered decorators.
- * Supports both synchronous and asynchronous validation flows, depending on the `async` flag.
- *
- * @summary
- * This function inspects a given model object, identifies decorated properties that require validation,
- * and applies the corresponding validation rules. It also supports nested model validation and gracefully
- * merges any validation errors. For collections (Array/Set), it enforces the presence of the `@list` decorator
- * and checks the type of elements. If a property is a nested model, it will call `hasErrors` on it and flatten
- * the nested error keys using dot notation.
- *
- * @param {M} model - The model instance to be validated. Must extend from {@link Model}.
- * @param {Async} [async] - A flag indicating whether validation should be asynchronous.
- * @param {...string} propsToIgnore - A variadic list of property names that should be skipped during validation.
- *
- * @returns {ConditionalAsync<Async, ModelErrorDefinition | undefined>}
- * Returns either a {@link ModelErrorDefinition} containing validation errors,
- * or `undefined` if no errors are found. When `async` is `true`, returns a Promise.
- *
- * @see {@link Model}
- * @see {@link ModelErrorDefinition}
- * @see {@link validateDecorators}
- * @see {@link getValidatableProperties}
- *
- * @mermaid
- * sequenceDiagram
- *     participant Caller
- *     participant validate
- *     participant getValidatableProperties
- *     participant validateDecorators
- *     participant ModelInstance
- *     Caller->>validate: call with obj, async, propsToIgnore
- *     validate->>getValidatableProperties: retrieve decorated props
- *     loop for each property
- *         validate->>validateDecorators: validate using decorators
- *         alt is nested model
- *             validate->>ModelInstance: call hasErrors()
- *         end
- *     end
- *     alt async
- *         validate->>validate: Promise.allSettled for errors
- *     end
- *     validate-->>Caller: return ModelErrorDefinition | undefined
- */
-export declare function validate<M extends Model<boolean>, Async extends boolean = false>(model: M, async: Async, ...propsToIgnore: string[]): ConditionalAsync<Async, ModelErrorDefinition | undefined>;

package/lib/types/overrides/Metadata.d.ts

@@ -1,132 +0,0 @@
-import { Model } from "../model/Model";
-import "@decaf-ts/decoration";
-import { Constructor } from "@decaf-ts/decoration";
-import { designTypeReturn, ExtendedMetadata } from "./types";
-import { ValidationMetadata } from "../validation/types";
-declare module "@decaf-ts/decoration" {
-    namespace Metadata {
-        /**
-         * @description Retrieves validation metadata for a specific property of a model
-         * @summary Fetches validation rules and constraints that were applied to a property
-         * via decorators. The optional key parameter allows drilling down to specific
-         * validation types (e.g., 'required', 'min', 'max').
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @param {string} [key] - Optional specific validation key to retrieve (e.g., 'required', 'pattern')
-         * @return {any} The validation metadata object or value at the specified key
-         *
-         * @example
-         * class User extends Model {
-         *   @required()
-         *   @maxLength(100)
-         *   name!: string;
-         * }
-         *
-         * // Get all validation metadata for 'name'
-         * const validations = Metadata.validationFor(User, 'name');
-         *
-         * // Get specific validation metadata
-         * const required = Metadata.validationFor(User, 'name', 'required');
-         */
-        function validationFor<M extends Model, P extends keyof M = keyof M, K extends string = string>(this: Metadata, model: Constructor<M>, property?: keyof M, key?: string): (K extends string ? ValidationMetadata : P extends keyof M ? Record<string, ValidationMetadata> : Record<keyof M, Record<string, ValidationMetadata>>) | undefined;
-        /**
-         * @description Retrieves all validatable for a model
-         * @param model
-         */
-        function validatableProperties<M extends Model>(model: Constructor<M>, ...propsToIgnore: string[]): string[];
-        /**
-         * @description Retrieves extended metadata for a model or a specific key within it
-         * @summary When called with a constructor only, returns the entire metadata object
-         * associated with the model, including validation rules, property types, relationships,
-         * and other decorator-applied metadata. This override extends the base Metadata.get
-         * method with type-safe support for ExtendedMetadata.
-         *
-         * @template M - The model type
-         * @template META - The extended metadata type, defaults to ExtendedMetadata<M>
-         * @param {Constructor<M>} model - The target constructor used to locate the metadata record
-         * @param {keyof M} prop - Optional property of the model.
-         * @return {META|undefined} The complete metadata object for the model, or undefined if no metadata exists
-         *
-         * @example
-         * class Article extends Model {
-         *   @pk()
-         *   @type(Number)
-         *   id!: number;
-         *
-         *   @required()
-         *   @maxLength(200)
-         *   title!: string;
-         *
-         *   @oneToMany(() => Comment, { update: true, delete: true }, true)
-         *   comments!: Comment[];
-         * }
-         *
-         * // Get all metadata for the Article model
-         * const metadata = Metadata.get<Article>(Article);
-         * // metadata contains:
-         * // - property definitions
-         * // - validation rules
-         * // - relationship mappings
-         * // - primary key information
-         * // - column mappings
-         *
-         * @remarks
-         * The @ts-expect-error directive is used because this declaration intentionally
-         * overrides the signature from the base module to provide enhanced type information
-         * specific to the decorator-validation system.
-         */
-        function get<M, META extends ExtendedMetadata<M> = ExtendedMetadata<M>>(model: Constructor<M>, prop?: keyof M): META | undefined;
-        /**
-         * @description Retrieves the original constructor name for a model
-         * @summary Fetches the original constructor name for a model from the metadata of a model.
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @return {string} The metadata object or value
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get the constructor name for 'User'
-         * const constName = Metadata.modelName(User);
-         */
-        function modelName<M>(model: Constructor<M>): string;
-        /**
-         * @description Retrieves all allowed types for a model or a property
-         * @summary Retrieves all allowed types for a model or a property from it's metadata.
-         *
-         * @template M - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @return {any[]} An array of the allowed types
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get all validation metadata for 'User'
-         * const allowedTypes = Metadata.meallowedTypestadata(User);
-         */
-        function allowedTypes<M>(model: Constructor<M>, property?: keyof M): any[];
-        /**
-         * @description Retrieves all allowed types for a model or a property
-         * @summary Retrieves all allowed types for a model or a property from it's metadata.
-         *
-         * @template model - The model type extending from Model
-         * @param {Constructor<M>} model - The constructor of the target model class
-         * @param {keyof M} property - The property name to retrieve validation for
-         * @return {designTypeReturn} An object of the designtypes
-         *
-         * @example
-         * class User extends Model {
-         *
-         * // Get the designtypes for property name
-         * const { designTypes, designType } = Metadata.getPropDesignTypes(User.constructor, 'name');
-         */
-        function getPropDesignTypes<M>(model: Constructor<M>, property: keyof M): designTypeReturn;
-        function isModel(target: Record<string, any>): boolean;
-        function isPropertyModel<M extends Model>(target: M, attribute: string): boolean | string | undefined;
-        function getAttributes<V extends Model>(model: Constructor<V> | V): string[];
-    }
-}

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

@@ -1,4 +0,0 @@
-import "./overrides";
-export * from "./Metadata";
-export * from "./overrides";
-export * from "./types";

package/lib/types/overrides/overrides.d.ts

@@ -1 +0,0 @@
-import "./Metadata";

package/lib/types/overrides/types.d.ts

@@ -1,17 +0,0 @@
-import { BasicMetadata } from "@decaf-ts/decoration";
-import { ValidatorOptions } from "../validation/types";
-export type ExtendedMetadata<M> = BasicMetadata<M> & {
-    validation: Record<keyof M, ValidatorOptions>;
-};
-/**
- * @description Return type for design type information.
- * @summary Defines the structure of the return type for functions that provide design type information.
- * @property {any[]} designTypes An array of design types.
- * @property {any} designType The primary design type.
- * @typedef {object} designTypeReturn
- * @memberOf module:decorator-validation
- */
-export type designTypeReturn = {
-    designTypes: any[];
-    designType: any;
-};

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

@@ -1 +0,0 @@
-export * from "./validation";

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

@@ -1,28 +0,0 @@
-import { Model } from "../model/Model";
-import { ModelErrorDefinition } from "../model/ModelErrorDefinition";
-/**
- * @description Conditionally wraps a type in a `Promise` based on the `Async` flag.
- * @summary Utility type that resolves to `T` if `Async` is `false`, or to `Promise<T>` if `Async` is `true`.
- * Used to abstract the return type of functions that may be either synchronous or asynchronous depending on a flag.
- *
- * @template Async A boolean flag indicating whether the result should be asynchronous (`true`) or synchronous (`false`).
- * @template T The base type to return directly or to wrap in a `Promise`.
- *
- * @example
- * ```typescript
- * // Synchronous result
- * type SyncResult: string | number = ConditionalAsync<false, string | number>;
- *
- * // Asynchronous result
- * type AsyncResult: Promise<string | number> = ConditionalAsync<true, string | number>;
- * ```
- * @memberOf module:decorator-validation
- */
-export type ConditionalAsync<Async extends boolean, T> = Async extends true ? Promise<T> : T;
-export type DecoratorMetadataAsync = {
-    async?: boolean;
-};
-/**
- * @deprecated
- */
-export type ModelConditionalAsync<M> = M extends Model<true> ? Promise<ModelErrorDefinition | undefined> : ModelErrorDefinition | undefined;

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";