@forwardslashns/taskit-validation-messages 1.10.18 → 1.10.20

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

@@ -1,49 +1,59 @@
 export declare const STATES: {
-    readonly INVALID_REQUEST: {
-        readonly message: "Missing state id in request";
-        readonly affectedFields: readonly [];
-    };
-    readonly ID_DOES_NOT_EXIST: {
-        readonly message: "State does not exist";
-        readonly params: readonly ["id"];
-        readonly affectedFields: readonly ["stateId"];
-    };
-    readonly NAME_ALREADY_EXISTS: {
-        readonly message: "State with the same name '{name}' already exists";
-        readonly params: readonly ["name"];
-        readonly affectedFields: readonly ["name"];
-    };
-    readonly STATE_TYPE_ID_DOES_NOT_EXIST: {
-        readonly message: "State type does not exist";
-        readonly params: readonly ["id"];
-        readonly affectedFields: readonly ["stateType"];
-    };
-    readonly IS_PARENT_OF_OTHER_STATES: {
-        readonly message: "This option is currently in use and cannot be deleted.";
-        readonly affectedFields: readonly [];
-    };
-    readonly PARENT_ID_DOES_NOT_EXIST: {
-        readonly message: "Parent state does not exist";
-        readonly params: readonly ["id"];
-        readonly affectedFields: readonly ["parent"];
-    };
-    readonly NATION_PARENT_TYPE_NOT_ALLOWED: {
-        readonly message: "Nation cannot have associated parent.";
-        readonly affectedFields: readonly ["parent"];
-    };
-    readonly STATE_PARENT_TYPE_NOT_ALLOWED: {
-        readonly message: "There must be a nation associated with the state '{stateName}'. Please select a nation to proceed.";
-        readonly params: readonly ["stateName"];
-        readonly affectedFields: readonly ["parent"];
-    };
-    readonly CITY_PARENT_TYPE_NOT_ALLOWED: {
-        readonly message: "There must be a state associated with the city '{cityName}'. Please select a state to proceed.";
-        readonly params: readonly ["cityName"];
-        readonly affectedFields: readonly ["parent"];
-    };
-    readonly OPTION_IN_USE: {
-        readonly message: "This option is currently in use and cannot be deleted.";
-        readonly affectedFields: readonly [];
+    INVALID_REQUEST: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    ID_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NAME_ALREADY_EXISTS: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    STATE_TYPE_ID_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    IS_PARENT_OF_OTHER_STATES: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    PARENT_ID_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NATION_PARENT_TYPE_NOT_ALLOWED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    STATE_PARENT_TYPE_NOT_ALLOWED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    CITY_PARENT_TYPE_NOT_ALLOWED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    OPTION_IN_USE: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
     };
 };
 //# sourceMappingURL=states.validation-messages.d.ts.map

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

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

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

@@ -1,51 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.STATES = void 0;
-exports.STATES = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.STATES = (0, validation_message_types_1.defineValidationFeatureMessages)({
     INVALID_REQUEST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Missing state id in request',
         affectedFields: [],
     },
     ID_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `State does not exist`,
         params: ['id'],
         affectedFields: ['stateId'],
     },
     NAME_ALREADY_EXISTS: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `State with the same name '{name}' already exists`,
         params: ['name'],
         affectedFields: ['name'],
     },
     STATE_TYPE_ID_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `State type does not exist`,
         params: ['id'],
         affectedFields: ['stateType'],
     },
     IS_PARENT_OF_OTHER_STATES: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `This option is currently in use and cannot be deleted.`,
         affectedFields: [],
     },
     PARENT_ID_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Parent state does not exist`,
         params: ['id'],
         affectedFields: ['parent'],
     },
     NATION_PARENT_TYPE_NOT_ALLOWED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Nation cannot have associated parent.`,
         affectedFields: ['parent'],
     },
     STATE_PARENT_TYPE_NOT_ALLOWED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `There must be a nation associated with the state '{stateName}'. Please select a nation to proceed.`,
         params: ['stateName'],
         affectedFields: ['parent'],
     },
     CITY_PARENT_TYPE_NOT_ALLOWED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `There must be a state associated with the city '{cityName}'. Please select a state to proceed.`,
         params: ['cityName'],
         affectedFields: ['parent'],
     },
     OPTION_IN_USE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `This option is currently in use and cannot be deleted.`,
         affectedFields: [],
     },
-};
+});

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

@@ -1,72 +1,89 @@
 export declare const TEMPLATE_ASSIGNMENTS: {
-    readonly NAME_REQUIRED: {
-        readonly message: "Assignment name is required";
-        readonly affectedFields: readonly ["name"];
-    };
-    readonly NAME_ALREADY_EXISTS: {
-        readonly message: "This name is already in use on this template. Please enter a different name";
-        readonly affectedFields: readonly ["name"];
-    };
-    readonly DEFAULT_STAFF_REQUIRED: {
-        readonly message: "Default staff is required";
-        readonly affectedFields: readonly ["defaultStaff"];
-    };
-    readonly DEFAULT_STAFF_NOT_ALLOWED_FOR_TODO: {
-        readonly message: "Default staff cannot be set when the assignment type is 'To do'";
-        readonly affectedFields: readonly ["defaultStaff"];
-    };
-    readonly INVALID_STAFF: {
-        readonly message: "Invalid staff member";
-        readonly affectedFields: readonly ["defaultStaff"];
-    };
-    readonly ASSIGNMENT_TYPE_REQUIRED: {
-        readonly message: "Assignment type is required";
-        readonly affectedFields: readonly ["assignmentType"];
-    };
-    readonly INVALID_ASSIGNMENT_TYPE: {
-        readonly message: "Invalid assignment type";
-        readonly affectedFields: readonly ["assignmentType"];
-    };
-    readonly WORKFLOW_MUST_BE_REQUIRED: {
-        readonly message: "A workflow assignment must always be required. Please check the 'Required' checkbox to continue";
-        readonly affectedFields: readonly ["isRequired"];
-    };
-    readonly WORKFLOW_CANNOT_BE_DELETED: {
-        readonly message: "A workflow assignment cannot be deleted. Please uncheck the 'Can be deleted' checkbox to continue";
-        readonly affectedFields: readonly ["canBeDeleted"];
-    };
-    readonly ORDER_REQUIRED: {
-        readonly message: "Order is required for workflow assignments";
-        readonly affectedFields: readonly ["order"];
-    };
-    readonly ORDER_ALREADY_EXISTS: {
-        readonly message: "This order number is already in use on this template. Please enter a different number to set the workflow order";
-        readonly affectedFields: readonly ["order"];
-    };
-    readonly TEMPLATE_NOT_FOUND: {
-        readonly message: "Template not found";
-        readonly affectedFields: readonly [];
-    };
-    readonly ASSIGNMENT_NOT_FOUND: {
-        readonly message: "Assignment not found";
-        readonly affectedFields: readonly [];
-    };
-    readonly CANNOT_EDIT_IN_USE: {
-        readonly message: "This assignment is already being used by a client, and cannot be edited";
-        readonly affectedFields: readonly [];
-    };
-    readonly CANNOT_DELETE_IN_USE: {
-        readonly message: "This assignment is already being used by a client, and cannot be deleted";
-        readonly affectedFields: readonly [];
-    };
-    readonly INVALID_FILING_CATEGORY: {
-        readonly message: "Invalid filing category";
-        readonly affectedFields: readonly ["filingCategoryId"];
-    };
-    readonly ASSIGNMENTS_ORDER_NOT_CONSECUTIVE: {
-        readonly message: "Assignment orders must be consecutive starting from 1. Expected orders: {expected}";
-        readonly params: readonly ["expected"];
-        readonly affectedFields: readonly ["assignments"];
+    NAME_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    NAME_ALREADY_EXISTS: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DEFAULT_STAFF_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    DEFAULT_STAFF_NOT_ALLOWED_FOR_TODO: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    INVALID_STAFF: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ASSIGNMENT_TYPE_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    INVALID_ASSIGNMENT_TYPE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    WORKFLOW_MUST_BE_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    WORKFLOW_CANNOT_BE_DELETED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ORDER_REQUIRED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ORDER_ALREADY_EXISTS: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    TEMPLATE_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    ASSIGNMENT_NOT_FOUND: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    CANNOT_EDIT_IN_USE: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    CANNOT_DELETE_IN_USE: {
+        severity: "error";
+        message: string;
+        affectedFields: never[];
+    };
+    INVALID_FILING_CATEGORY: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ASSIGNMENTS_ORDER_NOT_CONSECUTIVE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
     };
 };
 //# sourceMappingURL=template-assignments.validation-messages.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"template-assignments.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-assignments.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuEvB,CAAC"}
+{"version":3,"file":"template-assignments.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/template-assignments.validation-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwF/B,CAAC"}

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

@@ -1,74 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TEMPLATE_ASSIGNMENTS = void 0;
-exports.TEMPLATE_ASSIGNMENTS = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.TEMPLATE_ASSIGNMENTS = (0, validation_message_types_1.defineValidationFeatureMessages)({
     NAME_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Assignment name is required',
         affectedFields: ['name'],
     },
     NAME_ALREADY_EXISTS: {
+        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'],
     },
     DEFAULT_STAFF_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Default staff is required',
         affectedFields: ['defaultStaff'],
     },
     DEFAULT_STAFF_NOT_ALLOWED_FOR_TODO: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: "Default staff cannot be set when the assignment type is 'To do'",
         affectedFields: ['defaultStaff'],
     },
     INVALID_STAFF: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Invalid staff member',
         affectedFields: ['defaultStaff'],
     },
     ASSIGNMENT_TYPE_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Assignment type is required',
         affectedFields: ['assignmentType'],
     },
     INVALID_ASSIGNMENT_TYPE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Invalid assignment type',
         affectedFields: ['assignmentType'],
     },
     WORKFLOW_MUST_BE_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: "A workflow assignment must always be required. Please check the 'Required' checkbox to continue",
         affectedFields: ['isRequired'],
     },
     WORKFLOW_CANNOT_BE_DELETED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: "A workflow assignment cannot be deleted. Please uncheck the 'Can be deleted' checkbox to continue",
         affectedFields: ['canBeDeleted'],
     },
     ORDER_REQUIRED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Order is required for workflow assignments',
         affectedFields: ['order'],
     },
     ORDER_ALREADY_EXISTS: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This order number is already in use on this template. Please enter a different number to set the workflow order',
         affectedFields: ['order'],
     },
     TEMPLATE_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Template not found',
         affectedFields: [],
     },
     ASSIGNMENT_NOT_FOUND: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Assignment not found',
         affectedFields: [],
     },
     CANNOT_EDIT_IN_USE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This assignment is already being used by a client, and cannot be edited',
         affectedFields: [],
     },
     CANNOT_DELETE_IN_USE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'This assignment is already being used by a client, and cannot be deleted',
         affectedFields: [],
     },
     INVALID_FILING_CATEGORY: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Invalid filing category',
         affectedFields: ['filingCategoryId'],
     },
     ASSIGNMENTS_ORDER_NOT_CONSECUTIVE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: 'Assignment orders must be consecutive starting from 1. Expected orders: {expected}',
         params: ['expected'],
         affectedFields: ['assignments'],
     },
-};
+});