@forwardslashns/taskit-validation-messages 1.10.18 → 1.10.20

package/dist/validation/features/client-records-entity-types-histories.validation-messages.d.ts

@@ -1,83 +1,100 @@
 export declare const CLIENT_RECORDS_ENTITY_TYPES: {
-    readonly ENTITY_TYPE_ID_DOES_NOT_EXIST: {
-        readonly message: "Entity type does not exist";
-        readonly params: readonly ["id"];
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPE_STARTING_DATE: {
-        readonly message: "One or more entity types have a start date that is before the client's date established, {clientDateEstablished}. ({entityType} starting {entityTypeStartingDate}). Please update the entity type start dates to be on or after the client's date established, or update the client's date established.";
-        readonly params: readonly ["clientDateEstablished", "entityType", "entityTypeStartingDate"];
-        readonly affectedFields: readonly ["dateEstablished", "entityType"];
-    };
-    readonly NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPE_STARTING_DATE: {
-        readonly message: "One or more entity types have start dates that are after the client's close date, {clientCloseDate}. {entityType} starting {entityTypeStartingDate}. Please update the entity type/s end date/s to be on or before the client's close date, or update the client's close date.";
-        readonly params: readonly ["clientCloseDate", "entityType", "entityTypeStartingDate"];
-        readonly affectedFields: readonly ["closeDate", "entityType"];
-    };
-    readonly ENTITY_TYPE_STARTING_DATE_NOT_POPULATED: {
-        readonly message: "Current Entity Type Starting Date cannot be Empty";
-        readonly affectedFields: readonly ["entityTypeStartingDate"];
-    };
-    readonly NOT_ALIGNED_ENTITY_TYPE_STARTING_ENDING_DATE: {
-        readonly message: "Entity type starting date needs to be before the ending date";
-        readonly affectedFields: readonly ["entityTypeStartingDate", "entityTypeEndingDate"];
-    };
-    readonly ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
-        readonly message: "Entity types do not exist";
-        readonly params: readonly ["ids"];
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
-        readonly message: "At least one entity type should exist";
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
-        readonly message: "Starting date for {entityType} cannot be empty";
-        readonly params: readonly ["entityType"];
-        readonly affectedFields: readonly ["entityTypeStartingDate"];
-    };
-    readonly NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
-        readonly message: "The ending date for {entityType} must be after its starting date";
-        readonly params: readonly ["entityType"];
-        readonly affectedFields: readonly ["entityTypeStartingDate", "entityTypeEndingDate"];
-    };
-    readonly NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPES_STARTING_DATE: {
-        readonly message: "Adjust the start date to be on or after the client's date established, {clientStartDate}.";
-        readonly params: readonly ["clientStartDate"];
-        readonly affectedFields: readonly ["entityTypeStartingDate", "dateEstablished"];
-    };
-    readonly NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPES_STARTING_DATE: {
-        readonly message: "Adjust the start date to be before the client's close date, {clientCloseDate}.";
-        readonly params: readonly ["clientCloseDate"];
-        readonly affectedFields: readonly ["entityTypeStartingDate", "closeDate"];
-    };
-    readonly ENTITY_TYPES_DATE_GAP_DETECTED: {
-        readonly message: "There is a gap in the timeframes between {currentEntityType}, ending {currentEntityTypeEndDate}, and {nextEntityType}, starting {nextEntityTypeStartDate}. Please adjust the dates to fill this gap.";
-        readonly params: readonly ["currentEntityType", "currentEntityTypeEndDate", "nextEntityType", "nextEntityTypeStartDate"];
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly ENTITY_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
-        readonly message: "There are two entries for {entityType} with timeframes that immediately follow each other. {entityType} ending {firstPeriodEnd}, and {entityType} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {entityType}. ";
-        readonly params: readonly ["entityType", "firstPeriodStart", "firstPeriodEnd", "secondPeriodStart"];
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly ENTITY_TYPE_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
-        readonly message: "There is a gap between the client's date established ({dateEstablished}) and the start of its first entity type ({earliestEntityType} starting {earliestEntityTypeStartDate}). There must be an entity type that begins on {dateEstablished}.";
-        readonly params: readonly ["dateEstablished", "earliestEntityType", "earliestEntityTypeStartDate"];
-        readonly affectedFields: readonly ["entityType", "dateEstablished"];
-    };
-    readonly ENTITY_TYPES_DATES_OVERLAP: {
-        readonly message: "The client already has {entityType} starting from {startDate2} to {endDate2}. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.";
-        readonly params: readonly ["entityType", "startDate1", "endDate1", "startDate2", "endDate2"];
-        readonly affectedFields: readonly ["entityType"];
-    };
-    readonly ALL_NON_LAST_ENTITY_TYPES_REQUIRE_ENDING_DATE: {
-        readonly message: "Only the last entity type can be open without an end date. Add an ending date to the existing entity type before adding a start date for a new entity type.";
-        readonly affectedFields: readonly ["entityTypeEndingDate"];
-    };
-    readonly CURRENT_ENTITY_TYPE_CANNOT_HAVE_ENDING_DATE: {
-        readonly message: "The current entity type cannot have an end date. Please remove the end date for this state.";
-        readonly affectedFields: readonly ["entityTypeEndingDate"];
+    ENTITY_TYPE_ID_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPE_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPE_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ENTITY_TYPE_STARTING_DATE_NOT_POPULATED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_ENTITY_TYPE_STARTING_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPES_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPES_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ENTITY_TYPES_DATE_GAP_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ENTITY_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ENTITY_TYPE_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ENTITY_TYPES_DATES_OVERLAP: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ALL_NON_LAST_ENTITY_TYPES_REQUIRE_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    CURRENT_ENTITY_TYPE_CANNOT_HAVE_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
     };
 };
 //# sourceMappingURL=client-records-entity-types-histories.validation-messages.d.ts.map

package/dist/validation/features/client-records-entity-types-histories.validation-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-records-entity-types-histories.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-records-entity-types-histories.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF9B,CAAC"}
+{"version":3,"file":"client-records-entity-types-histories.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-records-entity-types-histories.validation-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGtC,CAAC"}

package/dist/validation/features/client-records-entity-types-histories.validation-messages.js

@@ -1,85 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIENT_RECORDS_ENTITY_TYPES = void 0;
-exports.CLIENT_RECORDS_ENTITY_TYPES = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.CLIENT_RECORDS_ENTITY_TYPES = (0, validation_message_types_1.defineValidationFeatureMessages)({
     ENTITY_TYPE_ID_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Entity type does not exist`,
         params: ['id'],
         affectedFields: ['entityType'],
     },
     NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPE_STARTING_DATE: {
-        message: `One or more entity types have a start date that is before the client's date established, {clientDateEstablished}. ({entityType} starting {entityTypeStartingDate}). Please update the entity type start dates to be on or after the client's date established, or update the client's date established.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `One or more entity types have a start date that is before the client's date established, '{clientDateEstablished}'. ('{entityType}' starting '{entityTypeStartingDate}'). Please update the entity type start dates to be on or after the client's date established, or update the client's date established.`,
         params: ['clientDateEstablished', 'entityType', 'entityTypeStartingDate'],
         affectedFields: ['dateEstablished', 'entityType'],
     },
     NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPE_STARTING_DATE: {
-        message: `One or more entity types have start dates that are after the client's close date, {clientCloseDate}. {entityType} starting {entityTypeStartingDate}. Please update the entity type/s end date/s to be on or before the client's close date, or update the client's close date.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `One or more entity types have start dates that are after the client's close date, '{clientCloseDate}'. '{entityType}' starting '{entityTypeStartingDate}'. Please update the entity type/s end date/s to be on or before the client's close date, or update the client's close date.`,
         params: ['clientCloseDate', 'entityType', 'entityTypeStartingDate'],
         affectedFields: ['closeDate', 'entityType'],
     },
     ENTITY_TYPE_STARTING_DATE_NOT_POPULATED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Current Entity Type Starting Date cannot be Empty`,
         affectedFields: ['entityTypeStartingDate'],
     },
     NOT_ALIGNED_ENTITY_TYPE_STARTING_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Entity type starting date needs to be before the ending date`,
         affectedFields: ['entityTypeStartingDate', 'entityTypeEndingDate'],
     },
     ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Entity types do not exist`,
         params: ['ids'],
         affectedFields: ['entityType'],
     },
     AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `At least one entity type should exist`,
         affectedFields: ['entityType'],
     },
     ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
-        message: `Starting date for {entityType} cannot be empty`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Starting date for '{entityType}' cannot be empty`,
         params: ['entityType'],
         affectedFields: ['entityTypeStartingDate'],
     },
     NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
-        message: `The ending date for {entityType} must be after its starting date`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `The ending date for '{entityType}' must be after its starting date`,
         params: ['entityType'],
         affectedFields: ['entityTypeStartingDate', 'entityTypeEndingDate'],
     },
     NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPES_STARTING_DATE: {
-        message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Adjust the start date to be on or after the client's date established, '{clientStartDate}'.`,
         params: ['clientStartDate'],
         affectedFields: ['entityTypeStartingDate', 'dateEstablished'],
     },
     NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPES_STARTING_DATE: {
-        message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Adjust the start date to be before the client's close date, '{clientCloseDate}'.`,
         params: ['clientCloseDate'],
         affectedFields: ['entityTypeStartingDate', 'closeDate'],
     },
     ENTITY_TYPES_DATE_GAP_DETECTED: {
-        message: `There is a gap in the timeframes between {currentEntityType}, ending {currentEntityTypeEndDate}, and {nextEntityType}, starting {nextEntityTypeStartDate}. Please adjust the dates to fill this gap.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There is a gap in the timeframes between '{currentEntityType}', ending '{currentEntityTypeEndDate}', and '{nextEntityType}', starting '{nextEntityTypeStartDate}'. Please adjust the dates to fill this gap.`,
         params: ['currentEntityType', 'currentEntityTypeEndDate', 'nextEntityType', 'nextEntityTypeStartDate'],
         affectedFields: ['entityType'],
     },
     ENTITY_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
-        message: `There are two entries for {entityType} with timeframes that immediately follow each other. {entityType} ending {firstPeriodEnd}, and {entityType} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {entityType}. `,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There are two entries for '{entityType}' with timeframes that immediately follow each other. '{entityType}' ending '{firstPeriodEnd}', and '{entityType}' starting '{secondPeriodStart}'. Please update one entry to include the entire timeframe for '{entityType}'. `,
         params: ['entityType', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
         affectedFields: ['entityType'],
     },
     ENTITY_TYPE_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
-        message: `There is a gap between the client's date established ({dateEstablished}) and the start of its first entity type ({earliestEntityType} starting {earliestEntityTypeStartDate}). There must be an entity type that begins on {dateEstablished}.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There is a gap between the client's date established ('{dateEstablished}') and the start of its first entity type ('{earliestEntityType}' starting '{earliestEntityTypeStartDate}'). There must be an entity type that begins on '{dateEstablished}'.`,
         params: ['dateEstablished', 'earliestEntityType', 'earliestEntityTypeStartDate'],
         affectedFields: ['entityType', 'dateEstablished'],
     },
     ENTITY_TYPES_DATES_OVERLAP: {
-        message: `The client already has {entityType} starting from {startDate2} to {endDate2}. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `The client already has '{entityType}' starting from '{startDate2}' to '{endDate2}'. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.`,
         params: ['entityType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
         affectedFields: ['entityType'],
     },
     ALL_NON_LAST_ENTITY_TYPES_REQUIRE_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Only the last entity type can be open without an end date. Add an ending date to the existing entity type before adding a start date for a new entity type.`,
         affectedFields: ['entityTypeEndingDate'],
     },
     CURRENT_ENTITY_TYPE_CANNOT_HAVE_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `The current entity type cannot have an end date. Please remove the end date for this state.`,
         affectedFields: ['entityTypeEndingDate'],
     },
-};
+});

package/dist/validation/features/client-records-filing-statuses-histories.validation-messages.d.ts

@@ -1,83 +1,100 @@
 export declare const CLIENT_RECORDS_FILING_STATUSES: {
-    readonly FILING_STATUS_ID_DOES_NOT_EXIST: {
-        readonly message: "Sub/Parent status does not exist";
-        readonly params: readonly ["id"];
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUS_STARTING_DATE: {
-        readonly message: "The Sub/Parent status {filingStatus} starts on {filingStatusStartingDate} which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the Sub/Parent status or the client's date established.";
-        readonly params: readonly ["clientDateEstablished", "filingStatus", "filingStatusStartingDate"];
-        readonly affectedFields: readonly ["dateEstablished", "filingStatus"];
-    };
-    readonly NOT_ALIGNED_CLOSE_DATE_FILING_STATUS_STARTING_DATE: {
-        readonly message: "One or more Sub/Parent status have a start date which is after the client's close date of {clientCloseDate}. {filingStatus}, starting {filingStatusStartingDate}. Please update the start date to be earlier than the client's close date, or update the client's close date.";
-        readonly params: readonly ["clientCloseDate", "filingStatus", "filingStatusStartingDate"];
-        readonly affectedFields: readonly ["closeDate", "filingStatus"];
-    };
-    readonly FILING_STATUS_STARTING_DATE_NOT_POPULATED: {
-        readonly message: "Current Sub/Parent status Starting Date cannot be Empty";
-        readonly affectedFields: readonly ["filingStatusStartingDate"];
-    };
-    readonly NOT_ALIGNED_FILING_STATUS_STARTING_ENDING_DATE: {
-        readonly message: "Sub/Parent status starting date needs to be before the ending date";
-        readonly affectedFields: readonly ["filingStatusStartingDate", "filingStatusEndingDate"];
-    };
-    readonly FILING_STATUSES_IDS_DOES_NOT_EXIST: {
-        readonly message: "Sub/Parent status do not exist";
-        readonly params: readonly ["ids"];
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly AT_LEAST_ONE_FILING_STATUS_SHOULD_EXIST: {
-        readonly message: "At least one Sub/Parent status should exist";
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly FILING_STATUSES_STARTING_DATE_NOT_POPULATED: {
-        readonly message: "Starting date for {filingStatus} cannot be empty";
-        readonly params: readonly ["filingStatus"];
-        readonly affectedFields: readonly ["filingStatusStartingDate"];
-    };
-    readonly NOT_ALIGNED_FILING_STATUSES_STARTING_ENDING_DATE: {
-        readonly message: "The ending date for {filingStatus} must be after its starting date";
-        readonly params: readonly ["filingStatus"];
-        readonly affectedFields: readonly ["filingStatusStartingDate", "filingStatusEndingDate"];
-    };
-    readonly NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUSES_STARTING_DATE: {
-        readonly message: "Adjust the start date to be on or after the client's date established, {clientStartDate}.";
-        readonly params: readonly ["clientStartDate"];
-        readonly affectedFields: readonly ["filingStatusStartingDate", "dateEstablished"];
-    };
-    readonly NOT_ALIGNED_CLOSE_DATE_FILING_STATUSES_STARTING_DATE: {
-        readonly message: "Adjust the start date to be before the client's close date, {clientCloseDate}.";
-        readonly params: readonly ["clientCloseDate"];
-        readonly affectedFields: readonly ["filingStatusStartingDate", "closeDate"];
-    };
-    readonly FILING_STATUSES_DATE_GAP_DETECTED: {
-        readonly message: "There is a gap in the timeframes between {currentFilingStatus}, ending {currentFilingStatusEndDate}, and {nextFilingStatus}, starting {nextFilingStatusStartDate}. Please adjust the dates to fill this gap.";
-        readonly params: readonly ["currentFilingStatus", "currentFilingStatusEndDate", "nextFilingStatus", "nextFilingStatusStartDate"];
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly FILING_STATUSES_CONSECUTIVE_DUPLICATES_DETECTED: {
-        readonly message: "There are two entries for {filingStatus} with timeframes that immediately follow each other. {filingStatus} ending {firstPeriodEnd}, and {filingStatus} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {filingStatus}. ";
-        readonly params: readonly ["filingStatus", "firstPeriodStart", "firstPeriodEnd", "secondPeriodStart"];
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly FILING_STATUS_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
-        readonly message: "There is a gap between the client's date established ({dateEstablished}) and the start date of the first Sub/Parent status ({earliestFilingStatusStartDate}). Please ensure that the status of one Sub/Parent status matches the client's date established.";
-        readonly params: readonly ["dateEstablished", "earliestFilingStatusStartDate"];
-        readonly affectedFields: readonly ["filingStatus", "dateEstablished"];
-    };
-    readonly FILING_STATUSES_DATES_OVERLAP: {
-        readonly message: "The client already has {filingStatus} starting from {startDate2} to {endDate2}. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.";
-        readonly params: readonly ["filingStatus", "startDate1", "endDate1", "startDate2", "endDate2"];
-        readonly affectedFields: readonly ["filingStatus"];
-    };
-    readonly ALL_NON_LAST_FILING_STATUSES_REQUIRE_ENDING_DATE: {
-        readonly message: "Only the last Sub/Parent status can be open without an end date. Add an ending date to the existing Sub/Parent status before adding a start date for a new Sub/Parent status.";
-        readonly affectedFields: readonly ["filingStatusEndingDate"];
-    };
-    readonly CURRENT_FILING_STATUS_CANNOT_HAVE_ENDING_DATE: {
-        readonly message: "The current Sub/Parent status cannot have an end date. Please remove the end date for this state.";
-        readonly affectedFields: readonly ["filingStatusEndingDate"];
+    FILING_STATUS_ID_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUS_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_CLOSE_DATE_FILING_STATUS_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FILING_STATUS_STARTING_DATE_NOT_POPULATED: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_FILING_STATUS_STARTING_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    FILING_STATUSES_IDS_DOES_NOT_EXIST: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    AT_LEAST_ONE_FILING_STATUS_SHOULD_EXIST: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    FILING_STATUSES_STARTING_DATE_NOT_POPULATED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_FILING_STATUSES_STARTING_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUSES_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    NOT_ALIGNED_CLOSE_DATE_FILING_STATUSES_STARTING_DATE: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FILING_STATUSES_DATE_GAP_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FILING_STATUSES_CONSECUTIVE_DUPLICATES_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FILING_STATUS_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    FILING_STATUSES_DATES_OVERLAP: {
+        severity: "error";
+        message: string;
+        params: string[];
+        affectedFields: string[];
+    };
+    ALL_NON_LAST_FILING_STATUSES_REQUIRE_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
+    };
+    CURRENT_FILING_STATUS_CANNOT_HAVE_ENDING_DATE: {
+        severity: "error";
+        message: string;
+        affectedFields: string[];
     };
 };
 //# sourceMappingURL=client-records-filing-statuses-histories.validation-messages.d.ts.map

package/dist/validation/features/client-records-filing-statuses-histories.validation-messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client-records-filing-statuses-histories.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-records-filing-statuses-histories.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFjC,CAAC"}
+{"version":3,"file":"client-records-filing-statuses-histories.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-records-filing-statuses-histories.validation-messages.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkGzC,CAAC"}

package/dist/validation/features/client-records-filing-statuses-histories.validation-messages.js

@@ -1,85 +1,103 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLIENT_RECORDS_FILING_STATUSES = void 0;
-exports.CLIENT_RECORDS_FILING_STATUSES = {
+const validation_message_types_1 = require("../validation-message.types");
+exports.CLIENT_RECORDS_FILING_STATUSES = (0, validation_message_types_1.defineValidationFeatureMessages)({
     FILING_STATUS_ID_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Sub/Parent status does not exist`,
         params: ['id'],
         affectedFields: ['filingStatus'],
     },
     NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUS_STARTING_DATE: {
-        message: `The Sub/Parent status {filingStatus} starts on {filingStatusStartingDate} which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the Sub/Parent status or the client's date established.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `The Sub/Parent status '{filingStatus}' starts on '{filingStatusStartingDate}' which is earlier than the client's date established, '{clientDateEstablished}'. Please adjust the start date of the Sub/Parent status or the client's date established.`,
         params: ['clientDateEstablished', 'filingStatus', 'filingStatusStartingDate'],
         affectedFields: ['dateEstablished', 'filingStatus'],
     },
     NOT_ALIGNED_CLOSE_DATE_FILING_STATUS_STARTING_DATE: {
-        message: `One or more Sub/Parent status have a start date which is after the client's close date of {clientCloseDate}. {filingStatus}, starting {filingStatusStartingDate}. Please update the start date to be earlier than the client's close date, or update the client's close date.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `One or more Sub/Parent status have a start date which is after the client's close date of '{clientCloseDate}'. '{filingStatus}', starting '{filingStatusStartingDate}'. Please update the start date to be earlier than the client's close date, or update the client's close date.`,
         params: ['clientCloseDate', 'filingStatus', 'filingStatusStartingDate'],
         affectedFields: ['closeDate', 'filingStatus'],
     },
     FILING_STATUS_STARTING_DATE_NOT_POPULATED: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Current Sub/Parent status Starting Date cannot be Empty`,
         affectedFields: ['filingStatusStartingDate'],
     },
     NOT_ALIGNED_FILING_STATUS_STARTING_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Sub/Parent status starting date needs to be before the ending date`,
         affectedFields: ['filingStatusStartingDate', 'filingStatusEndingDate'],
     },
     FILING_STATUSES_IDS_DOES_NOT_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Sub/Parent status do not exist`,
         params: ['ids'],
         affectedFields: ['filingStatus'],
     },
     AT_LEAST_ONE_FILING_STATUS_SHOULD_EXIST: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `At least one Sub/Parent status should exist`,
         affectedFields: ['filingStatus'],
     },
     FILING_STATUSES_STARTING_DATE_NOT_POPULATED: {
-        message: `Starting date for {filingStatus} cannot be empty`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Starting date for '{filingStatus}' cannot be empty`,
         params: ['filingStatus'],
         affectedFields: ['filingStatusStartingDate'],
     },
     NOT_ALIGNED_FILING_STATUSES_STARTING_ENDING_DATE: {
-        message: `The ending date for {filingStatus} must be after its starting date`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `The ending date for '{filingStatus}' must be after its starting date`,
         params: ['filingStatus'],
         affectedFields: ['filingStatusStartingDate', 'filingStatusEndingDate'],
     },
     NOT_ALIGNED_DATE_ESTABLISHED_FILING_STATUSES_STARTING_DATE: {
-        message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Adjust the start date to be on or after the client's date established, '{clientStartDate}'.`,
         params: ['clientStartDate'],
         affectedFields: ['filingStatusStartingDate', 'dateEstablished'],
     },
     NOT_ALIGNED_CLOSE_DATE_FILING_STATUSES_STARTING_DATE: {
-        message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `Adjust the start date to be before the client's close date, '{clientCloseDate}'.`,
         params: ['clientCloseDate'],
         affectedFields: ['filingStatusStartingDate', 'closeDate'],
     },
     FILING_STATUSES_DATE_GAP_DETECTED: {
-        message: `There is a gap in the timeframes between {currentFilingStatus}, ending {currentFilingStatusEndDate}, and {nextFilingStatus}, starting {nextFilingStatusStartDate}. Please adjust the dates to fill this gap.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There is a gap in the timeframes between '{currentFilingStatus}', ending '{currentFilingStatusEndDate}', and '{nextFilingStatus}', starting '{nextFilingStatusStartDate}'. Please adjust the dates to fill this gap.`,
         params: ['currentFilingStatus', 'currentFilingStatusEndDate', 'nextFilingStatus', 'nextFilingStatusStartDate'],
         affectedFields: ['filingStatus'],
     },
     FILING_STATUSES_CONSECUTIVE_DUPLICATES_DETECTED: {
-        message: `There are two entries for {filingStatus} with timeframes that immediately follow each other. {filingStatus} ending {firstPeriodEnd}, and {filingStatus} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {filingStatus}. `,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There are two entries for '{filingStatus}' with timeframes that immediately follow each other. '{filingStatus}' ending '{firstPeriodEnd}', and '{filingStatus}' starting '{secondPeriodStart}'. Please update one entry to include the entire timeframe for '{filingStatus}'. `,
         params: ['filingStatus', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
         affectedFields: ['filingStatus'],
     },
     FILING_STATUS_EARLIEST_AND_DATE_ESTABLISHED_GAP_DETECTED: {
-        message: `There is a gap between the client's date established ({dateEstablished}) and the start date of the first Sub/Parent status ({earliestFilingStatusStartDate}). Please ensure that the status of one Sub/Parent status matches the client's date established.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `There is a gap between the client's date established ('{dateEstablished}') and the start date of the first Sub/Parent status ('{earliestFilingStatusStartDate}'). Please ensure that the status of one Sub/Parent status matches the client's date established.`,
         params: ['dateEstablished', 'earliestFilingStatusStartDate'],
         affectedFields: ['filingStatus', 'dateEstablished'],
     },
     FILING_STATUSES_DATES_OVERLAP: {
-        message: `The client already has {filingStatus} starting from {startDate2} to {endDate2}. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.`,
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
+        message: `The client already has '{filingStatus}' starting from '{startDate2}' to '{endDate2}'. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.`,
         params: ['filingStatus', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
         affectedFields: ['filingStatus'],
     },
     ALL_NON_LAST_FILING_STATUSES_REQUIRE_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `Only the last Sub/Parent status can be open without an end date. Add an ending date to the existing Sub/Parent status before adding a start date for a new Sub/Parent status.`,
         affectedFields: ['filingStatusEndingDate'],
     },
     CURRENT_FILING_STATUS_CANNOT_HAVE_ENDING_DATE: {
+        severity: validation_message_types_1.VALIDATION_SEVERITY.ERROR,
         message: `The current Sub/Parent status cannot have an end date. Please remove the end date for this state.`,
         affectedFields: ['filingStatusEndingDate'],
     },
-};
+});