@decaf-ts/decorator-validation 1.10.5 → 1.11.0

package/lib/model/Builder.cjs

@@ -1,130 +1,401 @@
 "use strict";
-// import { Model } from "./Model";
-// import { Constructor, ModelArg } from "./types";
-// import { ObjectAccumulator } from "typed-object-accumulator";
-//
-// export interface DecorateOption<M extends Model> {
-//   decorate(...decorators: PropertyDecorator[]): ModelBuilder<M>;
-// }
-//
-// export class AttributeBuilder<M extends Model, N extends keyof M, T>
-//   implements DecorateOption<M>
-// {
-//   constructor(
-//     protected parent: ModelBuilder<M>,
-//     readonly attr: keyof M,
-//     readonly type: T
-//   ) {}
-//
-//   private decorators: Set<PropertyDecorator> = new Set();
-//
-//   decorate(...decorators: PropertyDecorator[]): ModelBuilder<M> {
-//     for (const decorator of decorators) {
-//       if (this.decorators.has(decorator))
-//         throw new Error(`Decorator "${decorator}" has already been used`);
-//       this.decorators.add(decorator);
-//     }
-//     return this.parent;
-//   }
-//
-//   undecorate(...decorators: PropertyDecorator[]) {
-//     for (const decorator of decorators) {
-//       if (!this.decorators.has(decorator))
-//         throw new Error(
-//           `Decorator "${decorator}" is not applied to ${this.attr as string}`
-//         );
-//       this.decorators.delete(decorator);
-//     }
-//     return this.parent;
-//   }
-//
-//   apply(obj: Constructor<M>): ModelBuilder<M> {
-//     Object.defineProperty(obj, this.attr, {
-//       value: undefined,
-//     });
-//     this.decorators.forEach((decorator) => {
-//       try {
-//         decorator(obj, this.attr as any);
-//       } catch (e: unknown) {
-//         throw new Error(
-//           `Failed to apply decorator to property "${this.attr as any}": ${e}`
-//         );
-//       }
-//     });
-//     //
-//     // const c = `${this.attr.toString()}` as const;
-//     //
-//     // const temp: {
-//     //   [c]: T
-//     // } = {
-//     //   [this.attr]: 0
-//     // }
-//
-//     return this.parent.accumulate() as unknown as ModelBuilder<M & Record<N, T>>;
-//   }
-// }
-//
-// export class ModelBuilder<M extends Model = Model> extends ObjectAccumulator<M>{
-//   private attributes: Map<string, AttributeBuilder<M, any, any>> = new Map();
-//   private _name?: string;
-//
-//   private _parent?: Constructor<M>;
-//
-//   setName(name: string) {
-//     this._name = name;
-//     return this;
-//   }
-//
-//   private attribute<T, N extends symbol>(
-//     attr: string,
-//     type: T
-//   ): AttributeBuilder<M, N, T> {
-//     return new AttributeBuilder<M, N, T>(this, attr as any, type);
-//   }
-//
-//   string(attr: string) {
-//     return this.attribute(attr, String.name);
-//   }
-//
-//   number(attr: string) {
-//     return this.attribute(attr, Number.name);
-//   }
-//
-//   date(attr: string) {
-//     return this.attribute(attr, Date.name);
-//   }
-//
-//   bigint(attr: string) {
-//     return this.attribute(attr, BigInt.name);
-//   }
-//
-//   instance(clazz: Constructor<any>, attr: string) {
-//     return this.attribute(attr, clazz.name);
-//   }
-//
-//   build(): Constructor<M> {
-//     if (!this._name) throw new Error("name is required");
-//
-//     const DynamicBuiltClass = class<M> extends Model {
-//       constructor(arg?: ModelArg<M>) {
-//         super(arg as any);
-//       }
-//     };
-//
-//     Object.defineProperty(DynamicBuiltClass, "name", {
-//       value: this._name,
-//       writable: false,
-//     });
-//
-//     this.attributes.forEach((attribute) => {
-//       attribute.apply(DynamicBuiltClass as any);
-//     });
-//
-//     return DynamicBuiltClass as unknown as Constructor<M>;
-//   }
-//
-//   static get builder() {
-//     return new ModelBuilder();
-//   }
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelBuilder = exports.AttributeBuilder = void 0;
+const Model_1 = require("./Model.cjs");
+const typed_object_accumulator_1 = require("typed-object-accumulator");
+const decoration_1 = require("@decaf-ts/decoration");
+const decorators_1 = require("./decorators.cjs");
+const decorators_2 = require("./../validation/decorators.cjs");
+const constants_1 = require("./../validation/Validators/constants.cjs");
+const Validation_1 = require("./../validation/Validation.cjs");
+class AttributeBuilder {
+    constructor(parent, attr, declaredType) {
+        this.parent = parent;
+        this.attr = attr;
+        this.declaredType = declaredType;
+        this.decorators = [];
+    }
+    decorate(...decorators) {
+        for (const decorator of decorators) {
+            if (this.decorators.includes(decorator))
+                throw new Error(`Decorator "${decorator}" has already been used`);
+            this.decorators.push(decorator);
+        }
+        return this.parent;
+    }
+    undecorate(...decorators) {
+        for (const decorator of decorators) {
+            const index = this.decorators.indexOf(decorator);
+            if (index < 0)
+                throw new Error(`Decorator "${decorator}" is not applied to ${this.attr}`);
+            this.decorators.splice(index, 1);
+        }
+        return this.parent;
+    }
+    required(messageOrMeta) {
+        const meta = AttributeBuilder.asMeta(messageOrMeta);
+        const message = typeof messageOrMeta === "string"
+            ? messageOrMeta
+            : AttributeBuilder.resolveMessage(meta);
+        return this.decorate((0, decorators_2.required)(message));
+    }
+    min(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const value = meta?.[constants_1.ValidationKeys.MIN] ??
+            (meta ? undefined : valueOrMeta);
+        if (value === undefined)
+            throw new Error(`Missing ${constants_1.ValidationKeys.MIN} for ${String(this.attr)}`);
+        return this.decorate((0, decorators_2.min)(value, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    max(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const value = meta?.[constants_1.ValidationKeys.MAX] ??
+            (meta ? undefined : valueOrMeta);
+        if (value === undefined)
+            throw new Error(`Missing ${constants_1.ValidationKeys.MAX} for ${String(this.attr)}`);
+        return this.decorate((0, decorators_2.max)(value, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    step(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const value = meta?.[constants_1.ValidationKeys.STEP] ??
+            (meta ? undefined : valueOrMeta);
+        if (value === undefined)
+            throw new Error(`Missing ${constants_1.ValidationKeys.STEP} for ${String(this.attr)}`);
+        return this.decorate((0, decorators_2.step)(value, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    minlength(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const value = meta?.[constants_1.ValidationKeys.MIN_LENGTH] ??
+            (meta ? undefined : valueOrMeta);
+        if (value === undefined)
+            throw new Error(`Missing ${constants_1.ValidationKeys.MIN_LENGTH} for ${String(this.attr)}`);
+        return this.decorate((0, decorators_2.minlength)(value, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    maxlength(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const value = meta?.[constants_1.ValidationKeys.MAX_LENGTH] ??
+            (meta ? undefined : valueOrMeta);
+        if (value === undefined)
+            throw new Error(`Missing ${constants_1.ValidationKeys.MAX_LENGTH} for ${String(this.attr)}`);
+        return this.decorate((0, decorators_2.maxlength)(value, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    pattern(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const rawPattern = meta?.[constants_1.ValidationKeys.PATTERN] ??
+            (meta ? undefined : valueOrMeta);
+        const regex = AttributeBuilder.patternFromString(rawPattern) ?? /.*/;
+        return this.decorate((0, decorators_2.pattern)(regex, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    email(messageOrMeta) {
+        const meta = AttributeBuilder.asMeta(messageOrMeta);
+        const message = typeof messageOrMeta === "string"
+            ? messageOrMeta
+            : AttributeBuilder.resolveMessage(meta);
+        return this.decorate((0, decorators_2.email)(message));
+    }
+    url(messageOrMeta) {
+        const meta = AttributeBuilder.asMeta(messageOrMeta);
+        const message = typeof messageOrMeta === "string"
+            ? messageOrMeta
+            : AttributeBuilder.resolveMessage(meta);
+        return this.decorate((0, decorators_2.url)(message));
+    }
+    type(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const types = meta?.customTypes ?? meta?.type ?? (meta ? undefined : valueOrMeta);
+        return this.decorate((0, decorators_2.type)(types, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    date(formatOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(formatOrMeta);
+        const format = meta?.[constants_1.ValidationKeys.FORMAT] ??
+            (meta ? undefined : formatOrMeta);
+        return this.decorate((0, decorators_2.date)(format, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    password(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const rawPattern = meta?.[constants_1.ValidationKeys.PATTERN] ??
+            (meta ? undefined : valueOrMeta);
+        const regex = AttributeBuilder.patternFromString(rawPattern);
+        return this.decorate((0, decorators_2.password)(regex, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    list(clazzOrMeta, collection, message) {
+        const meta = AttributeBuilder.asMeta(clazzOrMeta);
+        const clazz = meta?.clazz ?? (meta ? undefined : clazzOrMeta);
+        const typeOfCollection = meta?.type ?? collection;
+        return this.decorate((0, decorators_2.list)(clazz, typeOfCollection, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    set(clazzOrMeta, message) {
+        if (AttributeBuilder.isMetadataPayload(clazzOrMeta))
+            return this.list(clazzOrMeta);
+        return this.list(clazzOrMeta, "Set", message);
+    }
+    enum(valueOrMeta, message) {
+        const meta = AttributeBuilder.asMeta(valueOrMeta);
+        const values = meta?.[constants_1.ValidationKeys.ENUM] ?? (meta ? undefined : valueOrMeta);
+        return this.decorate((0, decorators_2.option)(values, AttributeBuilder.resolveMessage(meta, message)));
+    }
+    option(value, message) {
+        return this.enum(value, message);
+    }
+    static isMetadataPayload(value) {
+        if (!value)
+            return false;
+        if (value instanceof Date)
+            return false;
+        if (value instanceof RegExp)
+            return false;
+        if (Array.isArray(value))
+            return false;
+        return typeof value === "object";
+    }
+    static asMeta(value) {
+        return AttributeBuilder.isMetadataPayload(value)
+            ? value
+            : undefined;
+    }
+    static resolveMessage(meta, fallback) {
+        return meta?.message ?? fallback;
+    }
+    static patternFromString(pattern) {
+        if (!pattern)
+            return undefined;
+        if (pattern instanceof RegExp)
+            return pattern;
+        const match = pattern.match(/^\/(.+)\/([gimsuy]*)$/);
+        if (match)
+            return new RegExp(match[1], match[2]);
+        return new RegExp(pattern);
+    }
+    resolveComparison(propertyOrMeta, key, options) {
+        const meta = AttributeBuilder.asMeta(propertyOrMeta);
+        if (meta) {
+            return {
+                target: meta[key],
+                options: {
+                    label: meta.label,
+                    message: meta.message,
+                },
+            };
+        }
+        return { target: propertyOrMeta, options };
+    }
+    equals(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.EQUALS, options);
+        return this.decorate((0, decorators_2.eq)(target, resolvedOptions));
+    }
+    eq(propertyOrMeta, options) {
+        return this.equals(propertyOrMeta, options);
+    }
+    different(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.DIFF, options);
+        return this.decorate((0, decorators_2.diff)(target, resolvedOptions));
+    }
+    diff(propertyOrMeta, options) {
+        return this.different(propertyOrMeta, options);
+    }
+    lessThan(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.LESS_THAN, options);
+        return this.decorate((0, decorators_2.lt)(target, resolvedOptions));
+    }
+    lt(propertyOrMeta, options) {
+        return this.lessThan(propertyOrMeta, options);
+    }
+    lessThanOrEqual(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.LESS_THAN_OR_EQUAL, options);
+        return this.decorate((0, decorators_2.lte)(target, resolvedOptions));
+    }
+    lte(propertyOrMeta, options) {
+        return this.lessThanOrEqual(propertyOrMeta, options);
+    }
+    greaterThan(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.GREATER_THAN, options);
+        return this.decorate((0, decorators_2.gt)(target, resolvedOptions));
+    }
+    gt(propertyOrMeta, options) {
+        return this.greaterThan(propertyOrMeta, options);
+    }
+    greaterThanOrEqual(propertyOrMeta, options) {
+        const { target, options: resolvedOptions } = this.resolveComparison(propertyOrMeta, constants_1.ValidationKeys.GREATER_THAN_OR_EQUAL, options);
+        return this.decorate((0, decorators_2.gte)(target, resolvedOptions));
+    }
+    gte(propertyOrMeta, options) {
+        return this.greaterThanOrEqual(propertyOrMeta, options);
+    }
+    description(desc) {
+        return this.decorate((0, decoration_1.description)(desc));
+    }
+    /**
+     * Applies the attribute metadata and decorators to the provided constructor.
+     */
+    build(constructor) {
+        const target = constructor.prototype;
+        const propKey = this.attr;
+        if (!Object.getOwnPropertyDescriptor(target, propKey)) {
+            Object.defineProperty(target, propKey, {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value: undefined,
+            });
+        }
+        if (this.declaredType) {
+            Reflect.defineMetadata(decoration_1.DecorationKeys.DESIGN_TYPE, this.declaredType, target, propKey);
+        }
+        (0, decoration_1.prop)()(target, propKey);
+        this.decorators.forEach((decorator) => {
+            try {
+                decorator(target, propKey);
+            }
+            catch (e) {
+                throw new Error(`Failed to apply decorator to property "${this.attr}": ${e}`);
+            }
+        });
+    }
+}
+exports.AttributeBuilder = AttributeBuilder;
+class ListAttributeBuilder {
+    constructor(parent, attribute, collection) {
+        this.parent = parent;
+        this.attribute = attribute;
+        this.collection = collection;
+    }
+    ofPrimitives(clazz, message) {
+        this.attribute.list(clazz, this.collection, message);
+        return this.parent;
+    }
+    ofModel() {
+        const nestedBuilder = ModelBuilder.builder();
+        const originalBuild = nestedBuilder.build;
+        let cachedConstructor;
+        const factory = (() => {
+            return function () {
+                if (!cachedConstructor) {
+                    cachedConstructor = Reflect.apply(originalBuild, nestedBuilder, []);
+                }
+                return cachedConstructor;
+            };
+        })();
+        this.attribute.list(factory, this.collection);
+        nestedBuilder.build = new Proxy(originalBuild, {
+            apply: (target, thisArg, argArray) => {
+                cachedConstructor = Reflect.apply(target, thisArg, argArray);
+                return this.parent;
+            },
+        });
+        return nestedBuilder;
+    }
+}
+class ModelBuilder extends typed_object_accumulator_1.ObjectAccumulator {
+    constructor() {
+        super(...arguments);
+        this.attributes = new Map();
+    }
+    setName(name) {
+        this._name = name;
+        return this;
+    }
+    description(desc) {
+        this._description = desc;
+        return this;
+    }
+    attribute(attr, type) {
+        const existing = this.attributes.get(attr);
+        if (existing) {
+            if (existing.declaredType !== type)
+                throw new Error(`Attribute "${String(attr)}" already exists with a different type`);
+            return existing;
+        }
+        const attributeBuilder = new AttributeBuilder(this, attr, type);
+        this.attributes.set(attr, attributeBuilder);
+        return attributeBuilder;
+    }
+    string(attr) {
+        return this.attribute(attr, String);
+    }
+    number(attr) {
+        return this.attribute(attr, Number);
+    }
+    date(attr) {
+        return this.attribute(attr, Date);
+    }
+    bigint(attr) {
+        return this.attribute(attr, BigInt);
+    }
+    instance(clazz, attr) {
+        return this.attribute(attr, clazz);
+    }
+    model(attr) {
+        const mm = new ModelBuilder();
+        mm.build = new Proxy(mm.build, {
+            apply: (target, thisArg, argArray) => {
+                const built = Reflect.apply(target, thisArg, argArray);
+                return this.instance(built, attr);
+            },
+        });
+        return mm;
+    }
+    listOf(attr, collection = "Array") {
+        const listType = (collection === "Set" ? Set : Array);
+        const attribute = this.attribute(attr, listType);
+        return new ListAttributeBuilder(this, attribute, collection);
+    }
+    build() {
+        if (!this._name)
+            throw new Error("name is required");
+        const Parent = this._parent ?? Model_1.Model;
+        class DynamicBuiltClass extends Parent {
+            constructor(arg) {
+                super(arg);
+            }
+        }
+        Object.defineProperty(DynamicBuiltClass, "name", {
+            value: this._name,
+            writable: false,
+        });
+        for (const attribute of this.attributes.values()) {
+            attribute.build(DynamicBuiltClass);
+        }
+        let result = (0, decorators_1.model)()(DynamicBuiltClass);
+        if (this._description)
+            result = (0, decoration_1.description)(this._description)(result);
+        return result;
+    }
+    static builder() {
+        return new ModelBuilder();
+    }
+    static from(meta, name) {
+        if (!meta)
+            throw new Error("metadata is required");
+        const builder = ModelBuilder.builder();
+        const derivedName = name ?? `GeneratedModel${Date.now()}`;
+        builder.setName(derivedName);
+        const properties = meta.properties || {};
+        const validations = meta.validation || {};
+        for (const [prop, designType] of Object.entries(properties)) {
+            const attribute = builder.attribute(prop, designType || Object);
+            const propValidation = validations[prop];
+            if (propValidation) {
+                for (const [key, validationMeta] of Object.entries(propValidation)) {
+                    const handler = attribute[key];
+                    if (typeof handler === "function") {
+                        handler.call(attribute, validationMeta);
+                        continue;
+                    }
+                    try {
+                        const decoratorFactory = Validation_1.Validation.decoratorFromKey(key);
+                        const decorator = typeof decoratorFactory === "function"
+                            ? decoratorFactory(validationMeta)
+                            : decoratorFactory;
+                        attribute.decorate(decorator);
+                    }
+                    catch {
+                        // ignore unknown decorators
+                    }
+                }
+            }
+        }
+        return builder.build();
+    }
+}
+exports.ModelBuilder = ModelBuilder;
 //# sourceMappingURL=Builder.js.map

package/lib/model/Builder.d.ts

@@ -0,0 +1,84 @@
+import { Model } from "./Model";
+import { ObjectAccumulator } from "typed-object-accumulator";
+import { Constructor } from "@decaf-ts/decoration";
+import { ComparisonValidatorOptions } from "../validation/types";
+import { ExtendedMetadata } from "../overrides/types";
+type BuildableModel = Model & Record<PropertyKey, any>;
+export interface DecorateOption<M extends Model> {
+    decorate(...decorators: PropertyDecorator[]): ModelBuilder<M>;
+}
+export declare class AttributeBuilder<M extends BuildableModel, N extends keyof M, T> implements DecorateOption<M> {
+    protected parent: ModelBuilder<M>;
+    readonly attr: N;
+    readonly declaredType: T;
+    constructor(parent: ModelBuilder<M>, attr: N, declaredType: T);
+    private decorators;
+    decorate(...decorators: PropertyDecorator[]): ModelBuilder<M>;
+    undecorate(...decorators: PropertyDecorator[]): ModelBuilder<M>;
+    required(messageOrMeta?: string | Record<string, any>): ModelBuilder<M>;
+    min(valueOrMeta: number | Date | string | Record<string, any>, message?: string): ModelBuilder<M>;
+    max(valueOrMeta: number | Date | string | Record<string, any>, message?: string): ModelBuilder<M>;
+    step(valueOrMeta: number | Record<string, any>, message?: string): ModelBuilder<M>;
+    minlength(valueOrMeta: number | Record<string, any>, message?: string): ModelBuilder<M>;
+    maxlength(valueOrMeta: number | Record<string, any>, message?: string): ModelBuilder<M>;
+    pattern(valueOrMeta: RegExp | string | Record<string, any>, message?: string): ModelBuilder<M>;
+    email(messageOrMeta?: string | Record<string, any>): ModelBuilder<M>;
+    url(messageOrMeta?: string | Record<string, any>): ModelBuilder<M>;
+    type(valueOrMeta: Constructor | (() => Constructor) | (Constructor | (() => Constructor))[] | Record<string, any>, message?: string): ModelBuilder<M>;
+    date(formatOrMeta?: string | Record<string, any>, message?: string): ModelBuilder<M>;
+    password(valueOrMeta?: RegExp | string | Record<string, any>, message?: string): ModelBuilder<M>;
+    list(clazzOrMeta: Constructor | (() => Constructor) | (Constructor | (() => Constructor))[] | Record<string, any>, collection?: "Array" | "Set", message?: string): ModelBuilder<M>;
+    set(clazzOrMeta: Constructor | Record<string, any>, message?: string): ModelBuilder<M>;
+    enum(valueOrMeta: any[] | Record<any, any> | Record<string, any>, message?: string): ModelBuilder<M>;
+    option(value: any[] | Record<any, any>, message?: string): ModelBuilder<M>;
+    private static isMetadataPayload;
+    private static asMeta;
+    private static resolveMessage;
+    private static patternFromString;
+    private resolveComparison;
+    equals(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    eq(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    different(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    diff(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    lessThan(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    lt(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    lessThanOrEqual(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    lte(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    greaterThan(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    gt(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    greaterThanOrEqual(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    gte(propertyOrMeta: string | Record<string, any>, options?: Omit<ComparisonValidatorOptions, "async" | "description">): ModelBuilder<M>;
+    description(desc: string): ModelBuilder<M>;
+    /**
+     * Applies the attribute metadata and decorators to the provided constructor.
+     */
+    build(constructor: Constructor<M>): void;
+}
+declare class ListAttributeBuilder<M extends BuildableModel, N extends keyof M> {
+    private readonly parent;
+    private readonly attribute;
+    private readonly collection;
+    constructor(parent: ModelBuilder<M>, attribute: AttributeBuilder<M, N, any>, collection: "Array" | "Set");
+    ofPrimitives(clazz: Constructor | (() => Constructor) | (Constructor | (() => Constructor))[], message?: string): ModelBuilder<M>;
+    ofModel<MM extends BuildableModel>(): ModelBuilder<MM>;
+}
+export declare class ModelBuilder<M extends BuildableModel = BuildableModel> extends ObjectAccumulator<M> {
+    private attributes;
+    private _name?;
+    private _description?;
+    private _parent?;
+    setName(name: string): this;
+    description(desc: string): this;
+    private attribute;
+    string<N extends keyof M>(attr: N): AttributeBuilder<M, N, StringConstructor>;
+    number<N extends keyof M>(attr: N): AttributeBuilder<M, N, NumberConstructor>;
+    date<N extends keyof M>(attr: N): AttributeBuilder<M, N, DateConstructor>;
+    bigint<N extends keyof M>(attr: N): AttributeBuilder<M, N, BigIntConstructor>;
+    instance<N extends keyof M>(clazz: Constructor<any>, attr: N): AttributeBuilder<M, N, Constructor<any>>;
+    model<MM extends Model, N extends keyof M>(attr: N): ModelBuilder<MM>;
+    listOf<N extends keyof M>(attr: N, collection?: "Array" | "Set"): ListAttributeBuilder<M, N>;
+    build(): Constructor<M>;
+    static builder<M extends BuildableModel = BuildableModel>(): ModelBuilder<M>;
+    static from<N extends Model, M extends ExtendedMetadata<N>>(meta: M, name?: string): Constructor<N>;
+}
+export {};