@forwardslashns/taskit-validation-messages 1.2.0 → 1.3.0

package/dist/validation/features/client-record-entity-type-history.validation-messages.d.ts

@@ -0,0 +1,83 @@
+export declare const CLIENT_RECORD_ENTITY_TYPE_HISTORY: {
+    readonly ENTITY_TYPE_ID_DOES_NOT_EXIST: {
+        readonly message: "Entity type with id '{id}' does not exist";
+        readonly params: readonly ["id"];
+        readonly affectedFields: readonly ["entityTypeId"];
+    };
+    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", "entityTypes"];
+    };
+    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", "entityTypes"];
+    };
+    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 with ids '{ids}' do not exist";
+        readonly params: readonly ["ids"];
+        readonly affectedFields: readonly ["entityTypeId"];
+    };
+    readonly AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+        readonly message: "At least one entity type should exist";
+        readonly affectedFields: readonly ["entityTypes"];
+    };
+    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 ["entityTypes"];
+    };
+    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 ["entityTypes"];
+    };
+    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 ["entityTypes", "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 ["entityTypes"];
+    };
+    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"];
+    };
+};
+//# sourceMappingURL=client-record-entity-type-history.validation-messages.d.ts.map

package/dist/validation/features/client-record-entity-type-history.validation-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-record-entity-type-history.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-record-entity-type-history.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFpC,CAAC"}

package/dist/validation/features/client-record-entity-type-history.validation-messages.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_RECORD_ENTITY_TYPE_HISTORY = void 0;
+exports.CLIENT_RECORD_ENTITY_TYPE_HISTORY = {
+    ENTITY_TYPE_ID_DOES_NOT_EXIST: {
+        message: `Entity type with id '{id}' does not exist`,
+        params: ['id'],
+        affectedFields: ['entityTypeId'],
+    },
+    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.`,
+        params: ['clientDateEstablished', 'entityType', 'entityTypeStartingDate'],
+        affectedFields: ['dateEstablished', 'entityTypes'],
+    },
+    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.`,
+        params: ['clientCloseDate', 'entityType', 'entityTypeStartingDate'],
+        affectedFields: ['closeDate', 'entityTypes'],
+    },
+    ENTITY_TYPE_STARTING_DATE_NOT_POPULATED: {
+        message: `Current Entity Type Starting Date cannot be Empty`,
+        affectedFields: ['entityTypeStartingDate'],
+    },
+    NOT_ALIGNED_ENTITY_TYPE_STARTING_ENDING_DATE: {
+        message: `Entity type starting date needs to be before the ending date`,
+        affectedFields: ['entityTypeStartingDate', 'entityTypeEndingDate'],
+    },
+    ENTITY_TYPES_IDS_DOES_NOT_EXIST: {
+        message: `Entity types with ids '{ids}' do not exist`,
+        params: ['ids'],
+        affectedFields: ['entityTypeId'],
+    },
+    AT_LEAST_ONE_ENTITY_TYPE_SHOULD_EXIST: {
+        message: `At least one entity type should exist`,
+        affectedFields: ['entityTypes'],
+    },
+    ENTITY_TYPES_STARTING_DATE_NOT_POPULATED: {
+        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`,
+        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}.`,
+        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}.`,
+        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.`,
+        params: ['currentEntityType', 'currentEntityTypeEndDate', 'nextEntityType', 'nextEntityTypeStartDate'],
+        affectedFields: ['entityTypes'],
+    },
+    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'],
+        affectedFields: ['entityTypes'],
+    },
+    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'],
+        affectedFields: ['entityTypes', '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.`,
+        params: ['entityType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+        affectedFields: ['entityTypes'],
+    },
+    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.`,
+        affectedFields: ['entityTypeEndingDate'],
+    },
+    CURRENT_ENTITY_TYPE_CANNOT_HAVE_ENDING_DATE: {
+        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-record-filing-type-history.validation-messages.d.ts

@@ -0,0 +1,91 @@
+export declare const CLIENT_RECORD_FILING_TYPE_HISTORY: {
+    readonly FILING_TYPE_ID_DOES_NOT_EXIST: {
+        readonly message: "Parent/Sub status with id '{id}' does not exist";
+        readonly params: readonly ["id"];
+        readonly affectedFields: readonly ["filingTypeId"];
+    };
+    readonly FILING_TYPE_PARENT_REQUIRED: {
+        readonly message: "Parent needs to be specified for filing type 'Files under parent'";
+        readonly affectedFields: readonly ["parentClientId"];
+    };
+    readonly CURRENT_FILING_TYPE_PARENT_REQUIRED: {
+        readonly message: "Parent needs to be specified for current filing type 'Files under parent'";
+        readonly affectedFields: readonly ["parentClientId"];
+    };
+    readonly NOT_ALIGNED_DATE_ESTABLISHED_FILING_TYPE_STARTING_DATE: {
+        readonly message: "The Parent/Sub status {filingType} starts on {filingTypeStartingDate} which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the Parent/Sub status or the client's date established.";
+        readonly params: readonly ["clientDateEstablished", "filingType", "filingTypeStartingDate"];
+        readonly affectedFields: readonly ["dateEstablished", "filingTypes"];
+    };
+    readonly NOT_ALIGNED_CLOSE_DATE_FILING_TYPE_STARTING_DATE: {
+        readonly message: "One or more Parent/Sub status have a start date which is after the client's close date of {clientCloseDate}. {filingType}, starting {filingTypeStartingDate}. 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", "filingType", "filingTypeStartingDate"];
+        readonly affectedFields: readonly ["closeDate", "filingTypes"];
+    };
+    readonly FILING_TYPE_STARTING_DATE_NOT_POPULATED: {
+        readonly message: "Current Parent/Sub status Starting Date cannot be Empty";
+        readonly affectedFields: readonly ["filingTypeStartingDate"];
+    };
+    readonly NOT_ALIGNED_FILING_TYPE_STARTING_ENDING_DATE: {
+        readonly message: "Parent/Sub status starting date needs to be before the ending date";
+        readonly affectedFields: readonly ["filingTypeStartingDate", "filingTypeEndingDate"];
+    };
+    readonly FILING_TYPES_IDS_DOES_NOT_EXIST: {
+        readonly message: "Parent/Sub status with ids '{ids}' do not exist";
+        readonly params: readonly ["ids"];
+        readonly affectedFields: readonly ["filingTypeId"];
+    };
+    readonly AT_LEAST_ONE_FILING_TYPE_SHOULD_EXIST: {
+        readonly message: "At least one Parent/Sub status should exist";
+        readonly affectedFields: readonly ["filingTypes"];
+    };
+    readonly FILING_TYPES_STARTING_DATE_NOT_POPULATED: {
+        readonly message: "Starting date for {filingType} cannot be empty";
+        readonly params: readonly ["filingType"];
+        readonly affectedFields: readonly ["filingTypeStartingDate"];
+    };
+    readonly NOT_ALIGNED_FILING_TYPES_STARTING_ENDING_DATE: {
+        readonly message: "The ending date for {filingType} must be after its starting date";
+        readonly params: readonly ["filingType"];
+        readonly affectedFields: readonly ["filingTypeStartingDate", "filingTypeEndingDate"];
+    };
+    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 affectedFields: readonly ["filingTypeStartingDate", "dateEstablished"];
+    };
+    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 affectedFields: readonly ["filingTypeStartingDate", "closeDate"];
+    };
+    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 affectedFields: readonly ["filingTypes"];
+    };
+    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 affectedFields: readonly ["filingTypes"];
+    };
+    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 Parent/Sub status ({earliestFilingType} starting {earliestFilingTypeStartDate}). There must be a Parent/Sub status that begins on {dateEstablished}.";
+        readonly params: readonly ["dateEstablished", "earliestFilingType", "earliestFilingTypeStartDate"];
+        readonly affectedFields: readonly ["filingTypes", "dateEstablished"];
+    };
+    readonly FILING_TYPES_DATES_OVERLAP: {
+        readonly message: "The client already has {filingType} 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 ["filingType", "startDate1", "endDate1", "startDate2", "endDate2"];
+        readonly affectedFields: readonly ["filingTypes"];
+    };
+    readonly ALL_NON_LAST_FILING_TYPES_REQUIRE_ENDING_DATE: {
+        readonly message: "Only the last Parent/Sub status can be open without an end date. Add an ending date to the existing Parent/Sub status before adding a start date for a new Parent/Sub status.";
+        readonly affectedFields: readonly ["filingTypeEndingDate"];
+    };
+    readonly CURRENT_FILING_TYPE_CANNOT_HAVE_ENDING_DATE: {
+        readonly message: "The current Parent/Sub status cannot have an end date. Please remove the end date for this state.";
+        readonly affectedFields: readonly ["filingTypeEndingDate"];
+    };
+};
+//# sourceMappingURL=client-record-filing-type-history.validation-messages.d.ts.map

package/dist/validation/features/client-record-filing-type-history.validation-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-record-filing-type-history.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-record-filing-type-history.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyFpC,CAAC"}

package/dist/validation/features/client-record-filing-type-history.validation-messages.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_RECORD_FILING_TYPE_HISTORY = void 0;
+exports.CLIENT_RECORD_FILING_TYPE_HISTORY = {
+    FILING_TYPE_ID_DOES_NOT_EXIST: {
+        message: `Parent/Sub status with id '{id}' does not exist`,
+        params: ['id'],
+        affectedFields: ['filingTypeId'],
+    },
+    FILING_TYPE_PARENT_REQUIRED: {
+        message: `Parent needs to be specified for filing type 'Files under parent'`,
+        affectedFields: ['parentClientId'],
+    },
+    CURRENT_FILING_TYPE_PARENT_REQUIRED: {
+        message: `Parent needs to be specified for current filing type 'Files under parent'`,
+        affectedFields: ['parentClientId'],
+    },
+    NOT_ALIGNED_DATE_ESTABLISHED_FILING_TYPE_STARTING_DATE: {
+        message: `The Parent/Sub status {filingType} starts on {filingTypeStartingDate} which is earlier than the client's date established, {clientDateEstablished}. Please adjust the start date of the Parent/Sub status or the client's date established.`,
+        params: ['clientDateEstablished', 'filingType', 'filingTypeStartingDate'],
+        affectedFields: ['dateEstablished', 'filingTypes'],
+    },
+    NOT_ALIGNED_CLOSE_DATE_FILING_TYPE_STARTING_DATE: {
+        message: `One or more Parent/Sub status have a start date which is after the client's close date of {clientCloseDate}. {filingType}, starting {filingTypeStartingDate}. Please update the start date to be earlier than the client's close date, or update the client's close date.`,
+        params: ['clientCloseDate', 'filingType', 'filingTypeStartingDate'],
+        affectedFields: ['closeDate', 'filingTypes'],
+    },
+    FILING_TYPE_STARTING_DATE_NOT_POPULATED: {
+        message: `Current Parent/Sub status Starting Date cannot be Empty`,
+        affectedFields: ['filingTypeStartingDate'],
+    },
+    NOT_ALIGNED_FILING_TYPE_STARTING_ENDING_DATE: {
+        message: `Parent/Sub status starting date needs to be before the ending date`,
+        affectedFields: ['filingTypeStartingDate', 'filingTypeEndingDate'],
+    },
+    FILING_TYPES_IDS_DOES_NOT_EXIST: {
+        message: `Parent/Sub status with ids '{ids}' do not exist`,
+        params: ['ids'],
+        affectedFields: ['filingTypeId'],
+    },
+    AT_LEAST_ONE_FILING_TYPE_SHOULD_EXIST: {
+        message: `At least one Parent/Sub status should exist`,
+        affectedFields: ['filingTypes'],
+    },
+    FILING_TYPES_STARTING_DATE_NOT_POPULATED: {
+        message: `Starting date for {filingType} cannot be empty`,
+        params: ['filingType'],
+        affectedFields: ['filingTypeStartingDate'],
+    },
+    NOT_ALIGNED_FILING_TYPES_STARTING_ENDING_DATE: {
+        message: `The ending date for {filingType} must be after its starting date`,
+        params: ['filingType'],
+        affectedFields: ['filingTypeStartingDate', 'filingTypeEndingDate'],
+    },
+    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'],
+        affectedFields: ['filingTypeStartingDate', 'dateEstablished'],
+    },
+    NOT_ALIGNED_CLOSE_DATE_FILING_TYPES_STARTING_DATE: {
+        message: `Adjust the start date to be before the client's close date, {clientCloseDate}.`,
+        params: ['clientCloseDate'],
+        affectedFields: ['filingTypeStartingDate', 'closeDate'],
+    },
+    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'],
+        affectedFields: ['filingTypes'],
+    },
+    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'],
+        affectedFields: ['filingTypes'],
+    },
+    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 Parent/Sub status ({earliestFilingType} starting {earliestFilingTypeStartDate}). There must be a Parent/Sub status that begins on {dateEstablished}.`,
+        params: ['dateEstablished', 'earliestFilingType', 'earliestFilingTypeStartDate'],
+        affectedFields: ['filingTypes', 'dateEstablished'],
+    },
+    FILING_TYPES_DATES_OVERLAP: {
+        message: `The client already has {filingType} starting from {startDate2} to {endDate2}. Your current entity type overlaps with that time. Please adjust the dates so they don't overlap.`,
+        params: ['filingType', 'startDate1', 'endDate1', 'startDate2', 'endDate2'],
+        affectedFields: ['filingTypes'],
+    },
+    ALL_NON_LAST_FILING_TYPES_REQUIRE_ENDING_DATE: {
+        message: `Only the last Parent/Sub status can be open without an end date. Add an ending date to the existing Parent/Sub status before adding a start date for a new Parent/Sub status.`,
+        affectedFields: ['filingTypeEndingDate'],
+    },
+    CURRENT_FILING_TYPE_CANNOT_HAVE_ENDING_DATE: {
+        message: `The current Parent/Sub status cannot have an end date. Please remove the end date for this state.`,
+        affectedFields: ['filingTypeEndingDate'],
+    },
+};

package/dist/validation/features/{outside-provider.validation-messages.d.ts → client-record-outside-provider.validation-messages.d.ts}

@@ -1,4 +1,4 @@
-export declare const OUTSIDE_PROVIDER: {
+export declare const CLIENT_RECORD_OUTSIDE_PROVIDER: {
     readonly INVALID_TYPE: {
         readonly message: "Outside provider types with ids '{ids}' do not exist";
         readonly params: readonly ["ids"];
@@ -10,4 +10,4 @@ export declare const OUTSIDE_PROVIDER: {
         readonly affectedFields: readonly ["startDate", "endDate"];
     };
 };
-//# sourceMappingURL=outside-provider.validation-messages.d.ts.map
+//# sourceMappingURL=client-record-outside-provider.validation-messages.d.ts.map

package/dist/validation/features/client-record-outside-provider.validation-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-record-outside-provider.validation-messages.d.ts","sourceRoot":"","sources":["../../../src/validation/features/client-record-outside-provider.validation-messages.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B;;;;;;;;;;;CAWjC,CAAC"}

package/dist/validation/features/{outside-provider.validation-messages.js → client-record-outside-provider.validation-messages.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OUTSIDE_PROVIDER = void 0;
-exports.OUTSIDE_PROVIDER = {
+exports.CLIENT_RECORD_OUTSIDE_PROVIDER = void 0;
+exports.CLIENT_RECORD_OUTSIDE_PROVIDER = {
     INVALID_TYPE: {
         message: `Outside provider types with ids '{ids}' do not exist`,
         params: ['ids'],