@legalplace/wizardx-core 4.42.9 → 4.42.10-nightly.20251125115613

package/dist/helpers/activitiesHelper.d.ts

@@ -1,5 +1,5 @@
 import type { IActivities } from "../types/autocomplete.type";
 export declare const api: import("axios").AxiosInstance;
-export declare const getAllActivities: (signal?: AbortSignal | undefined) => Promise<import("axios").AxiosResponse<any, any>>;
-export declare const initializeActivities: (signal?: AbortSignal | undefined) => Promise<void>;
-export declare const searchInActivities: (inputValue: string, limit: number, signal?: AbortSignal | undefined) => Promise<Omit<IActivities, "keywords">[]>;
+export declare const getAllActivities: (signal?: AbortSignal) => Promise<import("axios").AxiosResponse<any, any>>;
+export declare const initializeActivities: (signal?: AbortSignal) => Promise<void>;
+export declare const searchInActivities: (inputValue: string, limit: number, signal?: AbortSignal) => Promise<Omit<IActivities, "keywords">[]>;

package/dist/helpers/autocomplete.helper.d.ts

@@ -2,6 +2,6 @@ import type { AutocompleteDatasetType } from "@legalplace/models-v3-types";
 export declare const handleDataGouvCitiesWithInpi: ({ inputValue, dataset, signal, variableId, }: {
     inputValue: string;
     dataset: AutocompleteDatasetType;
-    signal?: AbortSignal | undefined;
-    variableId?: string | number | undefined;
+    signal?: AbortSignal;
+    variableId?: string | number;
 }) => Promise<Record<string, string | number | null | undefined>[]>;

package/dist/helpers/autocomplete.helper.js

@@ -11,7 +11,7 @@ import { DataGouvApi } from "@legalplace/data-gouv";
 import { autocompleteDatasetConfig } from "../constants/autocomplete";
 import { DatasetTypeEnum } from "../types/autocomplete.type";
 import { initializeInpiCities, mixDataGouvAndInpiCities, } from "./inpiCitiesHelper";
-export const handleDataGouvCitiesWithInpi = ({ inputValue, dataset, signal, variableId, }) => __awaiter(void 0, void 0, void 0, function* () {
+export const handleDataGouvCitiesWithInpi = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputValue, dataset, signal, variableId, }) {
     yield initializeInpiCities();
     if (inputValue.length < 3) {
         return [];

package/dist/helpers/autosave.helper.d.ts

@@ -1,15 +1,5 @@
-import type { AnyAction, EmptyObject, Store } from "redux";
-import type { StateType } from "../types";
-export declare const getRelatedParentsByVariableId: (variableId: number, index: number) => {
-    id: number;
-    value: Readonly<string | number>;
-    condition: boolean | undefined;
-}[];
-export declare const getAutoCompleteParentVariableId: (variableId: number, index: number, type?: string | undefined) => number | undefined;
-export declare const autoSave: (variablesData: {
-    variablesIds: number[];
-    updateValue: string;
-    index: number;
-}[], store: Store<EmptyObject & StateType, AnyAction> & {
+import type { Store } from "redux";
+import type { StateType } from "../types/State.type";
+export declare const autoSave: (variablesData: any[], store: Store<StateType, any> & {
     dispatch: unknown;
 }) => Promise<void>;

package/dist/helpers/autosave.helper.js

@@ -7,75 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { saveDataAction, selectAutocompleteDataset, selectLinkedVariables, selectOptionReference, selectVariableConditionValue, selectVariableInputByIndex, selectVariableParents, selectVariablesReference, updateVariableAction, } from "../redux";
-import { fetchAutocompleteDataFromInputValue } from "../service";
-import { cleanString } from "../libs";
-export const getRelatedParentsByVariableId = (variableId, index) => {
-    const parentOptionId = selectVariableParents(variableId)[0];
-    const optionData = selectOptionReference(parentOptionId);
-    const variablesSection = selectVariablesReference(optionData === null || optionData === void 0 ? void 0 : optionData.variables);
-    return variablesSection
-        .filter((variableItem) => variableItem.type === "autocomplete" &&
-        Object.values((variableItem === null || variableItem === void 0 ? void 0 : variableItem.linkedVariables) || []).includes(variableId))
-        .map((parentVariable) => ({
-        id: parentVariable.id,
-        value: selectVariableInputByIndex(parentVariable.id, index) || "",
-        condition: selectVariableConditionValue(parentVariable.id, index),
-    }));
-};
-export const getAutoCompleteParentVariableId = (variableId, index, type) => {
-    if (type === "autocomplete") {
-        return variableId;
-    }
-    const autoCompleteParents = getRelatedParentsByVariableId(variableId, index);
-    if (autoCompleteParents.length) {
-        const { id: idParent } = autoCompleteParents[0];
-        return idParent;
-    }
-    return undefined;
-};
-const getResultAutoComplete = (variableId, updateValue, index, store) => __awaiter(void 0, void 0, void 0, function* () {
-    const linkedVariables = selectLinkedVariables(variableId);
-    const autocompleteDataset = selectAutocompleteDataset(variableId);
-    const autocompleteResults = yield fetchAutocompleteDataFromInputValue({
-        dataset: autocompleteDataset,
-        inputValue: cleanString(updateValue),
-        attributes: Object.keys(linkedVariables || {}),
-        variableId,
-    });
-    if (!autocompleteResults) {
-        window.parent.postMessage({ from: "WIZARD", data: "ERROR" }, "*");
-        return;
-    }
-    if (autocompleteResults.length) {
-        const selectedValue = autocompleteResults[0];
-        yield store.dispatch(updateVariableAction(variableId, (selectedValue === null || selectedValue === void 0 ? void 0 : selectedValue.field) || (selectedValue === null || selectedValue === void 0 ? void 0 : selectedValue.primary) || updateValue, index));
-        Object.entries(linkedVariables || {}).forEach(([key, linkedVariableId]) => __awaiter(void 0, void 0, void 0, function* () {
-            yield store.dispatch(updateVariableAction(linkedVariableId, selectedValue[key] || "", index));
-        }));
-        store.dispatch(saveDataAction());
-    }
-});
+import { PathReader } from "../libs/PathReader";
 export const autoSave = (variablesData, store) => __awaiter(void 0, void 0, void 0, function* () {
-    yield variablesData.forEach((variableData, indexVariablesData) => __awaiter(void 0, void 0, void 0, function* () {
-        yield variableData.variablesIds.forEach((variableId, indexVariable) => __awaiter(void 0, void 0, void 0, function* () {
-            let contentVariable = variableData.updateValue;
-            if (variableData.variablesIds.length > 1) {
-                contentVariable = `${variableData.updateValue.split(",")[indexVariable] || ""}`.trim();
-            }
-            const variable = store.getState().references.variables[variableId];
-            const variableParentId = getAutoCompleteParentVariableId(variableId, variableData.index, variable === null || variable === void 0 ? void 0 : variable.type);
-            if (variableParentId) {
-                yield getResultAutoComplete(variableParentId, contentVariable, variableData.index, store);
-                return;
-            }
-            yield store.dispatch(updateVariableAction(variableId, contentVariable, variableData.index));
-            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
-                if (indexVariable === variableData.variablesIds.length - 1 &&
-                    indexVariablesData === variablesData.length - 1) {
-                    store.dispatch(saveDataAction());
-                }
-            }), 200);
-        }));
-    }));
+    if (PathReader.isSmartScriptPath())
+        return;
 });

package/dist/helpers/inpiCitiesHelper.js

@@ -68,8 +68,8 @@ function addressKey(address) {
     return address.postcode;
 }
 export function mixDataGouvAndInpiCities(dataGouvResult, inputValue) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         if (!cachedInpiCities) {
             yield initializeInpiCities();
         }

package/dist/helpers/outputsParsing.d.ts

@@ -1,18 +1,18 @@
 import type { OptionsVariablesType } from "../libs/InputsInitiator";
-export declare type relVarsValsT = Record<string, string | number>;
-export declare type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
+export type relVarsValsT = Record<string, string | number>;
+export type getRelatedVarsT = (optionId: number, index: number, variables: number[]) => relVarsValsT;
 export declare const getRelatedVariablesValues: getRelatedVarsT;
-export declare type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
+export type parseContentT = (output: string, id: number, index: number, variables: relVarsValsT) => string;
 export declare const parseContentWithVariables: parseContentT;
-export declare type autonumsType = [string, string, number, string | null][];
-export declare type parseOutputT = (output: string, id: number, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
+export type autonumsType = [string, string, number, string | null][];
+export type parseOutputT = (output: string, id: number, index: number, variables: relVarsValsT, autonums: autonumsType) => string;
 export declare const parseOutputWithVariables: parseOutputT;
-export declare type parseVariableLabelT = (id: number, index: number) => string;
+export type parseVariableLabelT = (id: number, index: number) => string;
 export declare const parseVariableLabel: parseVariableLabelT;
-export declare type parseOptionLabelT = (id: number, index: number) => string;
+export type parseOptionLabelT = (id: number, index: number) => string;
 export declare const parseOptionLabel: parseOptionLabelT;
-export declare type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export type parseRawT = (text: string, inputs?: OptionsVariablesType, placeholder?: string) => string;
 export declare const parseRawWithVariables: parseRawT;
-export declare type parseRawWithRelatedVariablesT = (text: string, optionId: number, index: number, inputs?: OptionsVariablesType, placeholder?: string) => string;
+export type parseRawWithRelatedVariablesT = (text: string, optionId: number, index: number, inputs?: OptionsVariablesType, placeholder?: string) => string;
 export declare const parseRawWithRelatedVariables: parseRawWithRelatedVariablesT;
 export declare const parsePrefillerValue: (variableId: number, inputIndex: number, prefillerIndex: number) => string;

package/dist/hooks/useDispatch.d.ts

@@ -1 +1 @@
-export declare function useDispatch(): import("redux").Dispatch<import("redux").AnyAction>;
+export declare function useDispatch(): import("redux").Dispatch<any>;

package/dist/hooks/usePrevious.js

@@ -3,6 +3,6 @@ export const usePrevious = (value) => {
     const ref = useRef();
     useEffect(() => {
         ref.current = value;
-    });
+    }, []);
     return ref.current;
 };

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { default as App } from "./App";
 export * from "./App";
+export { default as WizardCore } from "./WizardCore";
+export * from "./WizardCore";
+export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/index.js

@@ -1,5 +1,8 @@
 export { default as App } from "./App";
 export * from "./App";
+export { default as WizardCore } from "./WizardCore";
+export * from "./WizardCore";
+export * from "./routing";
 export * from "./config";
 export * from "./Globals";
 export * from "./PluginLoader";

package/dist/libs/ConditionsRunner.d.ts

@@ -1,6 +1,6 @@
 import type { Dispatch } from "redux";
 import type { StateType, MAPPED_CONDITIONS } from "../types/State.type";
-export declare type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
+export type AllConditions = StateType.Conditions.Options | StateType.Conditions.Variables | StateType.Conditions.Validators | StateType.Conditions.Prefillers | StateType.Conditions.Sections | any[];
 export declare class ConditionsRunner {
     dispatch: Dispatch;
     constructor(dispatch: Dispatch);

package/dist/libs/Formatter/FormatAddress.d.ts

@@ -1 +1 @@
-export declare const cleanString: (str?: string | undefined) => string;
+export declare const cleanString: (str?: string) => string;

package/dist/libs/InputsInitiator.d.ts

@@ -1,5 +1,5 @@
 import type { StateType } from "../types/State.type";
-export declare type OptionsVariablesType = {
+export type OptionsVariablesType = {
     options: {
         [key: string]: boolean[];
     };

package/dist/libs/PathReader.d.ts

@@ -21,7 +21,102 @@ export declare class PathReader {
         appStates: string[];
     };
     getAppStatesPages(): {
-        [x: string]: string;
+        length: number;
+        toString(): string;
+        toLocaleString(): string;
+        toLocaleString(locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string;
+        pop(): string | undefined;
+        push(...items: string[]): number;
+        concat(...items: ConcatArray<string>[]): string[];
+        concat(...items: (string | ConcatArray<string>)[]): string[];
+        join(separator?: string): string;
+        reverse(): string[];
+        shift(): string | undefined;
+        slice(start?: number, end?: number): string[];
+        sort(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+        splice(start: number, deleteCount?: number): string[];
+        splice(start: number, deleteCount: number, ...items: string[]): string[];
+        unshift(...items: string[]): number;
+        indexOf(searchElement: string, fromIndex?: number): number;
+        lastIndexOf(searchElement: string, fromIndex?: number): number;
+        every<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): this is S[];
+        every(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        some(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): boolean;
+        forEach(callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any): void;
+        map<U>(callbackfn: (value: string, index: number, array: string[]) => U, thisArg?: any): U[];
+        filter<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S[];
+        filter(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string[];
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduce(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduce<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string): string;
+        reduceRight(callbackfn: (previousValue: string, currentValue: string, currentIndex: number, array: string[]) => string, initialValue: string): string;
+        reduceRight<U>(callbackfn: (previousValue: U, currentValue: string, currentIndex: number, array: string[]) => U, initialValue: U): U;
+        find<S extends string>(predicate: (value: string, index: number, obj: string[]) => value is S, thisArg?: any): S | undefined;
+        find(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): string | undefined;
+        findIndex(predicate: (value: string, index: number, obj: string[]) => unknown, thisArg?: any): number;
+        fill(value: string, start?: number, end?: number): string[];
+        copyWithin(target: number, start: number, end?: number): string[];
+        entries(): ArrayIterator<[number, string]>;
+        keys(): ArrayIterator<number>;
+        values(): ArrayIterator<string>;
+        includes(searchElement: string, fromIndex?: number): boolean;
+        flatMap<U, This = undefined>(callback: (this: This, value: string, index: number, array: string[]) => U | readonly U[], thisArg?: This | undefined): U[];
+        flat<A, D extends number = 1>(this: A, depth?: D | undefined): FlatArray<A, D>[];
+        at(index: number): string | undefined;
+        findLast<S extends string>(predicate: (value: string, index: number, array: string[]) => value is S, thisArg?: any): S | undefined;
+        findLast(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): string | undefined;
+        findLastIndex(predicate: (value: string, index: number, array: string[]) => unknown, thisArg?: any): number;
+        toReversed(): string[];
+        toSorted(compareFn?: ((a: string, b: string) => number) | undefined): string[];
+        toSpliced(start: number, deleteCount: number, ...items: string[]): string[];
+        toSpliced(start: number, deleteCount?: number): string[];
+        with(index: number, value: string): string[];
+        [Symbol.iterator](): ArrayIterator<string>;
+        [Symbol.unscopables]: {
+            [x: number]: boolean | undefined;
+            length?: boolean | undefined;
+            toString?: boolean | undefined;
+            toLocaleString?: boolean | undefined;
+            pop?: boolean | undefined;
+            push?: boolean | undefined;
+            concat?: boolean | undefined;
+            join?: boolean | undefined;
+            reverse?: boolean | undefined;
+            shift?: boolean | undefined;
+            slice?: boolean | undefined;
+            sort?: boolean | undefined;
+            splice?: boolean | undefined;
+            unshift?: boolean | undefined;
+            indexOf?: boolean | undefined;
+            lastIndexOf?: boolean | undefined;
+            every?: boolean | undefined;
+            some?: boolean | undefined;
+            forEach?: boolean | undefined;
+            map?: boolean | undefined;
+            filter?: boolean | undefined;
+            reduce?: boolean | undefined;
+            reduceRight?: boolean | undefined;
+            find?: boolean | undefined;
+            findIndex?: boolean | undefined;
+            fill?: boolean | undefined;
+            copyWithin?: boolean | undefined;
+            entries?: boolean | undefined;
+            keys?: boolean | undefined;
+            values?: boolean | undefined;
+            includes?: boolean | undefined;
+            flatMap?: boolean | undefined;
+            flat?: boolean | undefined;
+            at?: boolean | undefined;
+            findLast?: boolean | undefined;
+            findLastIndex?: boolean | undefined;
+            toReversed?: boolean | undefined;
+            toSorted?: boolean | undefined;
+            toSpliced?: boolean | undefined;
+            with?: boolean | undefined;
+            [Symbol.iterator]?: boolean | undefined;
+            readonly [Symbol.unscopables]?: boolean | undefined;
+        };
     };
     parsePath(page?: number, uniqid?: string | undefined, modelVersion?: string | undefined): string;
     static isWizardInstancePath(): boolean;

package/dist/libs/PathReader.js

@@ -2,7 +2,6 @@ import { createMatchSelector } from "connected-react-router";
 import queryString from "query-string";
 import { matchPath, generatePath } from "react-router";
 import { getConfig } from "../config";
-import { getPluginsPageAppStates } from "../PluginLoader";
 import { selectAvailableSections, selectAvailableAppStates, selectInstanceUniqid, selectMetaFetchStatus, } from "../redux/selectors/app";
 import { selectSectionReference } from "../redux/selectors/references";
 import Globals from "../Globals";
@@ -125,7 +124,7 @@ export class PathReader {
     }
     getAppStatesPages() {
         const globalAppStates = getConfig().router.appStatesPages || {};
-        const pluginsAppStates = getPluginsPageAppStates();
+        const pluginsAppStates = [];
         return Object.assign(Object.assign({}, globalAppStates), pluginsAppStates);
     }
     parsePath(page = this.currentPage, uniqid = this.currentUniqid, modelVersion = this.modelVersion) {

package/dist/libs/SmartScriptStore.d.ts

@@ -1,7 +1,7 @@
 import type { Action } from "redux";
 import type { ActionsType } from "../types/Actions.type";
 import type { StateType } from "../types/State.type";
-export declare type CallbackType = () => void;
+export type CallbackType = () => void;
 export declare class SmartScriptStore {
     static hooks: {
         variables: Record<string, CallbackType[]>;
@@ -29,11 +29,11 @@ export declare class SmartScriptStore {
     static onVariableChange(id: number | number[], callback: CallbackType): void;
     static updateVariableInput: (id: number, value: string | number, index?: number) => void;
     static updateOptionInput: (id: number, value: boolean, index?: number) => void;
-    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number | undefined) => void;
+    static updateVariableMeta: (id: number, _meta: ActionsType.References.updateVariableMeta["meta"], index?: number) => void;
     static updateOptionMeta: (id: number, _meta: ActionsType.References.updateOptionMeta["meta"]) => void;
     static retrieveExternalData: () => Readonly<false | any[]>;
-    static hideOption: (id: number, index?: number | undefined) => void;
-    static displayOption: (id: number, index?: number | undefined) => void;
-    static hideVariable: (id: number, index?: number | undefined) => void;
-    static displayVariable: (id: number, index?: number | undefined) => void;
+    static hideOption: (id: number, index?: number) => void;
+    static displayOption: (id: number, index?: number) => void;
+    static hideVariable: (id: number, index?: number) => void;
+    static displayVariable: (id: number, index?: number) => void;
 }

package/dist/redux/actions/app.d.ts

@@ -13,7 +13,7 @@ export declare const setFetchStatus: (fetchStatus: "waiting" | "succeeded" | "fa
 export declare const initInstanceAction: (instance: StateType.App.Instance) => ActionsType.App.initInstance;
 export declare const updateInstanceAction: (instance: Partial<StateType.App.Instance>) => ActionsType.App.updateInstance;
 export declare const updateInstancePaidAction: (isPaid: boolean) => ActionsType.App.updateInstancePaid;
-export declare type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, "type">;
+export type initPaginationActionPropsType = Omit<ActionsType.App.initPagination, "type">;
 export declare const initPaginationAction: (pagination: initPaginationActionPropsType) => ActionsType.App.initPagination;
 export declare const updateAvailableAppStatesAction: (availableAppStates: StateType.App.Pagination["availableAppStates"], ingorePluginAppStateReset?: boolean) => ActionsType.App.updateAvailableAppStates;
 export declare const goPageAction: (page: number, pushHistory?: boolean) => ActionsType.App.goPage;

package/dist/redux/actions/inputs.d.ts

@@ -1,6 +1,6 @@
 import type { StateType } from "../../types/State.type";
 import type { ActionsType } from "../../types/Actions.type";
-export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References | undefined) => ActionsType.Inputs.initInputs;
+export declare const initInputsAction: (inputs: StateType.Inputs, references?: StateType.References) => ActionsType.Inputs.initInputs;
 export declare const initOptionAction: (id: number, values: boolean[]) => ActionsType.Inputs.initOption;
 export declare const updateOptionAction: (id: number, value: boolean, index: number) => ActionsType.Inputs.updateOptionInput;
 export declare const initVariableAction: (id: number, values: (string | number)[]) => ActionsType.Inputs.initVariable;

package/dist/redux/actions/library.d.ts

@@ -1,36 +1,33 @@
 import * as app from "./app";
 export declare const actionsLibrary: {
-    setUserEmail: (email: string, disableRedirect?: boolean | undefined, inBackground?: boolean | undefined) => import("../..").ActionsType.User.setUserEmail;
+    setUserEmail: (email: string, disableRedirect?: boolean, inBackground?: boolean) => import("../..").ActionsType.User.setUserEmail;
     setUserEmailSucceeded: () => import("../..").ActionsType.User.setUserEmailSucceeded;
     fetchModelPrerequisitesAction: (permalink: string, prefix?: string) => import("../..").ActionsType.Sagas.Model.fetchModelPrerequisites;
     fetchModelAction: (permalink: string, prefix: string | undefined, uniqid: string | undefined, uniqidParam: string | undefined, queryParams: URLSearchParams, pathReader: import("../..").PathReader, urlParams: URLSearchParams, clientConfigReturnValue: {
         appStates: string[];
         enableShadowInstance: boolean;
     }, wizardConfig: import("../..").WizardConfigResponse) => import("../..").ActionsType.Sagas.Model.fetchModel;
-    saveDataAction: (redirect?: boolean, confirmAnswer?: boolean | undefined, redirectFallback?: string | undefined, redirectOverride?: string | undefined, additionalProperties?: Record<string, string | number> | undefined) => import("../..").ActionsType.Sagas.Data.saveData;
+    saveDataAction: (redirect?: boolean, confirmAnswer?: boolean, redirectFallback?: string, redirectOverride?: string, additionalProperties?: Record<string, string | number>) => import("../..").ActionsType.Sagas.Data.saveData;
     initUserAction: (user: Omit<import("../..").StateType.User, "status">) => import("../..").ActionsType.User.initUser;
-    setUserStatusAction: (status: "failed" | "authenticated" | "unauthenticated" | "inprogress") => import("../..").ActionsType.User.setUserStatus;
+    setUserStatusAction: (status: "authenticated" | "unauthenticated" | "inprogress" | "failed") => import("../..").ActionsType.User.setUserStatus;
     setUserValidTokenAction: (validToken: boolean) => import("../..").ActionsType.User.setUserValidToken;
     enableSmartscriptAction: () => import("../..").ActionsType.SmartScript.enableSmartScript;
-    initDataSmartscriptAction: (data: object | undefined) => import("../..").ActionsType.SmartScript.initDataSmartscript;
+    initDataSmartscriptAction: (data: import("../..").StateType.SmartScript["data"]) => import("../..").ActionsType.SmartScript.initDataSmartscript;
     callInitDataSmartscriptAction: () => import("../..").ActionsType.SmartScript.requestinitDataSmartscript;
-    initSmartscriptTriggersAction: (triggers: {
-        options: number[];
-        variables: number[];
-    }) => import("../..").ActionsType.SmartScript.initSmartscriptTriggers;
+    initSmartscriptTriggersAction: (triggers: import("../..").StateType.SmartScript["triggers"]) => import("../..").ActionsType.SmartScript.initSmartscriptTriggers;
     updateSmartscriptOptionHiddenAction: (id: number, index: number, hide: boolean) => import("../..").ActionsType.SmartScript.updateSmartscriptOptionHidden;
     updateSmartscriptVariableHiddenAction: (id: number, index: number, hide: boolean) => import("../..").ActionsType.SmartScript.updateSmartscriptVariableHidden;
     initReferencesAction: (references: import("../..").StateType.References) => import("../..").ActionsType.References.initReferences;
-    updateVariableMetaAction: (id: number, meta: import("../..").ActionsType.References.VariableUpdatableMeta, index?: number | undefined) => import("../..").ActionsType.References.updateVariableMeta;
-    updateOptionMetaAction: (id: number, meta: import("../..").ActionsType.References.OptionUpdatableMeta) => import("../..").ActionsType.References.updateOptionMeta;
-    setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string | undefined) => import("../..").ActionsType.References.setDisabledVariable;
+    updateVariableMetaAction: (id: number, meta: import("../..").ActionsType.References.updateVariableMeta["meta"], index?: number) => import("../..").ActionsType.References.updateVariableMeta;
+    updateOptionMetaAction: (id: number, meta: import("../..").ActionsType.References.updateOptionMeta["meta"]) => import("../..").ActionsType.References.updateOptionMeta;
+    setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string) => import("../..").ActionsType.References.setDisabledVariable;
     initMandatoryOptionAction: (id: number, value: boolean[]) => import("../..").ActionsType.Mandatories.initMandatoryOption;
     initMandatoryVariableAction: (id: number, value: boolean[]) => import("../..").ActionsType.Mandatories.initMandatoryVariable;
     setMandatoryIgnoreAction: (value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryIgnore;
     setMandatorySectionAction: (id: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatorySection;
     setMandatoryOptionAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryOption;
     setMandatoryVariableAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Mandatories.setMandatoryVariable;
-    initInputsAction: (inputs: import("../..").StateType.Inputs, references?: import("../..").StateType.References | undefined) => import("../..").ActionsType.Inputs.initInputs;
+    initInputsAction: (inputs: import("../..").StateType.Inputs, references?: import("../..").StateType.References) => import("../..").ActionsType.Inputs.initInputs;
     initOptionAction: (id: number, values: boolean[]) => import("../..").ActionsType.Inputs.initOption;
     updateOptionAction: (id: number, value: boolean, index: number) => import("../..").ActionsType.Inputs.updateOptionInput;
     initVariableAction: (id: number, values: (string | number)[]) => import("../..").ActionsType.Inputs.initVariable;
@@ -46,29 +43,26 @@ export declare const actionsLibrary: {
     updateOptionValidatorConditionsAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Conditions.updateOptionValidatorCondition;
     updateVariableValidatorConditionsAction: (id: number, index: number, value: boolean) => import("../..").ActionsType.Conditions.updateVariableValidatorCondition;
     initMetaAction: (meta: Omit<import("../..").StateType.App.Meta, "fetchStatus">) => import("../..").ActionsType.App.initMeta;
-    setModelUuidAction: (modelUuid: string | undefined) => import("../..").ActionsType.App.setModelUuid;
+    setModelUuidAction: (modelUuid: import("../..").StateType.App.Meta["modelUuid"]) => import("../..").ActionsType.App.setModelUuid;
     fetchModelSucceededAction: () => import("../..").ActionsType.App.fetchModelSucceeded;
     fetchModelNonBlockingAction: () => import("../..").ActionsType.App.fetchModelNonBlocking;
-    fetchModelUnhealthyAction: (report: {
-        object: import("@legalplace/model-healthcheck/dist/libs/HealthCheck.type").HealthCheckReport;
-        raw: string;
-    } | undefined) => import("../..").ActionsType.App.fetchModelUnhealthy;
+    fetchModelUnhealthyAction: (report: import("../..").StateType.App.Meta["report"]) => import("../..").ActionsType.App.fetchModelUnhealthy;
     fetchModelUserLockedAction: () => import("../..").ActionsType.App.fetchModelUserLocked;
     fetchModelFailedAction: () => import("../..").ActionsType.App.fetchModelFailed;
     setDataStatus: (dataStatus: "saved" | "unsaved" | "saving" | "failed") => import("../..").ActionsType.App.setDataStatus;
-    setFetchStatus: (fetchStatus: "failed" | "waiting" | "succeeded" | "unhealthy" | "userLocked") => import("../..").ActionsType.App.setFetchStatus;
+    setFetchStatus: (fetchStatus: "waiting" | "succeeded" | "failed" | "unhealthy" | "userLocked") => import("../..").ActionsType.App.setFetchStatus;
     initInstanceAction: (instance: import("../..").StateType.App.Instance) => import("../..").ActionsType.App.initInstance;
     updateInstanceAction: (instance: Partial<import("../..").StateType.App.Instance>) => import("../..").ActionsType.App.updateInstance;
     updateInstancePaidAction: (isPaid: boolean) => import("../..").ActionsType.App.updateInstancePaid;
     initPaginationAction: (pagination: app.initPaginationActionPropsType) => import("../..").ActionsType.App.initPagination;
-    updateAvailableAppStatesAction: (availableAppStates: string[], ingorePluginAppStateReset?: boolean) => import("../..").ActionsType.App.updateAvailableAppStates;
+    updateAvailableAppStatesAction: (availableAppStates: import("../..").StateType.App.Pagination["availableAppStates"], ingorePluginAppStateReset?: boolean) => import("../..").ActionsType.App.updateAvailableAppStates;
     goPageAction: (page: number, pushHistory?: boolean) => import("../..").ActionsType.App.goPage;
     goNextPageAction: () => import("../..").ActionsType.App.goNextPage;
     goPreviousPageAction: () => import("../..").ActionsType.App.goPreviousPage;
     updateCurrentAppStateAction: (currentAppState: string) => import("../..").ActionsType.App.updateCurrentAppState;
     updateAvailableSectionsAction: (availableSections: number[]) => import("../..").ActionsType.App.updateAvailableSections;
     updateCurrentSectionIdAction: (currentSectionId: number) => import("../..").ActionsType.App.updateCurrentSectionId;
-    initCustomizationMetaAction: (meta: import("@legalplace/models-v3-types").CustomizationMetaDefault) => import("../..").ActionsType.App.initCustomizationMeta;
-    initCustomizationAutoDefaultAction: (disableAutoDefault: boolean | undefined) => import("../..").ActionsType.App.initCustomizationAutoDefault;
+    initCustomizationMetaAction: (meta: Exclude<import("@legalplace/models-v3-types").ModelV3["customization"]["meta"], undefined>) => import("../..").ActionsType.App.initCustomizationMeta;
+    initCustomizationAutoDefaultAction: (disableAutoDefault: import("../..").StateType.App.Customization["disableAutoDefault"]) => import("../..").ActionsType.App.initCustomizationAutoDefault;
     resetStateAction: () => import("../..").ActionsType.App.resetState;
 };

package/dist/redux/actions/references.d.ts

@@ -1,6 +1,6 @@
 import type { StateType } from "../../types/State.type";
 import type { ActionsType } from "../../types/Actions.type";
 export declare const initReferencesAction: (references: StateType.References) => ActionsType.References.initReferences;
-export declare const updateVariableMetaAction: (id: number, meta: ActionsType.References.updateVariableMeta["meta"], index?: number | undefined) => ActionsType.References.updateVariableMeta;
+export declare const updateVariableMetaAction: (id: number, meta: ActionsType.References.updateVariableMeta["meta"], index?: number) => ActionsType.References.updateVariableMeta;
 export declare const updateOptionMetaAction: (id: number, meta: ActionsType.References.updateOptionMeta["meta"]) => ActionsType.References.updateOptionMeta;
-export declare const setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string | undefined) => ActionsType.References.setDisabledVariable;
+export declare const setDisabledVariableAction: (id: number, disabled: boolean, index: number, disabledTooltip?: string) => ActionsType.References.setDisabledVariable;

package/dist/redux/actions/sagas/data.d.ts

@@ -1,2 +1,2 @@
 import type { ActionsType } from "../../../types/Actions.type";
-export declare const saveDataAction: (redirect?: boolean, confirmAnswer?: boolean | undefined, redirectFallback?: string | undefined, redirectOverride?: string | undefined, additionalProperties?: Record<string, string | number> | undefined) => ActionsType.Sagas.Data.saveData;
+export declare const saveDataAction: (redirect?: boolean, confirmAnswer?: boolean, redirectFallback?: string, redirectOverride?: string, additionalProperties?: Record<string, string | number>) => ActionsType.Sagas.Data.saveData;

package/dist/redux/actions/sagas/user.d.ts

@@ -1,3 +1,3 @@
 import type { ActionsType } from "../../../types/Actions.type";
-export declare const setUserEmail: (email: string, disableRedirect?: boolean | undefined, inBackground?: boolean | undefined) => ActionsType.User.setUserEmail;
+export declare const setUserEmail: (email: string, disableRedirect?: boolean, inBackground?: boolean) => ActionsType.User.setUserEmail;
 export declare const setUserEmailSucceeded: () => ActionsType.User.setUserEmailSucceeded;

package/dist/redux/listeners/subscriber.d.ts

@@ -1,5 +1,5 @@
 import type { Store, Dispatch, AnyAction } from "redux";
 import type { StateType } from "../../types/State.type";
-export declare type StoreListener = (previousState: StateType, currentState: StateType, dispatch: Dispatch<AnyAction>) => void;
+export type StoreListener = (previousState: StateType, currentState: StateType, dispatch: Dispatch<AnyAction>) => void;
 declare const subscribeListeners: (store: Store, listenersToSubscribe?: StoreListener[]) => void;
 export default subscribeListeners;

package/dist/redux/middlewares/conditionsWatcherMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { Dispatch, MiddlewareAPI } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Conditions.initConditions;
+export type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Conditions.initConditions;
 declare const conditionsWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default conditionsWatcherMiddleware;

package/dist/redux/middlewares/evaluationsWatcherMiddleware.d.ts

@@ -2,6 +2,6 @@ import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
 import type { StateType } from "../../types/State.type";
 export declare const watchUpdateVariable: (mpi: MiddlewareAPI<Dispatch, StateType>, next: Dispatch, action: ActionsType.Inputs.updateVariableInput | ActionsType.Conditions.updateVariableCondition) => ActionsType.Inputs.updateVariableInput | ActionsType.Conditions.updateVariableCondition;
-export declare type WatcherActions = ActionsType.Conditions.updateVariableCondition | ActionsType.Conditions.updateOptionCondition | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.App.fetchModelSucceeded;
+export type WatcherActions = ActionsType.Conditions.updateVariableCondition | ActionsType.Conditions.updateOptionCondition | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.App.fetchModelSucceeded;
 declare const evaluationsWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default evaluationsWatcherMiddleware;

package/dist/redux/middlewares/mandatoriesWatcherMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { Dispatch, MiddlewareAPI } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Mandatories.setMandatoryOption | ActionsType.Mandatories.setMandatoryVariable;
+export type WatcherActions = ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput | ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency | ActionsType.Mandatories.setMandatoryOption | ActionsType.Mandatories.setMandatoryVariable;
 declare const mandatoriesWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default mandatoriesWatcherMiddleware;

package/dist/redux/middlewares/multiplesActionsMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency;
+export type WatcherActions = ActionsType.Inputs.addMultipleOccurency | ActionsType.Inputs.deleteMultipleOccurency;
 declare const multiplesActionsMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default multiplesActionsMiddleware;

package/dist/redux/middlewares/paginationWatcherMiddleware.d.ts

@@ -1,6 +1,6 @@
 import type { LocationChangeAction } from "connected-react-router";
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.Conditions.updateSectionCondition | LocationChangeAction;
-declare const paginationWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
+export type WatcherActions = ActionsType.Conditions.updateSectionCondition | LocationChangeAction;
+declare const paginationWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => any;
 export default paginationWatcherMiddleware;

package/dist/redux/middlewares/pluginsHookMiddleware.d.ts

@@ -1,3 +1,2 @@
-import type { MiddlewareAPI, Dispatch, Action } from "redux";
-declare const pluginsHookMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: Action) => Action<any>;
+declare const pluginsHookMiddleware: any;
 export default pluginsHookMiddleware;

package/dist/redux/middlewares/pluginsHookMiddleware.js

@@ -1,10 +1,4 @@
-import { RunActionAnchor, RunOverrideActionAnchor } from "../../PluginLoader";
 const pluginsHookMiddleware = (mpi) => (next) => (action) => {
-    const previousState = mpi.getState();
-    const overridenAction = RunOverrideActionAnchor(action);
-    const nextResult = next(overridenAction);
-    const nextState = mpi.getState();
-    RunActionAnchor(action.type, previousState, nextState);
-    return nextResult;
+    return next(action);
 };
 export default pluginsHookMiddleware;

package/dist/redux/middlewares/prefillerWatcherMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.Conditions.updatePrefillerCondition;
+export type WatcherActions = ActionsType.Conditions.updatePrefillerCondition;
 declare const prefillerWatcherMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | ActionsType.Conditions.updatePrefillerCondition;
 export default prefillerWatcherMiddleware;

package/dist/redux/middlewares/smartscriptMiddleware.d.ts

@@ -1,5 +1,5 @@
 import type { MiddlewareAPI, Dispatch } from "redux";
 import type { ActionsType } from "../../types/Actions.type";
-export declare type WatcherActions = ActionsType.SmartScript.enableSmartScript | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput;
+export type WatcherActions = ActionsType.SmartScript.enableSmartScript | ActionsType.Inputs.updateOptionInput | ActionsType.Inputs.updateVariableInput;
 declare const smartscriptMiddleware: (mpi: MiddlewareAPI) => (next: Dispatch) => (action: WatcherActions) => void | WatcherActions;
 export default smartscriptMiddleware;