@nest-omni/core 3.1.1-18 → 3.1.1-20

package/common/examples/paginate-and-map.example.js

@@ -0,0 +1,158 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicPaginationExample = basicPaginationExample;
+exports.syncTransformExample = syncTransformExample;
+exports.asyncTransformExample = asyncTransformExample;
+exports.asyncBatchTransformExample = asyncBatchTransformExample;
+exports.complexAsyncTransformExample = complexAsyncTransformExample;
+exports.iterateExample = iterateExample;
+exports.eachBatchSingleExample = eachBatchSingleExample;
+exports.eachBatchGroupExample = eachBatchGroupExample;
+function basicPaginationExample(repository, pageOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .paginateAndMap(pageOptions);
+        return result;
+    });
+}
+function syncTransformExample(repository, pageOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.isActive = :isActive', { isActive: true })
+            .paginateAndMap(pageOptions, {
+            transform: (items) => {
+                return items.filter(item => item.status === 'approved');
+            },
+        });
+        return result;
+    });
+}
+function asyncTransformExample(repository, pageOptions, externalService) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.isActive = :isActive', { isActive: true })
+            .paginateAndMap(pageOptions, {
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const enrichedItems = yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const additionalData = yield externalService.fetchData(item.id);
+                    return Object.assign(Object.assign({}, item), { additionalData });
+                })));
+                return enrichedItems.filter(item => { var _a; return (_a = item.additionalData) === null || _a === void 0 ? void 0 : _a.isValid; });
+            }),
+        });
+        return result;
+    });
+}
+function asyncBatchTransformExample(repository, pageOptions, batchProcessor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .leftJoinAndSelect('entity.relations', 'relations')
+            .paginateAndMap(pageOptions, {
+            dtoOptions: { includeRelations: true },
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const processedItems = yield batchProcessor.processBatch(items);
+                return processedItems.map(item => (Object.assign(Object.assign({}, item), { processed: true, processedAt: new Date() })));
+            }),
+        });
+        return result;
+    });
+}
+function complexAsyncTransformExample(repository, pageOptions, services) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield repository
+            .createQueryBuilder('entity')
+            .where('entity.createdAt > :date', { date: new Date('2024-01-01') })
+            .paginateAndMap(pageOptions, {
+            skipCount: false,
+            transform: (items) => __awaiter(this, void 0, void 0, function* () {
+                const validatedItems = yield Promise.all(items.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const isValid = yield services.validation.validate(item);
+                        return isValid ? item : null;
+                    }
+                    catch (error) {
+                        console.error(`Validation failed for item ${item.id}:`, error);
+                        return null;
+                    }
+                })));
+                const validItems = validatedItems.filter(item => item !== null);
+                const enrichedItems = yield Promise.all(validItems.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const enrichmentData = yield services.enrichment.enrich(item.id);
+                    return Object.assign(Object.assign({}, item), enrichmentData);
+                })));
+                const finalItems = yield Promise.all(enrichedItems.map((item) => __awaiter(this, void 0, void 0, function* () {
+                    const calculatedFields = yield services.calculation.calculate(item);
+                    return Object.assign(Object.assign({}, item), calculatedFields);
+                })));
+                return finalItems;
+            }),
+        });
+        return result;
+    });
+}
+function iterateExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const queryBuilder = repository
+            .createQueryBuilder('entity')
+            .where('entity.needsProcessing = :needsProcessing', { needsProcessing: true });
+        try {
+            for (var _d = true, _e = __asyncValues(queryBuilder.iterate({ batchSize: 500 })), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const batch = _c;
+                console.log(`Processing batch of ${batch.length} entities`);
+                yield processor.processBatch(batch);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function eachBatchSingleExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield repository
+            .createQueryBuilder('entity')
+            .where('entity.status = :status', { status: 'pending' })
+            .eachBatch((entity) => __awaiter(this, void 0, void 0, function* () {
+            console.log(`Processing entity ${entity.id}`);
+            yield processor.processOne(entity);
+        }), { batchSize: 100, mode: 'single' });
+    });
+}
+function eachBatchGroupExample(repository, processor) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield repository
+            .createQueryBuilder('entity')
+            .where('entity.status = :status', { status: 'pending' })
+            .eachBatch((batch) => __awaiter(this, void 0, void 0, function* () {
+            console.log(`Processing batch of ${batch.length} entities`);
+            yield processor.processBatch(batch);
+        }), { batchSize: 500, mode: 'batch' });
+    });
+}

package/decorators/examples/validation-decorators.example.d.ts

@@ -0,0 +1,69 @@
+export declare class ContactDto {
+    email?: string;
+    phone?: string;
+    wechat?: string;
+}
+export declare class SearchDto {
+    keyword?: string;
+    category?: string;
+    tags?: string[];
+}
+export declare class PasswordDto {
+    password: string;
+}
+export declare class EmailCheckDto {
+    email: string;
+    userService?: any;
+}
+export declare class OrderDto {
+    orderType: 'standard' | 'express';
+    deliveryDate?: Date;
+}
+export declare class DiscountDto {
+    discountType: 'percentage' | 'fixed';
+    discountValue: number;
+    get validatedDiscountValue(): number;
+}
+export declare class UserRegistrationDto {
+    username: string;
+    password: string;
+    confirmPassword: string;
+    validatePassword(password: string): boolean;
+    validatePasswordMatch(confirmPassword: string): boolean;
+}
+export declare class CreateProductDto {
+    name: string;
+    sku: string;
+    categoryId: string;
+    get validatedCategoryId(): string;
+    productService?: any;
+    categoryService?: any;
+    checkSkuUniqueness(sku: string): Promise<boolean>;
+    validateCategoryExists(categoryId: string): Promise<boolean>;
+}
+export declare class EmployeeDto {
+    name: string;
+    personalEmail?: string;
+    workEmail?: string;
+    phone?: string;
+    validatePhoneFormat(phone: string): boolean;
+}
+export declare class PaymentMethodDto {
+    paymentType: 'credit_card' | 'bank_transfer' | 'digital_wallet';
+    creditCard?: {
+        number: string;
+        expiryDate: string;
+        cvv: string;
+    };
+    bankAccount?: {
+        accountNumber: string;
+        routingNumber: string;
+    };
+    digitalWallet?: {
+        provider: string;
+        walletId: string;
+    };
+    validateCreditCard(creditCard: any): boolean;
+    validateBankAccount(bankAccount: any): boolean;
+    validateDigitalWallet(digitalWallet: any): boolean;
+}

package/decorators/examples/validation-decorators.example.js

@@ -0,0 +1,331 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodDto = exports.EmployeeDto = exports.CreateProductDto = exports.UserRegistrationDto = exports.DiscountDto = exports.OrderDto = exports.EmailCheckDto = exports.PasswordDto = exports.SearchDto = exports.ContactDto = void 0;
+const class_validator_1 = require("class-validator");
+const swagger_1 = require("@nestjs/swagger");
+const validator_decorators_1 = require("../validator.decorators");
+const field_decorators_1 = require("../field.decorators");
+class ContactDto {
+}
+exports.ContactDto = ContactDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsEmail)(),
+    (0, validator_decorators_1.AtLeastOneField)(['email', 'phone', 'wechat']),
+    __metadata("design:type", String)
+], ContactDto.prototype, "email", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ContactDto.prototype, "phone", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], ContactDto.prototype, "wechat", void 0);
+class SearchDto {
+}
+exports.SearchDto = SearchDto;
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)(),
+    (0, validator_decorators_1.AtLeastOneField)(['keyword', 'category', 'tags'], {
+        message: 'Please provide at least one search criteria: keyword, category, or tags',
+    }),
+    __metadata("design:type", String)
+], SearchDto.prototype, "keyword", void 0);
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)(),
+    __metadata("design:type", String)
+], SearchDto.prototype, "category", void 0);
+__decorate([
+    (0, field_decorators_1.StringFieldOptional)({ each: true }),
+    __metadata("design:type", Array)
+], SearchDto.prototype, "tags", void 0);
+class PasswordDto {
+}
+exports.PasswordDto = PasswordDto;
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        if (!value || value.length < 8)
+            return false;
+        const hasUppercase = /[A-Z]/.test(value);
+        const hasLowercase = /[a-z]/.test(value);
+        const hasNumber = /[0-9]/.test(value);
+        return hasUppercase && hasLowercase && hasNumber;
+    }, {
+        message: 'Password must be at least 8 characters with uppercase, lowercase, and number',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], PasswordDto.prototype, "password", void 0);
+class EmailCheckDto {
+}
+exports.EmailCheckDto = EmailCheckDto;
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => __awaiter(void 0, void 0, void 0, function* () {
+        const userService = args.object.userService;
+        if (!userService) {
+            console.warn('UserService not found, skipping email check');
+            return true;
+        }
+        const exists = yield userService.checkEmailExists(value);
+        return !exists;
+    }), {
+        message: 'Email already exists in the system',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], EmailCheckDto.prototype, "email", void 0);
+class OrderDto {
+}
+exports.OrderDto = OrderDto;
+__decorate([
+    (0, swagger_1.ApiProperty)({ enum: ['standard', 'express'] }),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], OrderDto.prototype, "orderType", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => {
+        const object = args.object;
+        if (object.orderType === 'express') {
+            return value !== null && value !== undefined;
+        }
+        return true;
+    }, {
+        message: 'Delivery date is required for express orders',
+    }),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Date)
+], OrderDto.prototype, "deliveryDate", void 0);
+class DiscountDto {
+    get validatedDiscountValue() {
+        return this.discountValue;
+    }
+}
+exports.DiscountDto = DiscountDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], DiscountDto.prototype, "discountType", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", Number)
+], DiscountDto.prototype, "discountValue", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value, args) => {
+        const object = args.object;
+        if (object.discountType === 'percentage') {
+            return value >= 0 && value <= 100;
+        }
+        else if (object.discountType === 'fixed') {
+            return value > 0;
+        }
+        return false;
+    }, {
+        message: 'Invalid discount value for the selected discount type',
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], DiscountDto.prototype, "validatedDiscountValue", null);
+class UserRegistrationDto {
+    validatePassword(password) {
+        if (!password || password.length < 8)
+            return false;
+        const hasUppercase = /[A-Z]/.test(password);
+        const hasLowercase = /[a-z]/.test(password);
+        const hasNumber = /[0-9]/.test(password);
+        const hasSpecial = /[!@#$%^&*]/.test(password);
+        return hasUppercase && hasLowercase && hasNumber && hasSpecial;
+    }
+    validatePasswordMatch(confirmPassword) {
+        return confirmPassword === this.password;
+    }
+}
+exports.UserRegistrationDto = UserRegistrationDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "username", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePassword', {
+        message: 'Password does not meet security requirements',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "password", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePasswordMatch'),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], UserRegistrationDto.prototype, "confirmPassword", void 0);
+class CreateProductDto {
+    get validatedCategoryId() {
+        return this.categoryId;
+    }
+    checkSkuUniqueness(sku) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.productService) {
+                console.warn('ProductService not found');
+                return true;
+            }
+            const exists = yield this.productService.skuExists(sku);
+            return !exists;
+        });
+    }
+    validateCategoryExists(categoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.categoryService) {
+                console.warn('CategoryService not found');
+                return true;
+            }
+            return yield this.categoryService.exists(categoryId);
+        });
+    }
+}
+exports.CreateProductDto = CreateProductDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "name", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('checkSkuUniqueness', {
+        message: 'SKU already exists',
+    }),
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "sku", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], CreateProductDto.prototype, "categoryId", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateCategoryExists', {
+        message: 'Category does not exist',
+    }),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [])
+], CreateProductDto.prototype, "validatedCategoryId", null);
+class EmployeeDto {
+    validatePhoneFormat(phone) {
+        if (!phone)
+            return true;
+        const phoneRegex = /^\+?[1-9]\d{1,14}$/;
+        return phoneRegex.test(phone);
+    }
+}
+exports.EmployeeDto = EmployeeDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "name", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        const workDomains = ['company.com', 'corp.com'];
+        const domain = value === null || value === void 0 ? void 0 : value.split('@')[1];
+        return !workDomains.includes(domain);
+    }, {
+        message: 'Personal email should not be from work domains',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, validator_decorators_1.AtLeastOneField)(['personalEmail', 'workEmail']),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "personalEmail", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidation)((value) => {
+        const workDomains = ['company.com', 'corp.com'];
+        const domain = value === null || value === void 0 ? void 0 : value.split('@')[1];
+        return workDomains.includes(domain);
+    }, {
+        message: 'Work email must be from company domains',
+    }),
+    (0, class_validator_1.IsEmail)(),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "workEmail", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validatePhoneFormat'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", String)
+], EmployeeDto.prototype, "phone", void 0);
+class PaymentMethodDto {
+    validateCreditCard(creditCard) {
+        var _a;
+        if (!creditCard)
+            return true;
+        const number = (_a = creditCard.number) === null || _a === void 0 ? void 0 : _a.replace(/\s/g, '');
+        if (!/^\d{13,19}$/.test(number))
+            return false;
+        let sum = 0;
+        let isEven = false;
+        for (let i = number.length - 1; i >= 0; i--) {
+            let digit = parseInt(number[i], 10);
+            if (isEven) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            isEven = !isEven;
+        }
+        return sum % 10 === 0;
+    }
+    validateBankAccount(bankAccount) {
+        if (!bankAccount)
+            return true;
+        const accountValid = /^\d{8,17}$/.test(bankAccount.accountNumber);
+        const routingValid = /^\d{9}$/.test(bankAccount.routingNumber);
+        return accountValid && routingValid;
+    }
+    validateDigitalWallet(digitalWallet) {
+        var _a;
+        if (!digitalWallet)
+            return true;
+        const validProviders = ['paypal', 'alipay', 'wechat_pay', 'apple_pay'];
+        return validProviders.includes((_a = digitalWallet.provider) === null || _a === void 0 ? void 0 : _a.toLowerCase());
+    }
+}
+exports.PaymentMethodDto = PaymentMethodDto;
+__decorate([
+    (0, swagger_1.ApiProperty)(),
+    __metadata("design:type", String)
+], PaymentMethodDto.prototype, "paymentType", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateCreditCard'),
+    (0, validator_decorators_1.AtLeastOneField)(['creditCard', 'bankAccount', 'digitalWallet']),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "creditCard", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateBankAccount'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "bankAccount", void 0);
+__decorate([
+    (0, validator_decorators_1.CustomValidationMethod)('validateDigitalWallet'),
+    (0, swagger_1.ApiProperty)({ required: false }),
+    __metadata("design:type", Object)
+], PaymentMethodDto.prototype, "digitalWallet", void 0);

package/decorators/use-dto.decorator.d.ts

@@ -2,3 +2,4 @@ import type { AbstractEntity } from '../common/abstract.entity';
 import type { AbstractDto } from '../common/dto/abstract.dto';
 import type { Constructor } from '../common/types';
 export declare function UseDto(dtoClass: Constructor<AbstractDto, [AbstractEntity, unknown]>): ClassDecorator;
+export declare function UseDto<Entity, Dto extends AbstractDto>(dtoClass: Constructor<Dto, [Entity, unknown?]>): ClassDecorator;

package/decorators/use-dto.decorator.js

@@ -4,5 +4,15 @@ exports.UseDto = UseDto;
 function UseDto(dtoClass) {
     return (ctor) => {
         ctor.prototype.dtoClass = dtoClass;
+        ctor.dtoClass = dtoClass;
+        if (!ctor.prototype.toDto) {
+            ctor.prototype.toDto = function (options) {
+                const DtoClass = this.constructor.dtoClass || dtoClass;
+                if (!DtoClass) {
+                    throw new Error(`You need to use @UseDto on class (${this.constructor.name}) be able to call toDto function`);
+                }
+                return new DtoClass(this, options);
+            };
+        }
     };
 }

package/decorators/validator.decorators.d.ts

@@ -1,5 +1,5 @@
 import type { ValidationOptions } from 'class-validator';
-import { IsPhoneNumber as isPhoneNumber } from 'class-validator';
+import { IsPhoneNumber as isPhoneNumber, ValidationArguments, ValidatorConstraintInterface } from 'class-validator';
 export declare function IsPassword(validationOptions?: ValidationOptions): PropertyDecorator;
 export declare function IsPhoneNumber(validationOptions?: ValidationOptions & {
     region?: Parameters<typeof isPhoneNumber>[0];
@@ -9,3 +9,10 @@ export declare function IsUndefinable(options?: ValidationOptions): PropertyDeco
 export declare function IsEmptyable(options?: ValidationOptions): PropertyDecorator;
 export declare function IsNullable(options?: ValidationOptions): PropertyDecorator;
 export declare function IsHttpUrl(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;
+export declare class AtLeastOneFieldConstraint implements ValidatorConstraintInterface {
+    validate(value: any, args: ValidationArguments): boolean;
+    defaultMessage(args: ValidationArguments): string;
+}
+export declare function AtLeastOneField(properties: string[], validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidation<T = any>(validationCallback: (value: T, args: ValidationArguments) => boolean | Promise<boolean>, validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function CustomValidationMethod(methodName: string, validationOptions?: ValidationOptions): PropertyDecorator;