ngx-t-forms 2.0.24 → 2.0.25

package/lib/components/t-form-input/elements/mscoa-form-input/elements/mscoa-chart/utils/mscoa-chart.helpers.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Helper functions for MSCOA Chart Component
+ */
+export interface RowData {
+    singleSelect?: boolean;
+    segment?: string;
+    inheritValueFromAccrual?: boolean;
+    vatSelectonActive?: boolean;
+    segmentValue?: {
+        vatApplicableTo?: string;
+        [key: string]: any;
+    } | any;
+    innerInput?: any;
+    [key: string]: any;
+}
+/**
+ * Gets the toolbar color based on accounting basis
+ */
+export declare function getToolbarColor(accountingBasis?: string): string;
+/**
+ * Gets the toolbar background style based on accounting basis
+ */
+export declare function getToolbarBackground(accountingBasis?: string): string;
+/**
+ * Gets the toolbar icon color based on accounting basis
+ */
+export declare function getToolbarIconColor(accountingBasis?: string): string;
+/**
+ * Gets the border style based on accounting basis
+ */
+export declare function getBorderStyle(accountingBasis?: string): string;
+/**
+ * Checks if a column is the segment column (first column)
+ */
+export declare function isSegmentColumn(index: number): boolean;
+/**
+ * Gets header text for a column
+ */
+export declare function getHeaderText(col: string, index: number, hasMultiSelect: boolean): string;
+/**
+ * Checks if a row has an inner input
+ */
+export declare function hasInnerInput(row: RowData | any): boolean;
+/**
+ * Checks if credit column should be disabled for single select
+ */
+export declare function isCreditDisabledForSingleSelect(row: RowData, col: string): boolean;
+/**
+ * Checks if VAT column should be disabled
+ */
+export declare function isVatDisabled(row: RowData, col: string): boolean;
+/**
+ * Checks if a field should show auto-selected label
+ */
+export declare function shouldShowAutoSelectedLabel(row: RowData, col: string): boolean;
+/**
+ * Checks if dropdown icon should be shown
+ */
+export declare function shouldShowDropdownIcon(row: RowData, col: string): boolean;
+/**
+ * Gets error color for required empty fields
+ */
+export declare function getErrorColor(touched: boolean, required: boolean, hasValue: boolean): string;
+/**
+ * Checks if field has error state (for class binding)
+ */
+export declare function hasError(touched: boolean, required: boolean, hasValue: boolean): boolean;
+/**
+ * Checks if VAT chip should be displayed
+ */
+export declare function shouldShowVatChip(row: RowData, col: string): boolean;
+/**
+ * Gets cell padding style based on column index
+ */
+export declare function getCellPadding(index: number): string;
+/**
+ * Gets header padding style based on column index
+ */
+export declare function getHeaderPadding(index: number): string;
+/**
+ * Gets cell background style for segment column
+ */
+export declare function getSegmentCellBackground(index: number): string;
+/**
+ * Checks if table should be visible based on dual basis expansion state
+ */
+export declare function shouldShowTable(isDualAccountBasis: boolean, expansionState: boolean, accountingBasis?: string): boolean;

package/lib/components/t-form-input/elements/mscoa-form-input/elements/mscoa-chart/utils/mscoa-chart.types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Type definitions for MSCOA Chart Component
+ */
+import { ITableScoaSelectionRow, FormColumnInputs, ScoaInnerInput } from 'ngx-t-forms-types';
+import { AccountingBasis } from './mscoa-chart.constants';
+/**
+ * Extended row interface that includes dynamic properties used in the component
+ * Uses intersection type to allow optional properties from base interface
+ */
+export type ExtendedTableRow = ITableScoaSelectionRow & {
+    innerInput?: ScoaInnerInput | FormColumnInputs;
+    accountInputs?: FormColumnInputs[];
+    customSegment?: string;
+    singleSelect?: boolean;
+    inheritValueFromAccrual?: boolean;
+    readOnly?: boolean;
+    additionalAccounts?: string[];
+    [key: string]: any;
+};
+export interface MscoaChartViewData {
+    loading: boolean;
+    accountTreeKeys: any[];
+    tableData: ExtendedTableRow[];
+    cols: string[];
+    hasMultiSelect: boolean;
+    cashAccountTreeKeys: any[];
+    cashTableData: ExtendedTableRow[];
+    cashCols: string[];
+    cashHasMultiSelect: boolean;
+    busnessRuleErrors: Record<string, string[]>;
+}
+export interface DualBasisExpansionState {
+    [key: string]: boolean;
+}
+export interface CountdownState {
+    count: number | null;
+    stop$: any;
+}
+export interface CountdownSeconds {
+    [key: string]: CountdownState;
+}
+export interface SelectionTableContext {
+    accountingBasis?: AccountingBasis | string;
+    canCollapse?: boolean;
+}
+export interface PortalProps {
+    inputConfig: any;
+    formGroup: any;
+    formBuilderFunctions: any;
+    editorMode: boolean;
+}

package/lib/components/t-form-input/elements/mscoa-form-input/elements/mscoa-chart/utils/mscoa-message-formatter.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Message Formatter Service for MSCOA Chart Component
+ * Transforms technical error messages into user-friendly, contextual messages
+ */
+export interface ValidationError {
+    message: string;
+    [key: string]: any;
+}
+export interface ErrorContext {
+    segment?: string;
+    accountNumber?: string;
+    accountName?: string;
+    column?: string;
+    accountingBasis?: string;
+    [key: string]: any;
+}
+export interface AccountCombination {
+    accounts: Array<{
+        number: string;
+        name: string;
+    }>;
+    segment: string;
+    column: string;
+}
+export interface ValidationRule {
+    type: string;
+    description: string;
+    applicableSegments?: string[];
+}
+/**
+ * Formats technical error messages into user-friendly messages
+ */
+export declare class MscoaMessageFormatter {
+    /**
+     * Formats a validation error message with context
+     */
+    formatError(error: ValidationError, context?: ErrorContext): string;
+    /**
+     * Formats success message for valid account combination
+     */
+    formatSuccess(combination: AccountCombination): string;
+    /**
+     * Formats contextual hint for validation rules
+     */
+    formatHint(rule: ValidationRule): string;
+    /**
+     * Checks if message is already user-friendly
+     */
+    private isUserFriendly;
+    /**
+     * Extracts segment name from error message
+     */
+    private extractSegment;
+    /**
+     * Extracts column name from error message
+     */
+    private extractColumn;
+    /**
+     * Formats invalid combination error
+     */
+    private formatInvalidCombination;
+    /**
+     * Formats cannot combine error
+     */
+    private formatCannotCombine;
+    /**
+     * Formats required field error
+     */
+    private formatRequired;
+    /**
+     * Formats conflict error
+     */
+    private formatConflict;
+    /**
+     * Formats category error
+     */
+    private formatCategoryError;
+    /**
+     * Formats rule violation error
+     */
+    private formatRuleViolation;
+    /**
+     * Formats default error message
+     */
+    private formatDefault;
+}
+export declare const mscoaMessageFormatter: MscoaMessageFormatter;

package/lib/components/t-form-input/elements/mscoa-form-input/elements/mscoa-computation/mscoa-computation.component.d.ts

@@ -1,11 +1,13 @@
 import { OnDestroy, OnInit } from '@angular/core';
+import { SafeHtml } from '@angular/platform-browser';
 import { Observable } from 'rxjs';
 import { FlatTreeControl } from '@angular/cdk/tree';
 import { MatTreeFlatDataSource } from '@angular/material/tree';
 import { MatDialogRef } from '@angular/material/dialog';
-import { IIncludedSegmentConfig, IScoaAccount, ScoaAccountTree } from "ngx-t-forms-types";
+import { IIncludedSegmentConfig, IScoaAccount, ScoaAccountTree, TreeNode } from "ngx-t-forms-types";
 import { ObjectTreeFlatNode, ObjectTreeNode } from '../../../../../t-dynamic-data-edit/elements/api-value-access-rules/functions/convertDataToTree';
 import { FormColumnInputs } from 'ngx-t-forms-types';
+import { FormControl } from '@angular/forms';
 import * as i0 from "@angular/core";
 export interface IMscoaComputationComponentData {
     data: ScoaAccountTree;
@@ -15,48 +17,173 @@ export interface IMscoaComputationComponentData {
     activeColumn: string | undefined;
     segmentConfig: IIncludedSegmentConfig | undefined;
     readonly: boolean;
+    isCashSelection: boolean;
     getSCOAAccount: (account: string) => Observable<{
         accounts: IScoaAccount[];
     }>;
 }
 export declare class MscoaComputationComponent implements OnInit, OnDestroy {
-    dialogRef: MatDialogRef<MscoaComputationComponent>;
-    dataInjected: IMscoaComputationComponentData;
-    data: ScoaAccountTree | undefined;
-    segment: string | undefined;
-    value: IScoaAccount | undefined;
-    accountInputs: FormColumnInputs[];
-    activeColumn: string | undefined;
-    readonly: boolean;
-    segmentConfig: IIncludedSegmentConfig | undefined;
-    private destroy$;
-    treeControl: FlatTreeControl<ObjectTreeFlatNode>;
-    private treeFlattener;
-    dataSource: MatTreeFlatDataSource<ObjectTreeNode, ObjectTreeFlatNode>;
+    private readonly dataInjected;
+    private readonly sanitizer;
+    readonly dialogRef: MatDialogRef<MscoaComputationComponent>;
+    readonly data: ScoaAccountTree | undefined;
+    readonly segment: string | undefined;
+    readonly value: IScoaAccount | undefined;
+    readonly accountInputs: FormColumnInputs[];
+    readonly activeColumn: string | undefined;
+    readonly isCashSelection: boolean;
+    readonly readonly: boolean;
+    readonly segmentConfig: IIncludedSegmentConfig | undefined;
+    readonly treeControl: FlatTreeControl<ObjectTreeFlatNode>;
+    private readonly treeFlattener;
+    readonly dataSource: MatTreeFlatDataSource<ObjectTreeNode, ObjectTreeFlatNode>;
+    selectedTreeNode: ObjectTreeFlatNode | undefined;
+    selectedAccount: IScoaAccount | null;
+    searchAccounts: IScoaAccount[];
+    searchingAccounts: boolean;
+    currentAccountPath: string | undefined;
+    showSearchBar: boolean;
+    readonly accountSearchTextControl: FormControl<string | null>;
+    readonly searchedPaths$: Observable<string[][]>;
+    private readonly destroy$;
+    private readonly accountCache;
+    errorMessage: string | null;
+    hasError: boolean;
     constructor(dialogRef: MatDialogRef<MscoaComputationComponent>);
     ngOnInit(): void;
     ngOnDestroy(): void;
+    /**
+     * Checks if a tree node has children (is expandable)
+     */
     hasChild: (_: number, node: ObjectTreeFlatNode) => boolean;
+    /**
+     * Transforms a tree node into a flat node for the Material tree
+     */
     private transformer;
+    /**
+     * Searches the tree for nodes matching the search text using fuzzy search
+     * @param searchText - The text to search for
+     * @returns Array of matching paths
+     */
+    searchTree(searchText: string | null): string[][];
+    /**
+     * Checks if a path is the currently selected path or a parent of it
+     * @param path - The path to check
+     * @returns True if the path is active or a parent of the selected path
+     */
     isActivePathOrParent(path: string[]): boolean;
+    /**
+     * Toggles the expansion state of a tree node.
+     * Does not collapse siblings (like Windows Explorer / VS Code) for better context.
+     */
     toggleNode(node: ObjectTreeFlatNode): void;
-    private collapseSiblings;
-    private getParentNode;
-    _selected: ObjectTreeFlatNode | undefined;
+    /**
+     * Checks if any tree nodes are currently expanded
+     */
+    get noneIsExpanded(): boolean;
+    /**
+     * Selects a tree node and loads its associated accounts
+     * @param node - The node to select
+     */
     selectNode(node: ObjectTreeFlatNode): void;
-    searchAccount: any[];
-    searchingAccounts: boolean;
-    account: string | undefined;
-    getSelectedAccounts(): void;
+    /**
+     * Loads accounts for the currently selected tree node
+     * Uses caching to prevent redundant API calls
+     */
+    private loadAccountsForNode;
+    /**
+     * Sets an error message to display to the user
+     * @param message - The error message to display
+     */
+    private setError;
+    /**
+     * Clears the current error state
+     */
+    private clearError;
+    /**
+     * Retries loading accounts for the current node
+     */
+    retryLoadAccounts(): void;
+    /**
+     * Cancels the current selection and resets the component state
+     */
     cancel(): void;
+    /**
+     * Saves the selected account and closes the dialog
+     */
     saveAccount(): void;
+    /**
+     * Closes the dialog and passes the selected account back
+     * @param account - The account to return, or undefined if cancelled
+     */
     closeAndPassData(account: IScoaAccount | undefined): void;
-    _selectedAccount: IScoaAccount | null;
+    /**
+     * Selects an account from the account table
+     * @param account - The account to select, or null to deselect
+     */
     selectAccount(account: IScoaAccount | null): void;
+    /**
+     * Finds a tree node by its path (from tree data)
+     * @param targetPath - The path to search for
+     * @returns The found node or null if not found
+     */
+    getNodeByPath(targetPath: string[]): TreeNode | null;
+    /**
+     * Finds the flat node (from treeControl.dataNodes) by path.
+     * Required for expand/select operations since Material tree uses flat nodes.
+     */
+    getFlatNodeByPath(targetPath: string[]): ObjectTreeFlatNode | null;
+    /**
+     * Expands all ancestor nodes so the target node is visible in the tree.
+     * Does not collapse siblings (user keeps context of other branches).
+     */
+    expandPathToNode(flatNode: ObjectTreeFlatNode): void;
+    /**
+     * Selects a path from search results: expands path, selects node, loads accounts,
+     * scrolls selection into view, then clears search.
+     * Follows UX best practice: expand to path → select → scroll into view.
+     */
+    selectPath(path: string[]): void;
+    /**
+     * Clears the search input
+     */
+    clearSearch(): void;
+    /**
+     * Clears the selected account
+     */
     clearSelectedAccount(): void;
+    /**
+     * Determines if the save button should be enabled
+     * Checks if the account has changed and all required inputs are valid
+     */
     get saveSelection(): boolean;
+    /**
+     * Updates the selected account with new values
+     * @param account - The updated account
+     */
     updateAccount(account: IScoaAccount): void;
+    /**
+     * Determines if the user can clear the selected account
+     */
     get userCanClearAccount(): boolean;
+    /**
+     * Handles keyboard navigation for the dialog
+     * @param event - The keyboard event
+     */
+    handleKeyboardNavigation(event: KeyboardEvent): void;
+    /**
+     * Highlights search text in a given string
+     * @param text - The text to highlight
+     * @param searchTerm - The search term to highlight
+     * @returns Safe HTML string with highlighted text
+     */
+    highlightSearchText(text: string, searchTerm: string): SafeHtml;
+    /**
+     * Escapes special regex characters in a string
+     * @param str - The string to escape
+     * @returns Escaped string
+     */
+    private escapeRegex;
     static ɵfac: i0.ɵɵFactoryDeclaration<MscoaComputationComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MscoaComputationComponent, "app-mscoa-computation", never, {}, {}, never, never, true, never>;
 }

package/lib/components/t-form-input/elements/mscoa-form-input/elements/mscoa-reactive-form-field/mscoa-reactive-form-field.component.d.ts

@@ -4,9 +4,14 @@ import { BehaviorSubject } from 'rxjs';
 import { FormBuilderFunctions, ITowerStepColumn } from "ngx-t-forms-types";
 import { IScoaInputConfig, ScoaSegmentValue } from "ngx-t-forms-types";
 import { BaseCustomInput } from '../../../../../../services/core/t-input-controller/functions/baseCustomInput';
+import { MscoaComponentStore } from '../../store/mscoa-component-store.service';
 import * as i0 from "@angular/core";
 export declare class MscoaReactiveFormFieldComponent extends BaseCustomInput<ScoaSegmentValue> {
+    store: MscoaComponentStore;
+    businessRuleValidationErrors$: import("rxjs").Observable<import("ngx-t-forms-types").MscoaValuetValidationErrors>;
+    businessRuleValidationErrors: import("@angular/core").Signal<import("ngx-t-forms-types").MscoaValuetValidationErrors | undefined>;
     get empty(): boolean;
+    get errorState(): boolean;
     constructor(ngControl: NgControl, elementRef: ElementRef<HTMLElement>);
     formBuilderFunctions: FormBuilderFunctions | undefined;
     editorMode: boolean;
@@ -18,6 +23,12 @@ export declare class MscoaReactiveFormFieldComponent extends BaseCustomInput<Sco
     get readonly(): boolean;
     get parentFormGroup(): FormGroup | null;
     checkValidationsAnErrors(): void;
+    /** Determines if the current value satisfies the specific Accounting Basis.
+     * For dual basis, BOTH accrual and cash must be valid.
+     */
+    private checkBasisValidity;
+    /** Updates control errors for required, segment completeness, and non-overridable business rule errors. */
+    private updateControlErrors;
     static ɵfac: i0.ɵɵFactoryDeclaration<MscoaReactiveFormFieldComponent, [{ optional: true; self: true; }, null]>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MscoaReactiveFormFieldComponent, "lib-mscoa-reactive-form-field", never, { "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "inputConfig": { "alias": "inputConfig"; "required": false; }; }, {}, never, never, true, never>;
 }

package/lib/components/t-form-input/elements/mscoa-form-input/elements/scoa-account-table/scoa-account-table.component.d.ts

@@ -33,6 +33,10 @@ export declare class ScoaAccountTableComponent implements OnChanges, OnInit {
     constructor();
     ngOnInit(): void;
     ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Checks if paginator should be shown
+     */
+    get shouldShowPaginator(): boolean;
     mapAccounts(accounts: IScoaAccount[]): {
         AccountNumberShortened: string;
         _id: {

package/lib/components/t-form-input/elements/mscoa-form-input/mscoa-form-input.component.d.ts

@@ -9,7 +9,7 @@ export declare class MscoaFormInputComponent {
     formGroup: FormGroup;
     formBuilderFunctions: FormBuilderFunctions | undefined;
     reload: EventEmitter<void>;
-    get errorMessage(): string | undefined;
+    get errorMessage(): string | string[] | undefined;
     static ɵfac: i0.ɵɵFactoryDeclaration<MscoaFormInputComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<MscoaFormInputComponent, "lib-mscoa-form-input", never, { "inputConfig": { "alias": "inputConfig"; "required": false; }; "editorMode": { "alias": "editorMode"; "required": false; }; "formGroup": { "alias": "formGroup"; "required": false; }; "formBuilderFunctions": { "alias": "formBuilderFunctions"; "required": false; }; }, { "reload": "reload"; }, never, never, true, never>;
 }

package/lib/components/t-form-input/elements/mscoa-form-input/store/accountConstants.d.ts

@@ -1,5 +1,10 @@
 export declare const MIN_ACCOUNT_DETAILS: string[];
-export declare const SCOA_ACCOUNT_COLUMNS: {
+export declare const SCOA_ACCOUNT_COLUMNS: ({
     key: string;
     label: string;
-}[];
+    system?: undefined;
+} | {
+    key: string;
+    label: string;
+    system: boolean;
+})[];

package/lib/components/t-form-input/elements/mscoa-form-input/store/mscoa-actions.d.ts

@@ -1,19 +1,30 @@
-import { IScoaAccount, IScoaInputConfig, ScoaSegmentValue } from "ngx-t-forms-types";
+import { IScoaAccount, IScoaInputConfig, MscoaValuetValidationErrors, ScoaSegmentValue } from "ngx-t-forms-types";
 import { MscoaComponentStore } from "./mscoa-component-store.service";
 export declare function mscoaStoreActions(store: MscoaComponentStore): {
     resetStore: () => void;
     setConfig: (() => void) | ((observableOrValue: IScoaInputConfig | import("rxjs").Observable<IScoaInputConfig | null | undefined> | null | undefined) => import("rxjs").Subscription);
     setInitiated: () => void;
-    setSegmentValues: (() => void) | ((observableOrValue: ScoaSegmentValue | import("rxjs").Observable<ScoaSegmentValue | null | undefined> | null | undefined) => import("rxjs").Subscription);
+    setSegmentValues: (() => void) | ((observableOrValue: {
+        accrual?: ScoaSegmentValue;
+        cash?: ScoaSegmentValue;
+    } | import("rxjs").Observable<{
+        accrual?: ScoaSegmentValue;
+        cash?: ScoaSegmentValue;
+    } | undefined> | undefined) => import("rxjs").Subscription);
+    setValidatingValue: (observableOrValue: boolean | import("rxjs").Observable<boolean>) => import("rxjs").Subscription;
+    validationErrors: (observableOrValue: MscoaValuetValidationErrors | import("rxjs").Observable<MscoaValuetValidationErrors>) => import("rxjs").Subscription;
     setLoadingTree: (observableOrValue: boolean | import("rxjs").Observable<boolean>) => import("rxjs").Subscription;
     setActiveSegment: (observableOrValue: string | import("rxjs").Observable<string | null> | null) => import("rxjs").Subscription;
     setSegmentAccount: (observableOrValue: {
         segment: string;
         account: IScoaAccount | undefined;
         accountType: string;
+        isCash: boolean;
     } | import("rxjs").Observable<{
         segment: string;
         account: IScoaAccount | undefined;
         accountType: string;
+        isCash: boolean;
     }>) => import("rxjs").Subscription;
+    auditStateValues: () => void;
 };

package/lib/components/t-form-input/elements/mscoa-form-input/store/mscoa-component-store.service.d.ts

@@ -3,7 +3,7 @@ import { ScoaInterface } from "ngx-t-forms-types";
 import * as i0 from "@angular/core";
 export declare const initialMscoaState: ScoaInterface;
 export declare class MscoaComponentStore extends ComponentStore<ScoaInterface> {
-    constructor();
+    NGX_T_FORMS_CONFIG_TOKEN: import("ngx-t-forms-types").NgxTFormsConfig;
     readonly selectors: {
         initiated$: import("rxjs").Observable<boolean>;
         loadingTree$: import("rxjs").Observable<boolean>;
@@ -12,8 +12,7 @@ export declare class MscoaComponentStore extends ComponentStore<ScoaInterface> {
         table$: import("rxjs").Observable<{
             accountInputs: import("ngx-t-forms-types").ScoaInnerInput[];
             input: import("ngx-t-forms-types").ScoaInnerInput | undefined;
-            vatCredit: any;
-            vatDebit: any;
+            vat: any;
             debit: any;
             credit: any;
             segment: string;
@@ -26,38 +25,76 @@ export declare class MscoaComponentStore extends ComponentStore<ScoaInterface> {
             customSegment?: string | undefined;
             readOnly: boolean;
             singleSelect: boolean;
+            inheritValueFromAccrual?: boolean;
+            vatSelectonActive?: boolean;
             additionalAccounts: string[];
             segmentExtension: boolean;
             id: string;
         }[]>;
-        hasVATApplicableAccount$: import("rxjs").Observable<{
-            vatCredit: boolean;
-            vatDebit: boolean;
-        }>;
+        hasVATApplicableAccount$: import("rxjs").Observable<boolean>;
         inputs$: import("rxjs").Observable<import("ngx-t-forms-types").ScoaInnerInput[]>;
         state$: import("rxjs").Observable<ScoaInterface>;
+        validationErrors$: import("rxjs").Observable<import("ngx-t-forms-types").MscoaValuetValidationErrors>;
+        validatingValue$: import("rxjs").Observable<boolean>;
+        cashAccountTreeKeys$: import("rxjs").Observable<import("ngx-t-forms-types").IAccountSegmentTreeKeys[]>;
+        cashTable$: import("rxjs").Observable<{
+            accountInputs: import("ngx-t-forms-types").ScoaInnerInput[];
+            input: import("ngx-t-forms-types").ScoaInnerInput | undefined;
+            vat: any;
+            debit: any;
+            credit: any;
+            segment: string;
+            innerInput: import("ngx-t-forms-types").ScoaInnerInput;
+            label: string;
+            formInput: boolean;
+            segmentTree: import("ngx-t-forms-types").ScoaAccountTree;
+            inputs: import("ngx-t-forms-types").ScoaInnerInput[];
+            segmentValue: Record<string, any>;
+            customSegment?: string | undefined;
+            readOnly: boolean;
+            singleSelect: boolean;
+            inheritValueFromAccrual?: boolean;
+            vatSelectonActive?: boolean;
+            additionalAccounts: string[];
+            segmentExtension: boolean;
+            id: string;
+        }[]>;
+        cashHasVATApplicableAccount$: import("rxjs").Observable<boolean>;
     };
     readonly actions: {
         resetStore: () => void;
         setConfig: (() => void) | ((observableOrValue: import("ngx-t-forms-types").IScoaInputConfig | import("rxjs").Observable<import("ngx-t-forms-types").IScoaInputConfig | null | undefined> | null | undefined) => import("rxjs").Subscription);
         setInitiated: () => void;
-        setSegmentValues: (() => void) | ((observableOrValue: import("ngx-t-forms-types").ScoaSegmentValue | import("rxjs").Observable<import("ngx-t-forms-types").ScoaSegmentValue | null | undefined> | null | undefined) => import("rxjs").Subscription);
+        setSegmentValues: (() => void) | ((observableOrValue: {
+            accrual?: import("ngx-t-forms-types").ScoaSegmentValue;
+            cash?: import("ngx-t-forms-types").ScoaSegmentValue;
+        } | import("rxjs").Observable<{
+            accrual?: import("ngx-t-forms-types").ScoaSegmentValue;
+            cash?: import("ngx-t-forms-types").ScoaSegmentValue;
+        } | undefined> | undefined) => import("rxjs").Subscription);
+        setValidatingValue: (observableOrValue: boolean | import("rxjs").Observable<boolean>) => import("rxjs").Subscription;
+        validationErrors: (observableOrValue: import("ngx-t-forms-types").MscoaValuetValidationErrors | import("rxjs").Observable<import("ngx-t-forms-types").MscoaValuetValidationErrors>) => import("rxjs").Subscription;
         setLoadingTree: (observableOrValue: boolean | import("rxjs").Observable<boolean>) => import("rxjs").Subscription;
         setActiveSegment: (observableOrValue: string | import("rxjs").Observable<string | null> | null) => import("rxjs").Subscription;
         setSegmentAccount: (observableOrValue: {
             segment: string;
             account: import("ngx-t-forms-types").IScoaAccount | undefined;
             accountType: string;
+            isCash: boolean;
         } | import("rxjs").Observable<{
             segment: string;
             account: import("ngx-t-forms-types").IScoaAccount | undefined;
             accountType: string;
+            isCash: boolean;
         }>) => import("rxjs").Subscription;
+        auditStateValues: () => void;
     };
     readonly effects: {
         initLoadMscoa$: (observableOrValue: import("ngx-t-forms-types").FormBuilderFunctions | import("rxjs").Observable<import("ngx-t-forms-types").FormBuilderFunctions | undefined> | undefined) => import("rxjs").Subscription;
         initSetSegmentValues$: (observableOrValue: import("ngx-t-forms-types").ScoaSegmentValue | import("rxjs").Observable<import("ngx-t-forms-types").ScoaSegmentValue>) => import("rxjs").Subscription;
+        auditOnSegmentValuesChange$: (observableOrValue?: void | import("rxjs").Observable<void> | undefined) => import("rxjs").Subscription;
     };
+    constructor();
     static ɵfac: i0.ɵɵFactoryDeclaration<MscoaComponentStore, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<MscoaComponentStore>;
 }

package/lib/components/t-form-input/elements/mscoa-form-input/store/mscoa-effects.d.ts

@@ -5,4 +5,5 @@ import { FormBuilderFunctions } from "ngx-t-forms-types";
 export declare function mscoaStoreEffects(store: MscoaComponentStore): {
     initLoadMscoa$: (observableOrValue: FormBuilderFunctions | Observable<FormBuilderFunctions | undefined> | undefined) => import("rxjs").Subscription;
     initSetSegmentValues$: (observableOrValue: ScoaSegmentValue | Observable<ScoaSegmentValue>) => import("rxjs").Subscription;
+    auditOnSegmentValuesChange$: (observableOrValue?: void | Observable<void> | undefined) => import("rxjs").Subscription;
 };