@forwardslashns/taskit-validation-messages 1.0.25 → 1.0.26

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "trailingComma": "es5",
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": true,
+  "printWidth": 120,
+  "endOfLine": "auto"
+}

package/README.md

@@ -8,4 +8,4 @@ The package exposes validation messages that can be retrieved using specific ali
 
 # getValidationMessage
 
-This mechanism allows for the retrieval and dynamic creation of validation messages by passing their aliases and any required parameters. Parameters are optional and passed as objects, following the structure defined within each validation message itself.
+This mechanism allows for the retrieval and dynamic creation of validation messages by passing their aliases and any required parameters. Parameters are optional and passed as objects, following the structure defined within each validation message itself.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { getValidationMessage } from "./validation/validation-message.formatter";
-import { VALIDATION_MESSAGES } from "./validation/validation-messages";
+import { getValidationMessage } from './validation/validation-message.formatter';
+import { VALIDATION_MESSAGES } from './validation/validation-messages';
 export { VALIDATION_MESSAGES, getValidationMessage };
 //# sourceMappingURL=index.d.ts.map

package/dist/validation/validation-message.formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation-message.formatter.d.ts","sourceRoot":"","sources":["../../src/validation/validation-message.formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,KAAK,QAAQ,GAAG,MAAM,OAAO,mBAAmB,CAAC;AACjD,KAAK,SAAS,CAAC,CAAC,SAAS,QAAQ,IAAI,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3E,KAAK,kBAAkB,CACrB,CAAC,SAAS,QAAQ,EAClB,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,IACpB,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;IAC7C,MAAM,EAAE,MAAM,CAAC,SAAS,SAAS,MAAM,EAAE,CAAC;CAC3C,GACG,CAAC,GACD,EAAE,CAAC;AACP,KAAK,aAAa,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAC;AAM/E,eAAO,MAAM,oBAAoB,GAC/B,WAAW,SAAS,QAAQ,EAC5B,gBAAgB,SAAS,SAAS,CAAC,WAAW,CAAC,EAE/C,SAAS,WAAW,EACpB,cAAc,gBAAgB,EAC9B,SAAS,aAAa,CAAC,kBAAkB,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,KACxE,MAuDF,CAAC"}
+{"version":3,"file":"validation-message.formatter.d.ts","sourceRoot":"","sources":["../../src/validation/validation-message.formatter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,KAAK,QAAQ,GAAG,MAAM,OAAO,mBAAmB,CAAC;AACjD,KAAK,SAAS,CAAC,CAAC,SAAS,QAAQ,IAAI,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC3E,KAAK,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EAAE,CAAC,SAAS,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS;IAC/G,MAAM,EAAE,MAAM,CAAC,SAAS,SAAS,MAAM,EAAE,CAAC;CAC3C,GACG,CAAC,GACD,EAAE,CAAC;AACP,KAAK,aAAa,CAAC,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI;KAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAAE,CAAC;AAM/E,eAAO,MAAM,oBAAoB,GAAI,WAAW,SAAS,QAAQ,EAAE,gBAAgB,SAAS,SAAS,CAAC,WAAW,CAAC,EAChH,SAAS,WAAW,EACpB,cAAc,gBAAgB,EAC9B,SAAS,aAAa,CAAC,kBAAkB,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC,KACxE,MA4CF,CAAC"}

package/dist/validation/validation-message.formatter.js

@@ -10,9 +10,7 @@ const getValidationMessage = (feature, featureError, params) => {
     const inputParams = params || {};
     const errorSuffix = `for feature: ${String(feature)}, error: ${String(featureError)}`;
     let message = messageConfig.message;
-    const expectedParams = messageConfig.params?.length
-        ? messageConfig.params
-        : [];
+    const expectedParams = messageConfig.params?.length ? messageConfig.params : [];
     if (!message) {
         throw new Error(`Validation error message is not defined properly in configuration ${errorSuffix}`);
     }

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

@@ -243,6 +243,86 @@ export declare const VALIDATION_MESSAGES: {
         readonly ALL_NON_LAST_DOMESTIC_STATES_REQUIRE_ENDING_DATE: {
             readonly message: "Only the last domestic state can be open without an end date. Add an ending date to the existing state before adding a start date for a new state.";
         };
+        readonly ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+            readonly message: "Entity types with ids '{ids}' do not exist";
+            readonly params: readonly ["ids"];
+        };
+        readonly AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+            readonly message: "At least one entity type should exist";
+        };
+        readonly ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
+            readonly message: "Entity Type Starting Date cannot be Empty";
+        };
+        readonly NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
+            readonly message: "Entity type starting date needs to be before the ending date";
+        };
+        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 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 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 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 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 ENTITY_TYPES_DATES_OVERLAP: {
+            readonly message: "There are multiple entries for {entityType} with overlapping timeframes: {entityType} from {startDate1} to {endDate1}, {entityType} from {startDate2} to {endDate2}. An entity type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {entityType} entries to remove the overlap.";
+            readonly params: readonly ["entityType", "startDate1", "endDate1", "startDate2", "endDate2"];
+        };
+        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 FILING_TYPES_IDS_DOES_NOT_EXIST: {
+            readonly message: "Filing types with ids '{ids}' do not exist";
+            readonly params: readonly ["ids"];
+        };
+        readonly AT_LEAST_ONE_FILING_TYPE_SHOULD_EXIST: {
+            readonly message: "At least one filing type should exist";
+        };
+        readonly FILING_TYPES_STARTING_DATE_NOT_POPULATED: {
+            readonly message: "Filing Type Starting Date cannot be Empty";
+        };
+        readonly NOT_ALIGNED_FILING_TYPES_STARTING_ENDING_DATE: {
+            readonly message: "Filing type starting date needs to be before the ending date";
+        };
+        readonly NOT_ALIGNED_DATE_ESTABLISHED_FILING_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 NOT_ALIGNED_CLOSE_DATE_FILING_TYPES_STARTING_DATE: {
+            readonly message: "Adjust the start date to be before the client's close date, {clientCloseDate}.";
+            readonly params: readonly ["clientCloseDate"];
+        };
+        readonly FILING_TYPES_DATE_GAP_DETECTED: {
+            readonly message: "There is a gap in the timeframes between {currentFilingType}, ending {currentFilingTypeEndDate}, and {nextFilingType}, starting {nextFilingTypeStartDate}. Please adjust the dates to fill this gap.";
+            readonly params: readonly ["currentFilingType", "currentFilingTypeEndDate", "nextFilingType", "nextFilingTypeStartDate"];
+        };
+        readonly FILING_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
+            readonly message: "There are two entries for {filingType} with timeframes that immediately follow each other. {filingType} ending {firstPeriodEnd}, and {filingType} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {filingType}. ";
+            readonly params: readonly ["filingType", "firstPeriodStart", "firstPeriodEnd", "secondPeriodStart"];
+        };
+        readonly FILING_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 filing type ({earliestFilingType} starting {earliestFilingTypeStartDate}). There must be a filing type that begins on {dateEstablished}.";
+            readonly params: readonly ["dateEstablished", "earliestFilingType", "earliestFilingTypeStartDate"];
+        };
+        readonly FILING_TYPES_DATES_OVERLAP: {
+            readonly message: "There are multiple entries for {filingType} with overlapping timeframes: {filingType} from {startDate1} to {endDate1}, {filingType} from {startDate2} to {endDate2}. A filing type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {filingType} entries to remove the overlap.";
+            readonly params: readonly ["filingType", "startDate1", "endDate1", "startDate2", "endDate2"];
+        };
+        readonly ALL_NON_LAST_FILING_TYPES_REQUIRE_ENDING_DATE: {
+            readonly message: "Only the last filing type can be open without an end date. Add an ending date to the existing filing type before adding a start date for a new filing type.";
+        };
     };
     readonly FILING_CATEGORY: {
         readonly INVALID_REQUEST: {

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

@@ -1 +1 @@
-{"version":3,"file":"validation-messages.d.ts","sourceRoot":"","sources":["../../src/validation/validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgWtB,CAAC"}
+{"version":3,"file":"validation-messages.d.ts","sourceRoot":"","sources":["../../src/validation/validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2atB,CAAC"}

package/dist/validation/validation-messages.js

@@ -114,11 +114,7 @@ exports.VALIDATION_MESSAGES = {
         },
         NOT_ALIGNED_DATE_ESTABLISHED_DOMESTIC_STATE_STARTING_DATE: {
             message: `The state, {domesticState}, starts on {domesticStateStartingDate}, which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the state or the client's date established.`,
-            params: [
-                'clientDateEstablished',
-                'domesticState',
-                'domesticStateStartingDate',
-            ],
+            params: ['clientDateEstablished', 'domesticState', 'domesticStateStartingDate'],
         },
         NOT_ALIGNED_DATE_ESTABLISHED_CLOSE_DATE: {
             message: `Adjust the close date to be after the date established.`,
@@ -226,15 +222,11 @@ exports.VALIDATION_MESSAGES = {
         },
         NOT_ALIGNED_DATE_ESTABLISHED_STATES_STARTING_DATE: {
             message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
-            params: [
-                'clientStartDate',
-            ],
+            params: ['clientStartDate'],
         },
         NOT_ALIGNED_CLOSE_DATE_STATES_STARTING_DATE: {
             message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
-            params: [
-                'clientCloseDate',
-            ],
+            params: ['clientCloseDate'],
         },
         DOMESTIC_STATES_DATE_GAP_DETECTED: {
             message: `There is a gap in the timeframes between {currentState}, ending {currentStateEndDate}, and {nextState}, starting {nextStateStartDate}. Please adjust the dates to fill this gap.`,
@@ -255,6 +247,88 @@ exports.VALIDATION_MESSAGES = {
         ALL_NON_LAST_DOMESTIC_STATES_REQUIRE_ENDING_DATE: {
             message: `Only the last domestic state can be open without an end date. Add an ending date to the existing state before adding a start date for a new state.`,
         },
+        //UPDATE-ENTITY-TYPES-VALIDATIONS
+        ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+            message: `Entity types with ids '{ids}' do not exist`,
+            params: ['ids'],
+        },
+        AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+            message: `At least one entity type should exist`,
+        },
+        ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
+            message: `Entity Type Starting Date cannot be Empty`,
+        },
+        NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
+            message: `Entity type starting date needs to be before the ending date`,
+        },
+        NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPES_STARTING_DATE: {
+            message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+            params: ['clientStartDate'],
+        },
+        NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPES_STARTING_DATE: {
+            message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+            params: ['clientCloseDate'],
+        },
+        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.`,
+            params: ['currentEntityType', 'currentEntityTypeEndDate', 'nextEntityType', 'nextEntityTypeStartDate'],
+        },
+        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}. `,
+            params: ['entityType', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
+        },
+        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}.`,
+            params: ['dateEstablished', 'earliestEntityType', 'earliestEntityTypeStartDate'],
+        },
+        ENTITY_TYPES_DATES_OVERLAP: {
+            message: `There are multiple entries for {entityType} with overlapping timeframes: {entityType} from {startDate1} to {endDate1}, {entityType} from {startDate2} to {endDate2}. An entity type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {entityType} entries to remove the overlap.`,
+            params: ['entityType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+        },
+        ALL_NON_LAST_ENTITY_TYPES_REQUIRE_ENDING_DATE: {
+            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.`,
+        },
+        //UPDATE-FILING-TYPES-VALIDATIONS
+        FILING_TYPES_IDS_DOES_NOT_EXIST: {
+            message: `Filing types with ids '{ids}' do not exist`,
+            params: ['ids'],
+        },
+        AT_LEAST_ONE_FILING_TYPE_SHOULD_EXIST: {
+            message: `At least one filing type should exist`,
+        },
+        FILING_TYPES_STARTING_DATE_NOT_POPULATED: {
+            message: `Filing Type Starting Date cannot be Empty`,
+        },
+        NOT_ALIGNED_FILING_TYPES_STARTING_ENDING_DATE: {
+            message: `Filing type starting date needs to be before the ending date`,
+        },
+        NOT_ALIGNED_DATE_ESTABLISHED_FILING_TYPES_STARTING_DATE: {
+            message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+            params: ['clientStartDate'],
+        },
+        NOT_ALIGNED_CLOSE_DATE_FILING_TYPES_STARTING_DATE: {
+            message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+            params: ['clientCloseDate'],
+        },
+        FILING_TYPES_DATE_GAP_DETECTED: {
+            message: `There is a gap in the timeframes between {currentFilingType}, ending {currentFilingTypeEndDate}, and {nextFilingType}, starting {nextFilingTypeStartDate}. Please adjust the dates to fill this gap.`,
+            params: ['currentFilingType', 'currentFilingTypeEndDate', 'nextFilingType', 'nextFilingTypeStartDate'],
+        },
+        FILING_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
+            message: `There are two entries for {filingType} with timeframes that immediately follow each other. {filingType} ending {firstPeriodEnd}, and {filingType} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {filingType}. `,
+            params: ['filingType', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
+        },
+        FILING_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 filing type ({earliestFilingType} starting {earliestFilingTypeStartDate}). There must be a filing type that begins on {dateEstablished}.`,
+            params: ['dateEstablished', 'earliestFilingType', 'earliestFilingTypeStartDate'],
+        },
+        FILING_TYPES_DATES_OVERLAP: {
+            message: `There are multiple entries for {filingType} with overlapping timeframes: {filingType} from {startDate1} to {endDate1}, {filingType} from {startDate2} to {endDate2}. A filing type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {filingType} entries to remove the overlap.`,
+            params: ['filingType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+        },
+        ALL_NON_LAST_FILING_TYPES_REQUIRE_ENDING_DATE: {
+            message: `Only the last filing type can be open without an end date. Add an ending date to the existing filing type before adding a start date for a new filing type.`,
+        },
     },
     FILING_CATEGORY: {
         INVALID_REQUEST: {

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@forwardslashns/taskit-validation-messages",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "commonjs",
   "scripts": {
     "build": "rimraf ./dist && tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "format:fix": "prettier --write --ignore-path .gitignore ."
   },
   "engines": {
     "node": ">=22.0.0"
@@ -20,7 +21,8 @@
   "devDependencies": {
     "@types/node": "^22.9.1",
     "rimraf": "^6.0.1",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "prettier": "^3.5.3"
   },
   "repository": {
     "type": "git",

package/src/index.ts

@@ -1,4 +1,4 @@
-import { getValidationMessage } from "./validation/validation-message.formatter";
-import { VALIDATION_MESSAGES } from "./validation/validation-messages";
+import { getValidationMessage } from './validation/validation-message.formatter';
+import { VALIDATION_MESSAGES } from './validation/validation-messages';
 
 export { VALIDATION_MESSAGES, getValidationMessage };

package/src/validation/validation-message.formatter.ts

@@ -2,10 +2,7 @@ import { VALIDATION_MESSAGES } from './validation-messages';
 
 type Features = keyof typeof VALIDATION_MESSAGES;
 type ErrorType<F extends Features> = keyof (typeof VALIDATION_MESSAGES)[F];
-type ErrorMessageParams<
-  F extends Features,
-  E extends ErrorType<F>,
-> = (typeof VALIDATION_MESSAGES)[F][E] extends {
+type ErrorMessageParams<F extends Features, E extends ErrorType<F>> = (typeof VALIDATION_MESSAGES)[F][E] extends {
   params: infer P extends readonly string[];
 }
   ? P
@@ -16,17 +13,12 @@ type MessageConfig = {
   params?: readonly string[];
 };
 
-export const getValidationMessage = <
-  FeatureType extends Features,
-  FeatureErrorType extends ErrorType<FeatureType>,
->(
+export const getValidationMessage = <FeatureType extends Features, FeatureErrorType extends ErrorType<FeatureType>>(
   feature: FeatureType,
   featureError: FeatureErrorType,
   params?: MessageParams<ErrorMessageParams<FeatureType, FeatureErrorType>>
 ): string => {
-  const messageConfig = VALIDATION_MESSAGES[feature][
-    featureError
-  ] as MessageConfig;
+  const messageConfig = VALIDATION_MESSAGES[feature][featureError] as MessageConfig;
 
   if (!messageConfig) {
     throw new Error(
@@ -37,20 +29,14 @@ export const getValidationMessage = <
   const inputParams = params || {};
   const errorSuffix = `for feature: ${String(feature)}, error: ${String(featureError)}`;
   let message = messageConfig.message;
-  const expectedParams = messageConfig.params?.length
-    ? messageConfig.params
-    : [];
+  const expectedParams = messageConfig.params?.length ? messageConfig.params : [];
 
   if (!message) {
-    throw new Error(
-      `Validation error message is not defined properly in configuration ${errorSuffix}`
-    );
+    throw new Error(`Validation error message is not defined properly in configuration ${errorSuffix}`);
   }
 
   if (params && !expectedParams.length) {
-    throw new Error(
-      `Validation error params are not defined properly in configuration ${errorSuffix}`
-    );
+    throw new Error(`Validation error params are not defined properly in configuration ${errorSuffix}`);
   }
 
   expectedParams.forEach((param) => {
@@ -71,10 +57,7 @@ export const getValidationMessage = <
   }
 
   expectedParams.forEach((param) => {
-    message = message.replaceAll(
-      `{${param}}`,
-      (inputParams as Record<string, string>)[param]
-    );
+    message = message.replaceAll(`{${param}}`, (inputParams as Record<string, string>)[param]);
   });
 
   return message;

package/src/validation/validation-messages.ts

@@ -111,11 +111,7 @@ export const VALIDATION_MESSAGES = {
     },
     NOT_ALIGNED_DATE_ESTABLISHED_DOMESTIC_STATE_STARTING_DATE: {
       message: `The state, {domesticState}, starts on {domesticStateStartingDate}, which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the state or the client's date established.`,
-      params: [
-        'clientDateEstablished',
-        'domesticState',
-        'domesticStateStartingDate',
-      ],
+      params: ['clientDateEstablished', 'domesticState', 'domesticStateStartingDate'],
     },
     NOT_ALIGNED_DATE_ESTABLISHED_CLOSE_DATE: {
       message: `Adjust the close date to be after the date established.`,
@@ -223,15 +219,11 @@ export const VALIDATION_MESSAGES = {
     },
     NOT_ALIGNED_DATE_ESTABLISHED_STATES_STARTING_DATE: {
       message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
-      params: [
-        'clientStartDate',
-      ],
+      params: ['clientStartDate'],
     },
     NOT_ALIGNED_CLOSE_DATE_STATES_STARTING_DATE: {
       message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
-      params: [
-        'clientCloseDate',
-      ],
+      params: ['clientCloseDate'],
     },
     DOMESTIC_STATES_DATE_GAP_DETECTED: {
       message: `There is a gap in the timeframes between {currentState}, ending {currentStateEndDate}, and {nextState}, starting {nextStateStartDate}. Please adjust the dates to fill this gap.`,
@@ -252,6 +244,90 @@ export const VALIDATION_MESSAGES = {
     ALL_NON_LAST_DOMESTIC_STATES_REQUIRE_ENDING_DATE: {
       message: `Only the last domestic state can be open without an end date. Add an ending date to the existing state before adding a start date for a new state.`,
     },
+
+    //UPDATE-ENTITY-TYPES-VALIDATIONS
+    ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+      message: `Entity types with ids '{ids}' do not exist`,
+      params: ['ids'],
+    },
+    AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+      message: `At least one entity type should exist`,
+    },
+    ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
+      message: `Entity Type Starting Date cannot be Empty`,
+    },
+    NOT_ALIGNED_ENTITY_TYPES_STARTING_ENDING_DATE: {
+      message: `Entity type starting date needs to be before the ending date`,
+    },
+    NOT_ALIGNED_DATE_ESTABLISHED_ENTITY_TYPES_STARTING_DATE: {
+      message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+      params: ['clientStartDate'],
+    },
+    NOT_ALIGNED_CLOSE_DATE_ENTITY_TYPES_STARTING_DATE: {
+      message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+      params: ['clientCloseDate'],
+    },
+    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.`,
+      params: ['currentEntityType', 'currentEntityTypeEndDate', 'nextEntityType', 'nextEntityTypeStartDate'],
+    },
+    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}. `,
+      params: ['entityType', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
+    },
+    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}.`,
+      params: ['dateEstablished', 'earliestEntityType', 'earliestEntityTypeStartDate'],
+    },
+    ENTITY_TYPES_DATES_OVERLAP: {
+      message: `There are multiple entries for {entityType} with overlapping timeframes: {entityType} from {startDate1} to {endDate1}, {entityType} from {startDate2} to {endDate2}. An entity type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {entityType} entries to remove the overlap.`,
+      params: ['entityType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+    },
+    ALL_NON_LAST_ENTITY_TYPES_REQUIRE_ENDING_DATE: {
+      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.`,
+    },
+
+    //UPDATE-FILING-TYPES-VALIDATIONS
+    FILING_TYPES_IDS_DOES_NOT_EXIST: {
+      message: `Filing types with ids '{ids}' do not exist`,
+      params: ['ids'],
+    },
+    AT_LEAST_ONE_FILING_TYPE_SHOULD_EXIST: {
+      message: `At least one filing type should exist`,
+    },
+    FILING_TYPES_STARTING_DATE_NOT_POPULATED: {
+      message: `Filing Type Starting Date cannot be Empty`,
+    },
+    NOT_ALIGNED_FILING_TYPES_STARTING_ENDING_DATE: {
+      message: `Filing type starting date needs to be before the ending date`,
+    },
+    NOT_ALIGNED_DATE_ESTABLISHED_FILING_TYPES_STARTING_DATE: {
+      message: `Adjust the start date to be on or after the client's date established, {clientStartDate}.`,
+      params: ['clientStartDate'],
+    },
+    NOT_ALIGNED_CLOSE_DATE_FILING_TYPES_STARTING_DATE: {
+      message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+      params: ['clientCloseDate'],
+    },
+    FILING_TYPES_DATE_GAP_DETECTED: {
+      message: `There is a gap in the timeframes between {currentFilingType}, ending {currentFilingTypeEndDate}, and {nextFilingType}, starting {nextFilingTypeStartDate}. Please adjust the dates to fill this gap.`,
+      params: ['currentFilingType', 'currentFilingTypeEndDate', 'nextFilingType', 'nextFilingTypeStartDate'],
+    },
+    FILING_TYPES_CONSECUTIVE_DUPLICATES_DETECTED: {
+      message: `There are two entries for {filingType} with timeframes that immediately follow each other. {filingType} ending {firstPeriodEnd}, and {filingType} starting {secondPeriodStart}. Please update one entry to include the entire timeframe for {filingType}. `,
+      params: ['filingType', 'firstPeriodStart', 'firstPeriodEnd', 'secondPeriodStart'],
+    },
+    FILING_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 filing type ({earliestFilingType} starting {earliestFilingTypeStartDate}). There must be a filing type that begins on {dateEstablished}.`,
+      params: ['dateEstablished', 'earliestFilingType', 'earliestFilingTypeStartDate'],
+    },
+    FILING_TYPES_DATES_OVERLAP: {
+      message: `There are multiple entries for {filingType} with overlapping timeframes: {filingType} from {startDate1} to {endDate1}, {filingType} from {startDate2} to {endDate2}. A filing type cannot appear more than once with overlapping dates. Please adjust the dates on the new or existing {filingType} entries to remove the overlap.`,
+      params: ['filingType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+    },
+    ALL_NON_LAST_FILING_TYPES_REQUIRE_ENDING_DATE: {
+      message: `Only the last filing type can be open without an end date. Add an ending date to the existing filing type before adding a start date for a new filing type.`,
+    },
   },
   FILING_CATEGORY: {
     INVALID_REQUEST: {
@@ -319,7 +395,6 @@ export const VALIDATION_MESSAGES = {
       message: `Reset password link is no longer valid. Please use the most recent one.`,
     },
   },
-  
   //BACKEND ONLY VALIDATION FEATURES
   DATA_FILTER: {
     MISSING_PAGE_SIZE: {