@forwardslashns/taskit-validation-messages 1.10.18 → 1.10.20

package/dist/validation/features/template-recurrence-settings.validation-messages.d.ts

@@ -1,136 +1,168 @@
 export declare const TEMPLATE_RECURRENCE_SETTINGS: {
-    readonly RECURRENCE_NOT_FOUND: {
-        readonly message: "Template recurrence setting not found";
-        readonly affectedFields: string[];
-    };
-    readonly RECURRENCE_FREQUENCY_REQUIRED: {
-        readonly message: "Recurrence frequency is required";
-        readonly affectedFields: readonly ["recurrenceFrequency"];
-    };
-    readonly RECURRENCE_FREQUENCY_NOT_FOUND: {
-        readonly message: "Recurrence frequency not found.";
-        readonly affectedFields: readonly ["recurrenceFrequencyId"];
-    };
-    readonly RECURRENCE_FREQUENCY_ALREADY_EXISTS: {
-        readonly message: "Each recurrence frequency can only be added to a template once. A recurrence for {recurrenceFrequency} already exists. Please edit that recurrence setup, or change the recurrence frequency selected here before saving.";
-        readonly params: readonly ["recurrenceFrequency"];
-        readonly affectedFields: readonly ["recurrenceFrequencyId"];
-    };
-    readonly INCOME_TAX_MUST_BE_ANNUAL: {
-        readonly message: "An Income tax filing template can only have an annual recurrence frequency. Please update your selection before saving.";
-        readonly affectedFields: readonly ["recurrenceFrequencyId"];
-    };
-    readonly BASED_ON_MUST_BE_PERIOD: {
-        readonly message: "A {templateType} template recurrence must always be based on 'Period'. Please update your selection before saving.";
-        readonly params: readonly ["templateType"];
-        readonly affectedFields: readonly ["basedOn"];
-    };
-    readonly BASED_ON_REQUIRED: {
-        readonly message: "Based on is required";
-        readonly affectedFields: readonly ["basedOn"];
-    };
-    readonly BASED_ON_MUST_BE_DATE: {
-        readonly message: "A {templateType} template recurrence must always be based on 'Date'. Please update your selection before saving.";
-        readonly params: readonly ["templateType"];
-        readonly affectedFields: readonly ["basedOn"];
-    };
-    readonly FIRST_MONTH_REQUIRED: {
-        readonly message: "First month is required";
-        readonly affectedFields: readonly ["firstMonth"];
-    };
-    readonly FIRST_MONTH_INVALID: {
-        readonly message: "First month must be a value between 1 and 12.";
-        readonly affectedFields: readonly ["firstMonth"];
-    };
-    readonly SECOND_MONTH_REQUIRED: {
-        readonly message: "Second month is required";
-        readonly affectedFields: readonly ["secondMonth"];
-    };
-    readonly SECOND_MONTH_INVALID: {
-        readonly message: "Second month must be a value between 1 and 12.";
-        readonly affectedFields: readonly ["secondMonth"];
-    };
-    readonly THIRD_MONTH_REQUIRED: {
-        readonly message: "Third month is required";
-        readonly affectedFields: readonly ["thirdMonth"];
-    };
-    readonly THIRD_MONTH_INVALID: {
-        readonly message: "Third month must be a value between 1 and 12.";
-        readonly affectedFields: readonly ["thirdMonth"];
-    };
-    readonly FOURTH_MONTH_REQUIRED: {
-        readonly message: "Fourth month is required";
-        readonly affectedFields: readonly ["fourthMonth"];
-    };
-    readonly FOURTH_MONTH_INVALID: {
-        readonly message: "Fourth month must be a value between 1 and 12.";
-        readonly affectedFields: readonly ["fourthMonth"];
-    };
-    readonly DAY_OF_MONTH_REQUIRED: {
-        readonly message: "Day of month is required";
-        readonly affectedFields: readonly ["dayOfMonth"];
-    };
-    readonly DAY_OF_MONTH_INVALID: {
-        readonly message: "Day of month must be a value between 1 and 31.";
-        readonly affectedFields: readonly ["dayOfMonth"];
-    };
-    readonly DUE_MONTH_REQUIRED: {
-        readonly message: "Due month is required";
-        readonly affectedFields: readonly ["dueMonth"];
-    };
-    readonly DUE_MONTH_INVALID: {
-        readonly message: "Due month must be a value between 0 and 12.";
-        readonly affectedFields: readonly ["dueMonth"];
-    };
-    readonly DUE_DAY_REQUIRED: {
-        readonly message: "Due day is required";
-        readonly affectedFields: readonly ["dueDay"];
-    };
-    readonly DUE_DAY_INVALID: {
-        readonly message: "Due day must be a value between 0 and 31.";
-        readonly affectedFields: readonly ["dueDay"];
-    };
-    readonly EXTEND_MONTH_REQUIRED: {
-        readonly message: "Extend month is required";
-        readonly affectedFields: readonly ["extendMonth"];
-    };
-    readonly EXTEND_MONTH_INVALID: {
-        readonly message: "Extend month cannot be a negative number.";
-        readonly affectedFields: readonly ["extendMonth"];
-    };
-    readonly GENERATE_BEFORE_REQUIRED: {
-        readonly message: "Before is required";
-        readonly affectedFields: readonly ["generateBeforeId"];
-    };
-    readonly GENERATE_TASKS_DAYS_REQUIRED: {
-        readonly message: "Generate task days is required";
-        readonly affectedFields: readonly ["generateTasksDays"];
-    };
-    readonly GENERATE_BEFORE_MUST_BE_DUE_DATE: {
-        readonly message: "This recurrence is based on a date, therefore it can only be generated before a due date. Please update your selection before saving.";
-        readonly affectedFields: readonly ["generateBeforeId"];
-    };
-    readonly DAY_EXCEEDS_MONTH_MAX: {
-        readonly message: "Day {dayOfMonth} is not valid for {monthName}. The maximum allowed day is {maxDays}.";
-        readonly params: readonly ["dayOfMonth", "monthName", "maxDays"];
-        readonly affectedFields: readonly ["dayOfMonth"];
-    };
-    readonly RECURRENCE_IN_USE_CANNOT_EDIT: {
-        readonly message: "This recurrence is currently applied to a client and cannot be edited.";
-        readonly affectedFields: string[];
-    };
-    readonly RECURRENCE_IN_USE_CANNOT_DELETE: {
-        readonly message: "This recurrence is currently in use and cannot be deleted.";
-        readonly affectedFields: string[];
-    };
-    readonly RECURRENCE_GENERATE_BEFORE_NOT_FOUND: {
-        readonly message: "Generate before option not found.";
-        readonly affectedFields: readonly ["generateBeforeId"];
-    };
-    readonly RECURRENCE_REQUIRED_FOR_TEMPLATE_TYPE: {
-        readonly message: "A {templateType} template must have a recurrence set up. Please add a recurrence before saving.";
-        readonly params: readonly ["templateType"];
-        readonly affectedFields: readonly ["recurrenceSettings"];
+    RECURRENCE_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_FREQUENCY_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_FREQUENCY_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_FREQUENCY_ALREADY_EXISTS: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    INCOME_TAX_MUST_BE_ANNUAL: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    BASED_ON_MUST_BE_PERIOD: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    BASED_ON_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    BASED_ON_MUST_BE_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FIRST_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    FIRST_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    SECOND_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    SECOND_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    THIRD_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    THIRD_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    FOURTH_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    FOURTH_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DAY_OF_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DAY_OF_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DUE_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DUE_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DUE_DAY_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DUE_DAY_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    EXTEND_MONTH_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    EXTEND_MONTH_INVALID: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    GENERATE_BEFORE_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    GENERATE_TASKS_DAYS_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    GENERATE_BEFORE_MUST_BE_DUE_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DAY_EXCEEDS_MONTH_MAX: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    RECURRENCE_IN_USE_CANNOT_EDIT: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_IN_USE_CANNOT_DELETE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_GENERATE_BEFORE_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    RECURRENCE_REQUIRED_FOR_TEMPLATE_TYPE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
     };
 };
 //# sourceMappingURL=template-recurrence-settings.validation-messages.d.ts.map

package/dist/validation/features/template-recurrence-settings.validation-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-recurrence-settings.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-recurrence-settings.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B;;;iCAGf,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAyHR,MAAM,EAAE;;;;iCAIR,MAAM,EAAE;;;;;;;;;;;CAWxB,CAAC"}
+{"version":3,"file":"template-recurrence-settings.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-recurrence-settings.validation-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,4BAA4B;;;;wBAIf,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqJR,MAAM,EAAE;;;;;wBAKR,MAAM,EAAE;;;;;;;;;;;;;CAahC,CAAC"}

package/dist/validation/features/template-recurrence-settings.validation-messages.js

@@ -1,138 +1,171 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEMPLATE_RECURRENCE_SETTINGS = void 0;
-exports.TEMPLATE_RECURRENCE_SETTINGS = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.TEMPLATE_RECURRENCE_SETTINGS = (0, validation_message_types_1.defineValidationFeatureMessages)({
     RECURRENCE_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Template recurrence setting not found',
         affectedFields: [],
     },
     RECURRENCE_FREQUENCY_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Recurrence frequency is required',
         affectedFields: ['recurrenceFrequency'],
     },
     RECURRENCE_FREQUENCY_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Recurrence frequency not found.',
         affectedFields: ['recurrenceFrequencyId'],
     },
     RECURRENCE_FREQUENCY_ALREADY_EXISTS: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Each recurrence frequency can only be added to a template once. A recurrence for {recurrenceFrequency} already exists. Please edit that recurrence setup, or change the recurrence frequency selected here before saving.',
         params: ['recurrenceFrequency'],
         affectedFields: ['recurrenceFrequencyId'],
     },
     INCOME_TAX_MUST_BE_ANNUAL: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'An Income tax filing template can only have an annual recurrence frequency. Please update your selection before saving.',
         affectedFields: ['recurrenceFrequencyId'],
     },
     BASED_ON_MUST_BE_PERIOD: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: "A {templateType} template recurrence must always be based on 'Period'. Please update your selection before saving.",
         params: ['templateType'],
         affectedFields: ['basedOn'],
     },
     BASED_ON_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Based on is required',
         affectedFields: ['basedOn'],
     },
     BASED_ON_MUST_BE_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: "A {templateType} template recurrence must always be based on 'Date'. Please update your selection before saving.",
         params: ['templateType'],
         affectedFields: ['basedOn'],
     },
     FIRST_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'First month is required',
         affectedFields: ['firstMonth'],
     },
     FIRST_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'First month must be a value between 1 and 12.',
         affectedFields: ['firstMonth'],
     },
     SECOND_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Second month is required',
         affectedFields: ['secondMonth'],
     },
     SECOND_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Second month must be a value between 1 and 12.',
         affectedFields: ['secondMonth'],
     },
     THIRD_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Third month is required',
         affectedFields: ['thirdMonth'],
     },
     THIRD_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Third month must be a value between 1 and 12.',
         affectedFields: ['thirdMonth'],
     },
     FOURTH_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Fourth month is required',
         affectedFields: ['fourthMonth'],
     },
     FOURTH_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Fourth month must be a value between 1 and 12.',
         affectedFields: ['fourthMonth'],
     },
     DAY_OF_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Day of month is required',
         affectedFields: ['dayOfMonth'],
     },
     DAY_OF_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Day of month must be a value between 1 and 31.',
         affectedFields: ['dayOfMonth'],
     },
     DUE_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Due month is required',
         affectedFields: ['dueMonth'],
     },
     DUE_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Due month must be a value between 0 and 12.',
         affectedFields: ['dueMonth'],
     },
     DUE_DAY_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Due day is required',
         affectedFields: ['dueDay'],
     },
     DUE_DAY_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Due day must be a value between 0 and 31.',
         affectedFields: ['dueDay'],
     },
     EXTEND_MONTH_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Extend month is required',
         affectedFields: ['extendMonth'],
     },
     EXTEND_MONTH_INVALID: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Extend month cannot be a negative number.',
         affectedFields: ['extendMonth'],
     },
     GENERATE_BEFORE_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Before is required',
         affectedFields: ['generateBeforeId'],
     },
     GENERATE_TASKS_DAYS_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Generate task days is required',
         affectedFields: ['generateTasksDays'],
     },
     GENERATE_BEFORE_MUST_BE_DUE_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This recurrence is based on a date, therefore it can only be generated before a due date. Please update your selection before saving.',
         affectedFields: ['generateBeforeId'],
     },
     DAY_EXCEEDS_MONTH_MAX: {
-        message: 'Day {dayOfMonth} is not valid for {monthName}. The maximum allowed day is {maxDays}.',
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Day '{dayOfMonth}' is not valid for '{monthName}'. The maximum allowed day is '{maxDays}'.`,
         params: ['dayOfMonth', 'monthName', 'maxDays'],
         affectedFields: ['dayOfMonth'],
     },
     RECURRENCE_IN_USE_CANNOT_EDIT: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This recurrence is currently applied to a client and cannot be edited.',
         affectedFields: [],
     },
     RECURRENCE_IN_USE_CANNOT_DELETE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This recurrence is currently in use and cannot be deleted.',
         affectedFields: [],
     },
     RECURRENCE_GENERATE_BEFORE_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Generate before option not found.',
         affectedFields: ['generateBeforeId'],
     },
     RECURRENCE_REQUIRED_FOR_TEMPLATE_TYPE: {
-        message: 'A {templateType} template must have a recurrence set up. Please add a recurrence before saving.',
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `A '{templateType}' template must have a recurrence set up. Please add a recurrence before saving.`,
         params: ['templateType'],
         affectedFields: ['recurrenceSettings'],
     },
-};
+});

package/dist/validation/features/template-states.validation-messages.d.ts

@@ -1,43 +1,53 @@
 export declare const TEMPLATE_STATES: {
-    readonly TEMPLATE_STATE_NOT_FOUND: {
-        readonly message: "Template state not found";
-        readonly affectedFields: readonly [];
-    };
-    readonly NAME_REQUIRED: {
-        readonly message: "Name is required";
-        readonly affectedFields: readonly ["name"];
-    };
-    readonly NAME_ALREADY_IN_USE: {
-        readonly message: "This name is already in use on this template. Please enter a different name.";
-        readonly affectedFields: readonly ["name"];
-    };
-    readonly STATE_REQUIRED: {
-        readonly message: "State is required";
-        readonly affectedFields: readonly ["stateId"];
-    };
-    readonly INVALID_STATE: {
-        readonly message: "Invalid state";
-        readonly affectedFields: readonly ["stateId"];
-    };
-    readonly STATE_LOCKED_WHEN_IN_USE: {
-        readonly message: "The State field cannot be changed because this state is already applied to a client.";
-        readonly affectedFields: readonly ["stateId"];
-    };
-    readonly DATE_STOPPED_REQUIRED_WHEN_INACTIVE: {
-        readonly message: "Date stopped is required when status is Inactive.";
-        readonly affectedFields: readonly ["dateStopped"];
-    };
-    readonly IS_ACTIVE_REQUIRED: {
-        readonly message: "Status is required";
-        readonly affectedFields: readonly ["isActive"];
-    };
-    readonly IN_USE_CANNOT_DELETE: {
-        readonly message: "This state is currently in use and cannot be deleted.";
-        readonly affectedFields: readonly [];
-    };
-    readonly TEMPLATE_MUST_BE_FILING_TYPE: {
-        readonly message: "States can only be added to Filing type templates.";
-        readonly affectedFields: readonly [];
+    TEMPLATE_STATE_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    NAME_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    NAME_ALREADY_IN_USE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    STATE_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    INVALID_STATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    STATE_LOCKED_WHEN_IN_USE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DATE_STOPPED_REQUIRED_WHEN_INACTIVE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    IS_ACTIVE_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    IN_USE_CANNOT_DELETE: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    TEMPLATE_MUST_BE_FILING_TYPE: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
     };
 };
 //# sourceMappingURL=template-states.validation-messages.d.ts.map

package/dist/validation/features/template-states.validation-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-states.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-states.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClB,CAAC"}
+{"version":3,"file":"template-states.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-states.validation-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmD1B,CAAC"}

package/dist/validation/features/template-states.validation-messages.js

@@ -1,45 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEMPLATE_STATES = void 0;
-exports.TEMPLATE_STATES = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.TEMPLATE_STATES = (0, validation_message_types_1.defineValidationFeatureMessages)({
     TEMPLATE_STATE_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Template state not found',
         affectedFields: [],
     },
     NAME_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Name is required',
         affectedFields: ['name'],
     },
     NAME_ALREADY_IN_USE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This name is already in use on this template. Please enter a different name.',
         affectedFields: ['name'],
     },
     STATE_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'State is required',
         affectedFields: ['stateId'],
     },
     INVALID_STATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Invalid state',
         affectedFields: ['stateId'],
     },
     STATE_LOCKED_WHEN_IN_USE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'The State field cannot be changed because this state is already applied to a client.',
         affectedFields: ['stateId'],
     },
     DATE_STOPPED_REQUIRED_WHEN_INACTIVE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Date stopped is required when status is Inactive.',
         affectedFields: ['dateStopped'],
     },
     IS_ACTIVE_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Status is required',
         affectedFields: ['isActive'],
     },
     IN_USE_CANNOT_DELETE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This state is currently in use and cannot be deleted.',
         affectedFields: [],
     },
     TEMPLATE_MUST_BE_FILING_TYPE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'States can only be added to Filing type templates.',
         affectedFields: [],
     },
-};
+});