@hosterai/types 0.0.27 → 0.0.29

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

@@ -21,8 +21,12 @@ describe('FieldDto Validator', () => {
         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' }],
+                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);
         });
@@ -30,28 +34,49 @@ describe('FieldDto Validator', () => {
     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'];
+            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 === 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);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
         });
     });
     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'],
+            [
+                {
+                    ...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);
+            expect(errors.some((e) => e.property === expectedProp)).toBe(true);
         });
     });
     describe('Invalid `value` field', () => {
@@ -64,12 +89,12 @@ describe('FieldDto Validator', () => {
         ])('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);
+            expect(errors.some((e) => e.property === 'value')).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);
+            expect(errors.some((e) => e.property === 'value')).toBe(true);
         });
     });
 });

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

@@ -36,50 +36,50 @@ describe('InfoDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, info_validator_1.validateInfoDto)({});
-            expect(errors.some(e => e.property === 'title')).toBe(true);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error when title is missing', () => {
             const { title, ...dto } = baseValidDto;
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error when supportedLanguages is missing', () => {
             const { supportedLanguages, ...dto } = baseValidDto;
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty title', () => {
             const dto = { ...baseValidDto, title: '' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error for empty supportedLanguages array', () => {
             const dto = { ...baseValidDto, supportedLanguages: [] };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid language enum', () => {
             const dto = { ...baseValidDto, supportedLanguages: ['INVALID'] };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid logo URL (not https)', () => {
             const dto = { ...baseValidDto, logo: 'http://example.com/logo.png' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
         it('should return error for invalid logo URL (not a URL)', () => {
             const dto = { ...baseValidDto, logo: 'not-a-url' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
         it('should return error for invalid onboardingUrl', () => {
             const dto = { ...baseValidDto, onboardingUrl: 'not-a-url' };
             const errors = (0, info_validator_1.validateInfoDto)(dto);
-            expect(errors.some(e => e.property === 'onboardingUrl')).toBe(true);
+            expect(errors.some((e) => e.property === 'onboardingUrl')).toBe(true);
         });
     });
 });

package/dist/validators/invoice-contact-data-validator.spec.js

@@ -40,49 +40,57 @@ describe('InvoiceContactData Validator', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)({});
             const requiredProps = [
-                'invoiceContactId', 'isBusinessContact', 'firstName', 'lastName',
-                'email', 'telephone', 'address1', 'postcode', 'city', 'country',
+                'invoiceContactId',
+                'isBusinessContact',
+                'firstName',
+                'lastName',
+                'email',
+                'telephone',
+                'address1',
+                'postcode',
+                'city',
+                'country',
             ];
             for (const prop of requiredProps) {
-                expect(errors.some(e => e.property === prop)).toBe(true);
+                expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
         it('should return error when invoiceContactId is missing', () => {
             const { invoiceContactId, ...dto } = baseValidDto;
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'invoiceContactId')).toBe(true);
+            expect(errors.some((e) => e.property === 'invoiceContactId')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid email', () => {
             const dto = { ...baseValidDto, email: 'not-an-email' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'email')).toBe(true);
+            expect(errors.some((e) => e.property === 'email')).toBe(true);
         });
         it('should return error for invalid telephone', () => {
             const dto = { ...baseValidDto, telephone: '123' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'telephone')).toBe(true);
+            expect(errors.some((e) => e.property === 'telephone')).toBe(true);
         });
         it('should return error for invalid country code', () => {
             const dto = { ...baseValidDto, country: 'INVALID' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'country')).toBe(true);
+            expect(errors.some((e) => e.property === 'country')).toBe(true);
         });
         it('should return error for address1 exceeding max length', () => {
             const dto = { ...baseValidDto, address1: 'a'.repeat(251) };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'address1')).toBe(true);
+            expect(errors.some((e) => e.property === 'address1')).toBe(true);
         });
         it('should return error for postcode exceeding max length', () => {
             const dto = { ...baseValidDto, postcode: '1'.repeat(17) };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'postcode')).toBe(true);
+            expect(errors.some((e) => e.property === 'postcode')).toBe(true);
         });
         it('should return error for invalid mobile phone', () => {
             const dto = { ...baseValidDto, mobile: 'not-a-phone' };
             const errors = (0, invoice_contact_data_validator_1.validateInvoiceContactDataDto)(dto);
-            expect(errors.some(e => e.property === 'mobile')).toBe(true);
+            expect(errors.some((e) => e.property === 'mobile')).toBe(true);
         });
     });
 });

package/dist/validators/invoice-info-validator.spec.js

@@ -20,7 +20,11 @@ describe('InvoiceInfoDto Validator', () => {
         it('should return no errors with all supported types', () => {
             const dto = {
                 ...baseValidDto,
-                supportedTypes: [invoice_types_enum_1.InvoiceTypesEnum.INVOICE, invoice_types_enum_1.InvoiceTypesEnum.CREDIT_NOTE, invoice_types_enum_1.InvoiceTypesEnum.PROFORMA],
+                supportedTypes: [
+                    invoice_types_enum_1.InvoiceTypesEnum.INVOICE,
+                    invoice_types_enum_1.InvoiceTypesEnum.CREDIT_NOTE,
+                    invoice_types_enum_1.InvoiceTypesEnum.PROFORMA,
+                ],
             };
             expect((0, invoice_info_validator_1.validateInvoiceInfoDto)(dto)).toHaveLength(0);
         });
@@ -37,45 +41,45 @@ describe('InvoiceInfoDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)({});
-            expect(errors.some(e => e.property === 'title')).toBe(true);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error when title is missing', () => {
             const { title, ...dto } = baseValidDto;
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error when supportedLanguages is missing', () => {
             const { supportedLanguages, ...dto } = baseValidDto;
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid supportedTypes enum', () => {
             const dto = { ...baseValidDto, supportedTypes: ['invalid-type'] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedTypes')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedTypes')).toBe(true);
         });
         it('should return error for empty title', () => {
             const dto = { ...baseValidDto, title: '' };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'title')).toBe(true);
+            expect(errors.some((e) => e.property === 'title')).toBe(true);
         });
         it('should return error for empty supportedLanguages array', () => {
             const dto = { ...baseValidDto, supportedLanguages: [] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid language enum', () => {
             const dto = { ...baseValidDto, supportedLanguages: ['INVALID'] };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'supportedLanguages')).toBe(true);
+            expect(errors.some((e) => e.property === 'supportedLanguages')).toBe(true);
         });
         it('should return error for invalid logo URL', () => {
             const dto = { ...baseValidDto, logo: 'not-a-url' };
             const errors = (0, invoice_info_validator_1.validateInvoiceInfoDto)(dto);
-            expect(errors.some(e => e.property === 'logo')).toBe(true);
+            expect(errors.some((e) => e.property === 'logo')).toBe(true);
         });
     });
 });

package/dist/validators/invoice-item-data-validator.spec.js

@@ -27,19 +27,19 @@ describe('InvoiceItemDataDto Validator', () => {
         it('should return error when action is missing', () => {
             const { action, ...dto } = baseValidDto;
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
         });
         it('should return errors for inherited required fields when missing', () => {
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)({});
-            expect(errors.some(e => e.property === 'action')).toBe(true);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for invalid action enum', () => {
             const dto = { ...baseValidDto, action: 'invalid-action' };
             const errors = (0, invoice_item_data_validator_1.validateInvoiceItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'action')).toBe(true);
+            expect(errors.some((e) => e.property === 'action')).toBe(true);
         });
     });
 });

package/dist/validators/item-data-validator.spec.js

@@ -33,47 +33,55 @@ describe('ItemDataDto Validator', () => {
     describe('Missing required fields', () => {
         it('should return errors when all fields are missing', () => {
             const errors = (0, item_data_validator_1.validateItemDataDto)({});
-            const requiredProps = ['productId', 'productName', 'resourceName', 'productAttributes', 'itemAttributes', 'startDate', 'endDate'];
+            const requiredProps = [
+                'productId',
+                'productName',
+                'resourceName',
+                'productAttributes',
+                'itemAttributes',
+                'startDate',
+                'endDate',
+            ];
             for (const prop of requiredProps) {
-                expect(errors.some(e => e.property === prop)).toBe(true);
+                expect(errors.some((e) => e.property === prop)).toBe(true);
             }
         });
         it('should return error when productId is missing', () => {
             const { productId, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
         it('should return error when productAttributes is missing', () => {
             const { productAttributes, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productAttributes')).toBe(true);
+            expect(errors.some((e) => e.property === 'productAttributes')).toBe(true);
         });
         it('should return error when itemAttributes is missing', () => {
             const { itemAttributes, ...dto } = baseValidDto;
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'itemAttributes')).toBe(true);
+            expect(errors.some((e) => e.property === 'itemAttributes')).toBe(true);
         });
     });
     describe('Invalid field values', () => {
         it('should return error for empty productId', () => {
             const dto = { ...baseValidDto, productId: '' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'productId')).toBe(true);
+            expect(errors.some((e) => e.property === 'productId')).toBe(true);
         });
         it('should return error for empty startDate', () => {
             const dto = { ...baseValidDto, startDate: '' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'startDate')).toBe(true);
+            expect(errors.some((e) => e.property === 'startDate')).toBe(true);
         });
         it('should return error for non-number price', () => {
             const dto = { ...baseValidDto, price: 'free' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'price')).toBe(true);
+            expect(errors.some((e) => e.property === 'price')).toBe(true);
         });
         it('should return error for non-number discountPrice', () => {
             const dto = { ...baseValidDto, discountPrice: 'half-off' };
             const errors = (0, item_data_validator_1.validateItemDataDto)(dto);
-            expect(errors.some(e => e.property === 'discountPrice')).toBe(true);
+            expect(errors.some((e) => e.property === 'discountPrice')).toBe(true);
         });
     });
 });

package/dist/validators/menu-with-submenu-validator.spec.js

@@ -4,41 +4,43 @@ require("reflect-metadata");
 const menu_with_submenu_validator_1 = require("./menu-with-submenu.validator");
 describe('validateMenuDto', () => {
     test.each([
-        ['valid data with submenu',
+        [
+            'valid data with submenu',
             {
                 type: 'with-submenu',
                 icon: 'https://example.com/icon.png',
                 label: 'Menu Label',
-                submenu: [
-                    { label: 'Submenu 1', url: 'https://example.com/sub1' }
-                ],
+                submenu: [{ label: 'Submenu 1', url: 'https://example.com/sub1' }],
             },
-            true
+            true,
         ],
-        ['missing required icon',
+        [
+            'missing required icon',
             {
                 type: 'with-submenu',
                 label: 'Menu Label',
                 submenu: [{ label: 'Submenu 1', url: 'https://example.com/sub1' }],
             },
-            false
+            false,
         ],
-        ['missing submenu',
+        [
+            'missing submenu',
             {
                 type: 'with-submenu',
                 icon: 'https://example.com/icon.png',
                 label: 'Menu Label',
             },
-            false
+            false,
         ],
-        ['submenu with missing label',
+        [
+            'submenu with missing label',
             {
                 type: 'with-submenu',
                 icon: 'https://example.com/icon.png',
                 label: 'Menu Label',
                 submenu: [{ url: 'https://example.com/sub1' }],
             },
-            false
+            false,
         ],
     ])('%s', (_, input, expectedValid) => {
         const errors = (0, menu_with_submenu_validator_1.validateMenuWithSubmenuDto)(input);

package/dist/validators/menu-with-url-validator.spec.js

@@ -22,7 +22,7 @@ describe('validateMenuWithUrlDto', () => {
         };
         const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
         expect(errors.length).toBeGreaterThan(0);
-        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isIn; })).toBe(true);
+        expect(errors.some((e) => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isIn; })).toBe(true);
     });
     it('fails if icon is not a string', () => {
         const data = {
@@ -33,7 +33,7 @@ describe('validateMenuWithUrlDto', () => {
         };
         const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
         expect(errors.length).toBeGreaterThan(0);
-        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isString; })).toBe(true);
+        expect(errors.some((e) => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isString; })).toBe(true);
     });
     it('fails if label is missing', () => {
         const data = {
@@ -43,17 +43,27 @@ describe('validateMenuWithUrlDto', () => {
         };
         const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
         expect(errors.length).toBeGreaterThan(0);
-        expect(errors.some(e => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isNotEmpty; })).toBe(true);
+        expect(errors.some((e) => { var _a; return (_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isNotEmpty; })).toBe(true);
     });
     it('fails if url is missing or invalid', () => {
         const invalids = [
             { type: 'only-url', icon: 12345, label: 'Dashboard' }, // icon not a string
-            { type: 'only-url', icon: 'https://example.com/icon.png', label: 'Dashboard', url: 'invalid-url' },
+            {
+                type: 'only-url',
+                icon: 'https://example.com/icon.png',
+                label: 'Dashboard',
+                url: 'invalid-url',
+            },
         ];
         for (const data of invalids) {
             const errors = (0, menu_with_url_validator_1.validateMenuWithUrlDto)(data);
             expect(errors.length).toBeGreaterThan(0);
-            expect(errors.some(e => { var _a, _b, _c; return ((_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isUrl) || ((_b = e.constraints) === null || _b === void 0 ? void 0 : _b.isString) || ((_c = e.constraints) === null || _c === void 0 ? void 0 : _c.isDefined); })).toBe(true);
+            expect(errors.some((e) => {
+                var _a, _b, _c;
+                return ((_a = e.constraints) === null || _a === void 0 ? void 0 : _a.isUrl) ||
+                    ((_b = e.constraints) === null || _b === void 0 ? void 0 : _b.isString) ||
+                    ((_c = e.constraints) === null || _c === void 0 ? void 0 : _c.isDefined);
+            })).toBe(true);
         }
     });
     it('fails if submenu is present', () => {

package/dist/validators/notification-info-validator.spec.js

@@ -6,7 +6,11 @@ const notification_message_type_enum_1 = require("../enums/notification/notifica
 const item_actions_enum_1 = require("../enums/item-actions.enum");
 const language_enum_1 = require("../enums/language.enum");
 describe('NotificationInfoDto Validator', () => {
-    const validUnit = { id: "ram", unitDescription: "MB", intervalDescription: "month" };
+    const validUnit = {
+        id: 'ram',
+        unitDescription: 'MB',
+        intervalDescription: 'month',
+    };
     const testCases = [
         {
             description: 'should return no errors for valid DTO',
@@ -15,9 +19,9 @@ describe('NotificationInfoDto Validator', () => {
                 title: 'Valid Title',
                 supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrorsLength: 0
+            expectedErrorsLength: 0,
         },
         {
             description: 'should return error for missing type',
@@ -25,9 +29,9 @@ describe('NotificationInfoDto Validator', () => {
                 title: 'Valid Title',
                 supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrorsLength: 1
+            expectedErrorsLength: 1,
         },
         {
             description: 'should return error for invalid payPerUseUnits',
@@ -36,10 +40,12 @@ describe('NotificationInfoDto Validator', () => {
                 title: 'Valid Title',
                 supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }] // Invalid unit
+                payPerUseUnits: [
+                    { id: '', unitDescription: '', intervalDescription: '' },
+                ], // Invalid unit
             },
-            expectedErrorsLength: 1
-        }
+            expectedErrorsLength: 1,
+        },
     ];
     testCases.forEach(({ description, dto, expectedErrorsLength }) => {
         it(description, async () => {
@@ -54,9 +60,9 @@ describe('NotificationInfoDto Validator', () => {
                 type: notification_message_type_enum_1.NotificationMessageTypeEnum.EMAIL,
                 supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [validUnit]
+                payPerUseUnits: [validUnit],
             },
-            expectedErrors: ['title']
+            expectedErrors: ['title'],
         },
         {
             description: 'should return ValidationError for invalid payPerUseUnits',
@@ -65,16 +71,18 @@ describe('NotificationInfoDto Validator', () => {
                 title: 'Valid Title',
                 supportedActions: [item_actions_enum_1.ProductItemActionsEnum.CREATE],
                 supportedLanguages: [language_enum_1.LanguageEnum.ENGLISH],
-                payPerUseUnits: [{ id: "", unitDescription: "", intervalDescription: "" }]
+                payPerUseUnits: [
+                    { id: '', unitDescription: '', intervalDescription: '' },
+                ],
             },
-            expectedErrors: ['payPerUseUnits']
-        }
+            expectedErrors: ['payPerUseUnits'],
+        },
     ];
     validationErrorTestCases.forEach(({ description, dto, expectedErrors }) => {
         it(description, async () => {
             const errors = await (0, notification_info_validator_1.validateNotificationInfoDto)(dto);
-            const errorProperties = errors.map(error => error.property);
-            expectedErrors.forEach(expectedError => {
+            const errorProperties = errors.map((error) => error.property);
+            expectedErrors.forEach((expectedError) => {
                 expect(errorProperties).toContain(expectedError);
             });
         });

package/dist/validators/product-downgradeable-request-validator.d.ts

@@ -0,0 +1,8 @@
+import { ValidationError } from 'class-validator';
+/**
+ * Validates a product downgradable request object.
+ *
+ * @param {Record<string, unknown>} plainObject - The plain object to validate.
+ * @returns {Promise<ValidationError[]>} - A promise that resolves with an array of validation errors.
+ */
+export declare const validateProductDowngradableRequestDto: (plainObject: Record<string, unknown>) => Promise<ValidationError[]>;

package/dist/validators/product-downgradeable-request-validator.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProductDowngradableRequestDto = void 0;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+const product_downgradable_request_dto_1 = require("../dtos/product/requests/product-downgradable-request.dto");
+/**
+ * Validates a product downgradable request object.
+ *
+ * @param {Record<string, unknown>} plainObject - The plain object to validate.
+ * @returns {Promise<ValidationError[]>} - A promise that resolves with an array of validation errors.
+ */
+const validateProductDowngradableRequestDto = async (plainObject) => {
+    const request = (0, class_transformer_1.plainToInstance)(product_downgradable_request_dto_1.ProductDowngradableRequestDto, plainObject);
+    return await (0, class_validator_1.validate)(request);
+};
+exports.validateProductDowngradableRequestDto = validateProductDowngradableRequestDto;