@hosterai/types 0.0.30 → 0.0.31

package/dist/validators/addon-field-validator.d.ts

@@ -1,7 +1,10 @@
 import { ValidationError } from 'class-validator';
 /**
  * Validates an AddonFieldDto object.
- * Since AddonFieldDto is an empty subclass of FieldDto, this delegates to validateFieldDto.
+ *
+ * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
+ * via the dispatcher; its errors are merged into the returned list under the
+ * `field` property.
  *
  * @param data The object to validate as an AddonFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.

package/dist/validators/addon-field-validator.js

@@ -1,14 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateAddonFieldDto = validateAddonFieldDto;
-const field_validator_1 = require("./field-validator");
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const addon_field_dto_1 = require("../dtos/addon-field.dto");
+const any_field_validator_1 = require("./any-field-validator");
 /**
  * Validates an AddonFieldDto object.
- * Since AddonFieldDto is an empty subclass of FieldDto, this delegates to validateFieldDto.
+ *
+ * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
+ * via the dispatcher; its errors are merged into the returned list under the
+ * `field` property.
  *
  * @param data The object to validate as an AddonFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */
 function validateAddonFieldDto(data) {
-    return (0, field_validator_1.validateFieldDto)(data);
+    const dto = (0, class_transformer_1.plainToInstance)(addon_field_dto_1.AddonFieldDto, data);
+    const errors = (0, class_validator_1.validateSync)(dto);
+    const field = data === null || data === void 0 ? void 0 : data.field;
+    if (field && typeof field === 'object') {
+        const fieldErrors = (0, any_field_validator_1.validateAnyFieldDto)(field);
+        if (fieldErrors.length > 0) {
+            const wrapped = new class_validator_1.ValidationError();
+            wrapped.property = 'field';
+            wrapped.value = field;
+            wrapped.children = fieldErrors;
+            errors.push(wrapped);
+        }
+    }
+    return errors;
 }

package/dist/validators/addon-field-validator.spec.js

@@ -2,16 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const addon_field_validator_1 = require("./addon-field-validator");
-const field_type_enum_1 = require("../enums/field-type.enum");
 const language_enum_1 = require("../enums/language.enum");
-const baseValidDto = {
+const validField = {
     id: 'addon-1',
     label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Addon Field' }],
-    value: 'test-value',
-    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+    type: 'TEXT',
     required: true,
     disabled: false,
-    upgradable: false,
+    value: 'test-value',
+};
+const baseValidDto = {
+    field: validField,
 };
 describe('AddonFieldDto Validator', () => {
     describe('Valid cases', () => {
@@ -20,26 +21,19 @@ describe('AddonFieldDto Validator', () => {
         });
     });
     describe('Missing required fields', () => {
-        it('should return errors when all fields are missing', () => {
+        it('should return error when the nested `field` is missing', () => {
             const errors = (0, addon_field_validator_1.validateAddonFieldDto)({});
-            const requiredProps = [
-                'id',
-                'label',
-                'value',
-                'type',
-                'required',
-                'disabled',
-            ];
-            for (const prop of requiredProps) {
-                expect(errors.some((e) => e.property === prop)).toBe(true);
-            }
+            expect(errors.some((e) => e.property === 'field')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
-        it('should return error for invalid type enum', () => {
-            const dto = { ...baseValidDto, type: 'not-a-valid-type' };
-            const errors = (0, addon_field_validator_1.validateAddonFieldDto)(dto);
-            expect(errors.some((e) => e.property === 'type')).toBe(true);
+        it('should surface errors from the nested field validator under `field`', () => {
+            var _a;
+            const errors = (0, addon_field_validator_1.validateAddonFieldDto)({
+                field: { ...validField, type: 'NOT_REAL' },
+            });
+            const fieldErr = errors.find((e) => e.property === 'field');
+            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'type')).toBe(true);
         });
     });
 });

package/dist/validators/any-field-validator.d.ts

@@ -0,0 +1,10 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates any field DTO by reading the string-literal `type` discriminator and
+ * routing to the matching concrete DTO's validation.
+ *
+ * @param data Object with a string `type` discriminator.
+ * @returns ValidationError[] from the concrete DTO, or a synthetic error if
+ *   `type` is missing or not a recognized literal.
+ */
+export declare function validateAnyFieldDto(data: object): ValidationError[];

package/dist/validators/any-field-validator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAnyFieldDto = validateAnyFieldDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const any_field_dto_1 = require("../dtos/fields/any-field.dto");
+/**
+ * Validates any field DTO by reading the string-literal `type` discriminator and
+ * routing to the matching concrete DTO's validation.
+ *
+ * @param data Object with a string `type` discriminator.
+ * @returns ValidationError[] from the concrete DTO, or a synthetic error if
+ *   `type` is missing or not a recognized literal.
+ */
+function validateAnyFieldDto(data) {
+    const type = data === null || data === void 0 ? void 0 : data.type;
+    if (typeof type !== 'string' || !(type in any_field_dto_1.FIELD_DTO_CLASSES)) {
+        const err = new class_validator_1.ValidationError();
+        err.property = 'type';
+        err.value = type;
+        err.constraints = {
+            isFieldType: `type must be one of: ${Object.keys(any_field_dto_1.FIELD_DTO_CLASSES).join(', ')}`,
+        };
+        return [err];
+    }
+    const Cls = any_field_dto_1.FIELD_DTO_CLASSES[type];
+    return (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(Cls, data));
+}

package/dist/validators/any-field-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/validators/any-field-validator.spec.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const any_field_validator_1 = require("./any-field-validator");
+const language_enum_1 = require("../enums/language.enum");
+const minimalBase = (type) => ({
+    id: 'x',
+    label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'X' }],
+    type,
+    required: true,
+    disabled: false,
+});
+describe('AnyField dispatcher', () => {
+    it('routes a TEXT payload to TextFieldDto validation', () => {
+        expect((0, any_field_validator_1.validateAnyFieldDto)(minimalBase('TEXT'))).toHaveLength(0);
+    });
+    it('routes a NUMBER payload to NumberFieldDto validation', () => {
+        expect((0, any_field_validator_1.validateAnyFieldDto)(minimalBase('NUMBER'))).toHaveLength(0);
+    });
+    it('returns a synthetic type error when discriminator is missing', () => {
+        const errors = (0, any_field_validator_1.validateAnyFieldDto)({ id: 'x' });
+        expect(errors.some((e) => e.property === 'type')).toBe(true);
+    });
+    it('returns a synthetic type error when discriminator is unknown', () => {
+        const errors = (0, any_field_validator_1.validateAnyFieldDto)({
+            ...minimalBase('NOT_REAL'),
+        });
+        expect(errors.some((e) => e.property === 'type')).toBe(true);
+    });
+    it('propagates type-specific validation errors from the concrete DTO', () => {
+        const errors = (0, any_field_validator_1.validateAnyFieldDto)({
+            ...minimalBase('PHONE'),
+            value: 'not-a-phone',
+        });
+        expect(errors.some((e) => e.property === 'value')).toBe(true);
+    });
+});

package/dist/validators/attribute-field-validator.d.ts

@@ -2,6 +2,10 @@ import { ValidationError } from 'class-validator';
 /**
  * Validates an AttributeFieldDto object using class-validator decorators.
  *
+ * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
+ * by dispatching to the matching concrete DTO's validator; its errors are
+ * merged into the returned list under the `field` property.
+ *
  * @param data The object to validate as an AttributeFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */

package/dist/validators/attribute-field-validator.js

@@ -4,14 +4,30 @@ exports.validateAttributeFieldDto = validateAttributeFieldDto;
 const class_validator_1 = require("class-validator");
 const class_transformer_1 = require("class-transformer");
 const attribute_field_dto_1 = require("../dtos/attribute-field.dto");
+const any_field_validator_1 = require("./any-field-validator");
 /**
  * Validates an AttributeFieldDto object using class-validator decorators.
  *
+ * The nested `field` (a discriminated `AnyFieldDto`) is validated separately
+ * by dispatching to the matching concrete DTO's validator; its errors are
+ * merged into the returned list under the `field` property.
+ *
  * @param data The object to validate as an AttributeFieldDto.
  * @returns An array of validation errors, empty if validation succeeds.
  */
 function validateAttributeFieldDto(data) {
     const dto = (0, class_transformer_1.plainToInstance)(attribute_field_dto_1.AttributeFieldDto, data);
     const errors = (0, class_validator_1.validateSync)(dto);
+    const field = data === null || data === void 0 ? void 0 : data.field;
+    if (field && typeof field === 'object') {
+        const fieldErrors = (0, any_field_validator_1.validateAnyFieldDto)(field);
+        if (fieldErrors.length > 0) {
+            const wrapped = new class_validator_1.ValidationError();
+            wrapped.property = 'field';
+            wrapped.value = field;
+            wrapped.children = fieldErrors;
+            errors.push(wrapped);
+        }
+    }
     return errors;
 }

package/dist/validators/attribute-field-validator.spec.js

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const attribute_field_validator_1 = require("./attribute-field-validator");
-const field_type_enum_1 = require("../enums/field-type.enum");
 const language_enum_1 = require("../enums/language.enum");
-const baseValidDto = {
+const validField = {
     id: 'attr-1',
     label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'CPU Cores' }],
-    value: '4',
-    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+    type: 'NUMBER',
     required: true,
     disabled: false,
-    upgradable: false,
+    value: 4,
+};
+const baseValidDto = {
+    field: validField,
 };
 describe('AttributeFieldDto Validator', () => {
     describe('Valid cases', () => {
-        it('should return no errors for a valid DTO (inherited fields only)', () => {
+        it('should return no errors for a valid DTO with only field', () => {
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(baseValidDto)).toHaveLength(0);
         });
         it('should return no errors with optional visibleInOrder and visibleInClientPanel', () => {
@@ -35,6 +36,12 @@ describe('AttributeFieldDto Validator', () => {
             expect((0, attribute_field_validator_1.validateAttributeFieldDto)(dto)).toHaveLength(0);
         });
     });
+    describe('Missing required fields', () => {
+        it('should return error when the nested `field` is missing', () => {
+            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({});
+            expect(errors.some((e) => e.property === 'field')).toBe(true);
+        });
+    });
     describe('AllOrNone constraint on repeatableMin/repeatableMax', () => {
         it('should return error when only repeatableMin is provided', () => {
             const dto = { ...baseValidDto, repeatableMin: 1 };
@@ -76,20 +83,23 @@ describe('AttributeFieldDto Validator', () => {
             expect(errors.some((e) => e.property === 'repeatableMax')).toBe(true);
         });
     });
-    describe('Inherited FieldDto validation', () => {
-        it('should return errors when inherited required fields are missing', () => {
-            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({});
-            const requiredProps = [
-                'id',
-                'label',
-                'value',
-                'type',
-                'required',
-                'disabled',
-            ];
-            for (const prop of requiredProps) {
-                expect(errors.some((e) => e.property === prop)).toBe(true);
-            }
+    describe('Nested field validation', () => {
+        it('should surface errors from the nested field validator under `field`', () => {
+            var _a;
+            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({
+                field: { ...validField, type: 'NUMBER', value: 'four' },
+            });
+            const fieldErr = errors.find((e) => e.property === 'field');
+            expect(fieldErr).toBeDefined();
+            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'value')).toBe(true);
+        });
+        it('should surface a type error when nested type literal is unknown', () => {
+            var _a;
+            const errors = (0, attribute_field_validator_1.validateAttributeFieldDto)({
+                field: { ...validField, type: 'NOT_REAL' },
+            });
+            const fieldErr = errors.find((e) => e.property === 'field');
+            expect((_a = fieldErr === null || fieldErr === void 0 ? void 0 : fieldErr.children) === null || _a === void 0 ? void 0 : _a.some((c) => c.property === 'type')).toBe(true);
         });
     });
 });

package/dist/validators/field-validator.d.ts

@@ -1,8 +1,6 @@
 import { ValidationError } from 'class-validator';
 /**
- * Validates a FieldDto object using class-validator decorators.
- *
- * @param data The object to validate as a FieldDto.
- * @returns An array of validation errors, empty if validation succeeds.
+ * @deprecated Use `validateAnyFieldDto` (or a concrete per-type validator like
+ * `validateTextFieldDto`) instead. Kept for one release for backward compatibility.
  */
 export declare function validateFieldDto(data: object): ValidationError[];

package/dist/validators/field-validator.js

@@ -1,17 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateFieldDto = validateFieldDto;
-const class_validator_1 = require("class-validator");
-const class_transformer_1 = require("class-transformer");
-const field_dto_1 = require("../dtos/field.dto");
+const any_field_validator_1 = require("./any-field-validator");
 /**
- * Validates a FieldDto object using class-validator decorators.
- *
- * @param data The object to validate as a FieldDto.
- * @returns An array of validation errors, empty if validation succeeds.
+ * @deprecated Use `validateAnyFieldDto` (or a concrete per-type validator like
+ * `validateTextFieldDto`) instead. Kept for one release for backward compatibility.
  */
 function validateFieldDto(data) {
-    const dto = (0, class_transformer_1.plainToInstance)(field_dto_1.FieldDto, data);
-    const errors = (0, class_validator_1.validateSync)(dto);
-    return errors;
+    return (0, any_field_validator_1.validateAnyFieldDto)(data);
 }

package/dist/validators/field-validator.spec.js

@@ -2,99 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("reflect-metadata");
 const field_validator_1 = require("./field-validator");
-const field_type_enum_1 = require("../enums/field-type.enum");
 const language_enum_1 = require("../enums/language.enum");
 const baseValidDto = {
     id: 'test-id',
     label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Test Label' }],
-    value: 'test-value',
-    type: field_type_enum_1.FieldTypeEnum.TEXT_BOX,
+    type: 'TEXT',
     required: true,
     disabled: false,
-    upgradable: false,
 };
-describe('FieldDto Validator', () => {
+describe('Deprecated validateFieldDto (dispatcher delegate)', () => {
     describe('Valid cases', () => {
-        it('should return no errors for a valid DTO', () => {
+        it('routes a TEXT payload', () => {
             expect((0, field_validator_1.validateFieldDto)(baseValidDto)).toHaveLength(0);
         });
-        it('should return no errors for a valid DTO with optional error messages', () => {
-            const dto = {
-                ...baseValidDto,
-                regexValidationErrorMessage: [
-                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid format' },
-                ],
-                remoteValidationErrorMessage: [
-                    { language: language_enum_1.LanguageEnum.ENGLISH, text: 'Invalid value' },
-                ],
-            };
-            expect((0, field_validator_1.validateFieldDto)(dto)).toHaveLength(0);
-        });
-    });
-    describe('Missing required fields', () => {
-        it('should return errors for all missing required fields (except upgradable)', () => {
-            const errors = (0, field_validator_1.validateFieldDto)({});
-            const requiredProps = [
-                'id',
-                'label',
-                'value',
-                'type',
-                'required',
-                'disabled',
-            ];
-            for (const prop of requiredProps) {
-                expect(errors.some((e) => e.property === prop)).toBe(true);
-            }
-        });
-        it('should return error if value is missing', () => {
-            const dto = { ...baseValidDto };
-            delete dto.value;
-            const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        it('routes a NUMBER payload', () => {
+            expect((0, field_validator_1.validateFieldDto)({ ...baseValidDto, type: 'NUMBER', value: 1 })).toHaveLength(0);
         });
     });
     describe('Invalid field values', () => {
-        it.each([
-            [{ ...baseValidDto, type: 'not-a-valid-type' }, 'type'],
-            [{}, 'id'],
-            [
-                {
-                    ...baseValidDto,
-                    regexValidation: 'regex',
-                    regexValidationErrorMessage: 'not-an-array',
-                },
-                'regexValidationErrorMessage',
-            ],
-            [
-                {
-                    ...baseValidDto,
-                    triggersRemoteValidation: true,
-                    remoteValidationErrorMessage: 'not-an-array',
-                },
-                'remoteValidationErrorMessage',
-            ],
-        ])('should return error for invalid %s', (dto, expectedProp) => {
-            const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.length).toBeGreaterThan(0);
-            expect(errors.some((e) => e.property === expectedProp)).toBe(true);
-        });
-    });
-    describe('Invalid `value` field', () => {
-        it.each([
-            [true, 'boolean'],
-            [null, 'null'],
-            [undefined, 'undefined'],
-            [{}, 'object'],
-            [[], 'array'],
-        ])('should return error if value is invalid type (%s)', (invalidValue, _label) => {
-            const dto = { ...baseValidDto, value: invalidValue };
-            const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        it('returns a synthetic type error when discriminator is unknown', () => {
+            const errors = (0, field_validator_1.validateFieldDto)({
+                ...baseValidDto,
+                type: 'not-a-valid-type',
+            });
+            expect(errors.some((e) => e.property === 'type')).toBe(true);
         });
-        it('should return error if value is empty string when required', () => {
-            const dto = { ...baseValidDto, value: '' };
-            const errors = (0, field_validator_1.validateFieldDto)(dto);
-            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        it('returns errors for missing required base fields after routing', () => {
+            const errors = (0, field_validator_1.validateFieldDto)({ type: 'TEXT' });
+            for (const prop of ['id', 'label', 'required', 'disabled']) {
+                expect(errors.some((e) => e.property === prop)).toBe(true);
+            }
         });
     });
 });

package/dist/validators/fields/boolean-field-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a BooleanFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a BooleanFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateBooleanFieldDto(data: object): ValidationError[];

package/dist/validators/fields/boolean-field-validator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateBooleanFieldDto = validateBooleanFieldDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const boolean_field_dto_1 = require("../../dtos/fields/boolean-field.dto");
+/**
+ * Validates a BooleanFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a BooleanFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateBooleanFieldDto(data) {
+    return (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(boolean_field_dto_1.BooleanFieldDto, data));
+}

package/dist/validators/fields/boolean-field-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/validators/fields/boolean-field-validator.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const boolean_field_validator_1 = require("./boolean-field-validator");
+const language_enum_1 = require("../../enums/language.enum");
+const baseValidDto = {
+    id: 'bool-1',
+    label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Accept Terms' }],
+    type: 'BOOLEAN',
+    required: true,
+    disabled: false,
+};
+describe('BooleanFieldDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid DTO', () => {
+            expect((0, boolean_field_validator_1.validateBooleanFieldDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors with a boolean value', () => {
+            expect((0, boolean_field_validator_1.validateBooleanFieldDto)({ ...baseValidDto, value: true })).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        it('should return errors for all missing required fields', () => {
+            const errors = (0, boolean_field_validator_1.validateBooleanFieldDto)({});
+            for (const prop of ['id', 'label', 'required', 'disabled']) {
+                expect(errors.some((e) => e.property === prop)).toBe(true);
+            }
+        });
+    });
+    describe('Invalid field values', () => {
+        it('should return error for wrong type literal', () => {
+            const errors = (0, boolean_field_validator_1.validateBooleanFieldDto)({ ...baseValidDto, type: 'TEXT' });
+            expect(errors.some((e) => e.property === 'type')).toBe(true);
+        });
+        it('should return error for non-boolean value', () => {
+            const errors = (0, boolean_field_validator_1.validateBooleanFieldDto)({
+                ...baseValidDto,
+                value: 'true',
+            });
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
+        });
+    });
+});

package/dist/validators/fields/countries-field-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a CountriesFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CountriesFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateCountriesFieldDto(data: object): ValidationError[];

package/dist/validators/fields/countries-field-validator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCountriesFieldDto = validateCountriesFieldDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const countries_field_dto_1 = require("../../dtos/fields/countries-field.dto");
+/**
+ * Validates a CountriesFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CountriesFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateCountriesFieldDto(data) {
+    return (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(countries_field_dto_1.CountriesFieldDto, data));
+}

package/dist/validators/fields/countries-field-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';

package/dist/validators/fields/countries-field-validator.spec.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const countries_field_validator_1 = require("./countries-field-validator");
+const language_enum_1 = require("../../enums/language.enum");
+const country_enum_1 = require("../../enums/country.enum");
+const baseValidDto = {
+    id: 'countries-1',
+    label: [{ language: language_enum_1.LanguageEnum.ENGLISH, text: 'Countries' }],
+    type: 'COUNTRIES',
+    required: true,
+    disabled: false,
+};
+describe('CountriesFieldDto Validator', () => {
+    describe('Valid cases', () => {
+        it('should return no errors for a valid minimal DTO', () => {
+            expect((0, countries_field_validator_1.validateCountriesFieldDto)(baseValidDto)).toHaveLength(0);
+        });
+        it('should return no errors with a valid value array', () => {
+            expect((0, countries_field_validator_1.validateCountriesFieldDto)({
+                ...baseValidDto,
+                value: [country_enum_1.CountryEnum.GREECE, country_enum_1.CountryEnum.UNITED_STATES],
+            })).toHaveLength(0);
+        });
+    });
+    describe('Missing required fields', () => {
+        it('should return errors for all missing required fields', () => {
+            const errors = (0, countries_field_validator_1.validateCountriesFieldDto)({});
+            for (const prop of ['id', 'label', 'required', 'disabled']) {
+                expect(errors.some((e) => e.property === prop)).toBe(true);
+            }
+        });
+    });
+    describe('Invalid field values', () => {
+        it.each([
+            [{ ...baseValidDto, type: 'TEXT' }, 'type'],
+            [{ ...baseValidDto, value: 'GR' }, 'value'],
+            [{ ...baseValidDto, value: ['NOT_A_COUNTRY'] }, 'value'],
+        ])('should return error for invalid %#', (dto, expectedProp) => {
+            const errors = (0, countries_field_validator_1.validateCountriesFieldDto)(dto);
+            expect(errors.some((e) => e.property === expectedProp)).toBe(true);
+        });
+    });
+});

package/dist/validators/fields/currency-field-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a CurrencyFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CurrencyFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+export declare function validateCurrencyFieldDto(data: object): ValidationError[];

package/dist/validators/fields/currency-field-validator.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCurrencyFieldDto = validateCurrencyFieldDto;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const currency_field_dto_1 = require("../../dtos/fields/currency-field.dto");
+/**
+ * Validates a CurrencyFieldDto object using class-validator decorators.
+ *
+ * @param data The object to validate as a CurrencyFieldDto.
+ * @returns An array of validation errors, empty if validation succeeds.
+ */
+function validateCurrencyFieldDto(data) {
+    return (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(currency_field_dto_1.CurrencyFieldDto, data));
+}

package/dist/validators/fields/currency-field-validator.spec.d.ts

@@ -0,0 +1 @@
+import 'reflect-metadata';