@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/libs/NumAuto.test.js

@@ -0,0 +1,43 @@
+import { NumAuto } from './NumAuto';
+describe('NumAuto Test Suit', () => {
+    it('Resets properly', () => {
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        NumAuto.resetNums();
+    });
+    it('It increments indexes correctly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+    });
+    it('It tags properly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', 'myTestTag')).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNumPre('myTestTag', 0, 0)).toEqual(2);
+        expect(NumAuto.getNum('myTestTag', null)).toEqual(2);
+    });
+    it('It returns previous indexes correctly', () => {
+        NumAuto.resetNums();
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(1);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(2);
+        expect(NumAuto.getNumPre('myTestIndex', 0, 1)).toEqual(3);
+        expect(NumAuto.getNumPre('myOtherTestIndex', 0, 0)).toEqual(2);
+        expect(NumAuto.getNum('myTestIndex', null)).toEqual(4);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(3);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(4);
+        expect(NumAuto.getNum('myOtherTestIndex', null)).toEqual(5);
+        expect(NumAuto.getNumPre('myTestIndex', 0, 0)).toEqual(4);
+        expect(NumAuto.getNumPre('myOtherTestIndex', 0, 1)).toEqual(5);
+    });
+});

package/dist/libs/OvcConverter.d.ts

@@ -0,0 +1,21 @@
+import { StateType } from '../types/State.type';
+export interface OvcType {
+    o: {
+        [k: string]: string | number | (string | number)[];
+    };
+    v: {
+        [k: string]: string | number | (string | number)[];
+    };
+    c: {
+        [k: string]: boolean | boolean[];
+    };
+}
+declare class _OvcConverter {
+    convertToOptionsVariables(ovc: OvcType, references: StateType.References): StateType.Inputs;
+    convertToOvc(inputs: StateType.Inputs): OvcType;
+    isOvc(_obj: StateType.Inputs | OvcType): boolean;
+    isOptionsVariables(_obj: StateType.Inputs | OvcType): boolean;
+    private pushStaticChildren;
+}
+export declare const OvcConverter: _OvcConverter;
+export {};

package/dist/libs/OvcConverter.js

@@ -0,0 +1,182 @@
+import { selectOptionParents, selectOptionReference, selectVariableParents, } from '../redux/selectors/references';
+import { selectOptionInput } from '../redux/selectors/inputs';
+class _OvcConverter {
+    convertToOptionsVariables(ovc, references) {
+        const inputs = {
+            options: {},
+            variables: {},
+        };
+        if (typeof ovc !== 'object')
+            return inputs;
+        if (typeof ovc.o === 'object') {
+            Object.keys(ovc.o).forEach((id) => {
+                const currentOption = ovc.o[id];
+                if (Array.isArray(currentOption)) {
+                    const occurences = currentOption.length;
+                    inputs.options = Object.assign(Object.assign({}, inputs.options), this.pushStaticChildren(inputs.options, id, occurences, references));
+                    currentOption.forEach((childId, index) => {
+                        const sanitizedId = typeof childId === 'string' && childId.split('_').length > 0
+                            ? childId.split('_')[0]
+                            : childId;
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, id)) {
+                            inputs.options[id] = new Array(occurences).fill(false);
+                        }
+                        if (typeof sanitizedId === 'string' &&
+                            sanitizedId.trim().length === 0) {
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(inputs.options, sanitizedId)) {
+                            inputs.options[sanitizedId] = new Array(occurences).fill(false);
+                        }
+                        inputs.options = Object.assign(Object.assign({}, inputs.options), this.pushStaticChildren(inputs.options, sanitizedId, occurences, references));
+                        inputs.options[sanitizedId][index] = true;
+                    });
+                }
+                else {
+                    if (typeof currentOption === 'string' &&
+                        currentOption.trim().length === 0)
+                        return;
+                    inputs.options[currentOption] = [true];
+                }
+            });
+        }
+        if (typeof ovc.c === 'object') {
+            Object.keys(ovc.c).forEach((id) => {
+                const currentCheckbox = ovc.c[id];
+                if (typeof id === 'string' && id.trim().length === 0)
+                    return;
+                if (Array.isArray(currentCheckbox)) {
+                    inputs.options[id] = currentCheckbox;
+                }
+                else {
+                    inputs.options[id] = [currentCheckbox];
+                }
+            });
+        }
+        if (typeof ovc.v === 'object') {
+            Object.keys(ovc.v).forEach((id) => {
+                const currentVariable = ovc.v[id];
+                if (Array.isArray(currentVariable)) {
+                    inputs.variables[id] = currentVariable;
+                    const parentsTree = references.relations.variables[id].parents;
+                    const parentOption = inputs.options[`${parentsTree[parentsTree.length - 1]}`];
+                    if (Array.isArray(parentOption)) {
+                        const occurences = parentOption.length;
+                        if (currentVariable.length < occurences) {
+                            inputs.variables[id] = [
+                                ...currentVariable,
+                                ...Array(occurences - currentVariable.length).fill(''),
+                            ];
+                        }
+                    }
+                }
+                else {
+                    inputs.variables[id] = [currentVariable];
+                }
+            });
+        }
+        return inputs;
+    }
+    convertToOvc(inputs) {
+        const ovc = {
+            o: {},
+            v: {},
+            c: {},
+        };
+        Object.keys(inputs.options).forEach((stringId) => {
+            var _a;
+            const id = parseInt(stringId, 10);
+            const values = inputs.options[id];
+            const parentsTree = selectOptionParents(id);
+            const parentId = parentsTree[0];
+            const optionReference = selectOptionReference(id);
+            const rootOptionId = parentsTree.length > 0 ? parentsTree[parentsTree.length - 1] : id;
+            const isMultiple = parentsTree.length > 0 &&
+                ((_a = selectOptionReference(rootOptionId).meta.multiple) === null || _a === void 0 ? void 0 : _a.enabled) === true;
+            const occurences = selectOptionInput(rootOptionId).length;
+            if (!['radio', 'checkbox'].includes(optionReference.meta.type)) {
+                if (values.length > 1 && rootOptionId === id) {
+                    ovc.o[id] = new Array(values.length).fill('');
+                }
+                return;
+            }
+            const trueIndexes = values
+                .map((value, index) => (value === true ? index : null))
+                .filter((value) => value !== null);
+            const isCheckbox = optionReference.meta.type === 'checkbox';
+            if (isCheckbox === true) {
+                if (isMultiple === true) {
+                    ovc.c[id] = values;
+                }
+                else {
+                    [ovc.c[id]] = values;
+                }
+            }
+            else if (isMultiple === true) {
+                if (!Object.prototype.hasOwnProperty.call(ovc.o, parentId)) {
+                    ovc.o[parentId] = new Array(occurences).fill('');
+                }
+                trueIndexes.forEach((index) => {
+                    const currentOption = ovc.o[parentId];
+                    if (Array.isArray(currentOption)) {
+                        currentOption[index] = id;
+                    }
+                });
+            }
+            else if (values[0] === true) {
+                ovc.o[parentId] = id;
+            }
+        });
+        Object.keys(inputs.variables).forEach((stringId) => {
+            var _a;
+            const id = parseInt(stringId, 10);
+            const values = inputs.variables[id];
+            const parentsTree = selectVariableParents(id);
+            const isMultiple = ((_a = selectOptionReference(parentsTree[parentsTree.length - 1]).meta.multiple) === null || _a === void 0 ? void 0 : _a.enabled) === true;
+            const occurences = selectOptionInput(parentsTree[parentsTree.length - 1]).length;
+            if (isMultiple === true) {
+                if (!Object.prototype.hasOwnProperty.call(ovc.o, id)) {
+                    ovc.v[id] = new Array(occurences).fill('');
+                }
+                ovc.v[id] = values;
+            }
+            else {
+                [ovc.v[id]] = values;
+            }
+        });
+        return ovc;
+    }
+    isOvc(_obj) {
+        if (typeof _obj !== 'object' || _obj === null)
+            return false;
+        const ovcKeys = ['o', 'v', 'c'];
+        const foundKeys = Object.keys(_obj)
+            .map((key) => (ovcKeys.includes(key) ? 1 : 0))
+            .reduce((a, b) => a + b, 0);
+        return foundKeys > 1;
+    }
+    isOptionsVariables(_obj) {
+        if (typeof _obj !== 'object' || _obj === null)
+            return false;
+        const optionsVariablesKeys = ['options', 'variables'];
+        const foundKeys = Object.keys(_obj)
+            .map((key) => (optionsVariablesKeys.includes(key) ? 1 : 0))
+            .reduce((a, b) => a + b, 0);
+        return foundKeys === 2;
+    }
+    pushStaticChildren(inputOptions, id, occurences, references) {
+        const result = Object.assign({}, inputOptions);
+        const intId = typeof id === 'number' ? id : parseInt(id, 10);
+        const { options } = references.relations.options[intId].children;
+        const staticOptions = options.filter((childId) => {
+            return references.options[childId].meta.type === 'static';
+        });
+        staticOptions.forEach((childId) => {
+            if (!Object.prototype.hasOwnProperty.call(result, childId)) {
+                result[childId] = new Array(occurences).fill(false);
+            }
+        });
+        return result;
+    }
+}
+export const OvcConverter = new _OvcConverter();

package/dist/libs/PathReader.d.ts

@@ -0,0 +1,26 @@
+import { StateType } from '../types/State.type';
+export declare class PathReader {
+    currentPage: number;
+    currentSectionId: number;
+    currentAppState: string;
+    currentPermalink: string;
+    currentView: string;
+    prefix: string;
+    currentUniqid: string | undefined;
+    modelVersion: string | undefined;
+    constructor(state: StateType);
+    matchWithoutUniqId(state: StateType): void;
+    matchWithUniqId(state: StateType): void;
+    getAppState(page: string): string;
+    getPageUrlName(page: number): string;
+    getPageNumber(page: string): number;
+    getSectionId(page?: number): number;
+    getPagination(): {
+        pages: (string | number)[];
+        appStates: string[];
+    };
+    getAppStatesPages(): {
+        [x: string]: string;
+    };
+    parsePath(page?: number, uniqid?: string | undefined, modelVersion?: string | undefined): string;
+}

package/dist/libs/PathReader.js

@@ -0,0 +1,143 @@
+import { createMatchSelector } from 'connected-react-router';
+import queryString from 'query-string';
+import { getConfig } from '../config';
+import { getPluginsPageAppStates } from '../PluginLoader';
+import { selectAvailableSections, selectAvailableAppStates, } from '../redux/selectors/app';
+import Globals from '../Globals';
+export class PathReader {
+    constructor(state) {
+        this.currentPage = 1;
+        this.currentSectionId = 1;
+        this.currentAppState = '';
+        this.currentPermalink = '';
+        this.currentView = '';
+        this.prefix = '';
+        this.currentUniqid = undefined;
+        this.modelVersion = undefined;
+        this.matchWithUniqId(state);
+        this.matchWithoutUniqId(state);
+        if (state.app.instance.uniqid !== '') {
+            this.currentUniqid = state.app.instance.uniqid;
+        }
+    }
+    matchWithoutUniqId(state) {
+        const matchSelector = createMatchSelector(getConfig().router.wizardPath);
+        const match = matchSelector(state);
+        if (match) {
+            const { permalink, page, view, prefix } = match.params;
+            const modelVersion = queryString.parse(window.location.search).version;
+            this.prefix = prefix || '';
+            this.currentPermalink = Globals.permalink || permalink;
+            this.currentPage = this.getPageNumber(page);
+            this.currentSectionId = this.getSectionId();
+            this.currentAppState = this.getAppState(page);
+            this.currentView = view;
+            this.modelVersion =
+                typeof modelVersion === 'string' ? modelVersion : undefined;
+        }
+    }
+    matchWithUniqId(state) {
+        const matchSelector = createMatchSelector(getConfig().router.wizardInstancePath);
+        const match = matchSelector(state);
+        if (match) {
+            const { permalink, page, uniqid, view, prefix } = match.params;
+            const modelVersion = queryString.parse(window.location.search).version;
+            this.currentPermalink = Globals.permalink || permalink;
+            this.prefix = prefix || '';
+            this.currentPage = this.getPageNumber(page);
+            this.currentSectionId = this.getSectionId();
+            this.currentUniqid = uniqid;
+            this.currentAppState = this.getAppState(page);
+            this.currentView = view;
+            this.modelVersion =
+                typeof modelVersion === 'string' ? modelVersion : undefined;
+        }
+    }
+    getAppState(page) {
+        const appStatesPages = this.getAppStatesPages();
+        let currentAppState = 'wizard';
+        Object.keys(appStatesPages).forEach((appState) => {
+            if (appStatesPages[appState] === page)
+                currentAppState = appState;
+        });
+        return currentAppState;
+    }
+    getPageUrlName(page) {
+        const pagesArray = this.getPagination().pages;
+        if (page > pagesArray.length)
+            return `${pagesArray[pagesArray.length - 1]}`;
+        return `${pagesArray[page - 1]}`;
+    }
+    getPageNumber(page) {
+        const { pages } = this.getPagination();
+        const parsedPage = Number.isNaN(parseInt(page, 10))
+            ? page
+            : parseInt(page, 10);
+        return pages.indexOf(parsedPage) + 1 || 1;
+    }
+    getSectionId(page = this.currentPage) {
+        const availableSections = selectAvailableSections();
+        const { appStates } = this.getPagination();
+        const pageIndex = page - 1;
+        let availableSectionsIndex = 0;
+        if (appStates[pageIndex] === 'wizard')
+            availableSectionsIndex = pageIndex - appStates.indexOf('wizard');
+        return availableSections[availableSectionsIndex];
+    }
+    getPagination() {
+        const availableAppStates = selectAvailableAppStates();
+        let pages = [];
+        let appStates = [];
+        availableAppStates.forEach((currentAppState) => {
+            if (currentAppState === 'wizard')
+                selectAvailableSections().forEach(() => {
+                    pages = [...pages, pages.length + 1];
+                    appStates = [...appStates, 'wizard'];
+                });
+            else if (Object.prototype.hasOwnProperty.call(this.getAppStatesPages(), currentAppState)) {
+                pages = [...pages, this.getAppStatesPages()[currentAppState]];
+                appStates = [...appStates, currentAppState];
+            }
+            else {
+                pages = [...pages, pages.length + 1];
+                appStates = [...appStates, currentAppState];
+            }
+        });
+        return {
+            pages,
+            appStates,
+        };
+    }
+    getAppStatesPages() {
+        const globalAppStates = getConfig().router.appStatesPages || {};
+        const pluginsAppStates = getPluginsPageAppStates();
+        return Object.assign(Object.assign({}, globalAppStates), pluginsAppStates);
+    }
+    parsePath(page = this.currentPage, uniqid = this.currentUniqid, modelVersion = this.modelVersion) {
+        let path = uniqid === undefined
+            ? getConfig().router.wizardPath
+            : getConfig().router.wizardInstancePath;
+        path = path.replace(/:permalink(\(([^/]*)\))?/gi, this.currentPermalink);
+        if (this.prefix)
+            path = path.replace(/:prefix\?(\(([^/]*)\))?/gi, this.prefix);
+        else
+            path = path.replace(/\/:prefix\?(\(([^/]*)\))?/gi, '');
+        path = path.replace(/:page(\(([^/]*)\))?\??/gi, this.getPageUrlName(page));
+        if (uniqid !== undefined) {
+            path = path.replace(/:uniqid(\(([^/]*)\))?/gi, uniqid);
+        }
+        if (modelVersion !== undefined) {
+            path += `?version=${modelVersion}`;
+        }
+        path = path.replace(/:view(\(([^/]*)\))?/gi, this.currentView);
+        const queryParams = queryString.parse(window.location.search);
+        if (queryParams.version !== undefined)
+            delete queryParams.version;
+        const cleanQueryString = queryString.stringify(queryParams);
+        if (cleanQueryString.length > 0) {
+            path += modelVersion === undefined ? '?' : '&';
+            path += cleanQueryString;
+        }
+        return path;
+    }
+}

package/dist/libs/SectionValidity.d.ts

@@ -0,0 +1,8 @@
+export declare class SectionValidity {
+    validity: boolean;
+    sectionId: number;
+    constructor(sectionId: number);
+    private checkSection;
+    private checkOption;
+    private checkVariable;
+}

package/dist/libs/SectionValidity.js

@@ -0,0 +1,53 @@
+import { selectSectionReference, selectOptionReference, } from '../redux/selectors/references';
+import { selectOptionConditionValue, selectOptionValidatorConditionValue, selectVariableConditionValue, selectVariableValidatorConditionValue, } from '../redux/selectors/conditions';
+import { selectOptionInput, selectOptionInputByIndex, } from '../redux/selectors/inputs';
+export class SectionValidity {
+    constructor(sectionId) {
+        this.validity = true;
+        this.sectionId = sectionId;
+        this.checkSection();
+    }
+    checkSection() {
+        const sectionReference = selectSectionReference(this.sectionId);
+        if (sectionReference === undefined)
+            throw new Error(`Section ${this.sectionId} does not exist`);
+        sectionReference.options.forEach((optionId) => {
+            const optionInputs = selectOptionInput(optionId);
+            optionInputs.forEach((value, index) => {
+                if (this.validity === false)
+                    return;
+                this.checkOption(optionId, index);
+            });
+        });
+    }
+    checkOption(optionId, index) {
+        const optionReference = selectOptionReference(optionId);
+        if (optionReference === undefined)
+            throw new Error(`Option ${optionId} does not exist`);
+        const optionValue = selectOptionInputByIndex(optionId, index);
+        const optionCondition = selectOptionConditionValue(optionId, index);
+        if (optionValue === false || optionCondition === false)
+            return;
+        const validatorValue = selectOptionValidatorConditionValue(optionId, index);
+        const optionValidity = validatorValue === true || validatorValue === undefined;
+        this.validity = this.validity && optionValidity;
+        if (this.validity === false)
+            return;
+        optionReference.options.forEach((childrenId) => {
+            this.checkOption(childrenId, index);
+        });
+        optionReference.variables.forEach((variableId) => {
+            if (this.validity === false)
+                return;
+            this.checkVariable(variableId, index);
+        });
+    }
+    checkVariable(variableId, index) {
+        const variableCondition = selectVariableConditionValue(variableId, index);
+        if (variableCondition === false)
+            return;
+        const validatorValue = selectVariableValidatorConditionValue(variableId, index);
+        const variableValidity = validatorValue === true || validatorValue === undefined;
+        this.validity = this.validity && variableValidity;
+    }
+}

package/dist/libs/SectionValidity.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/libs/SectionValidity.test.js

@@ -0,0 +1,116 @@
+import { SectionValidity } from './SectionValidity';
+const mockInputs = {
+    options: {
+        1: [true],
+        2: [true],
+        3: [true],
+        1032: [true],
+    },
+    variables: {},
+};
+const mockReferences = {
+    sections: {
+        main: {
+            1: {
+                id: 1,
+                label: 'Section 1 - Valid Section',
+                options: [1],
+            },
+            2: {
+                id: 2,
+                label: 'Section 2 - Unvalid Section',
+                options: [2],
+            },
+            3: {
+                id: 3,
+                label: 'Section 3 - Has inexistant child',
+                options: [1032],
+            },
+        },
+    },
+    options: {
+        1: {
+            meta: {
+                type: 'checkbox',
+                id: 1,
+                label: 'Option 1',
+                step: '*',
+            },
+            options: [],
+            variables: [1],
+        },
+        2: {
+            meta: {
+                type: 'checkbox',
+                id: 2,
+                label: 'Option 2',
+                step: '*',
+            },
+            options: [3],
+            variables: [2],
+        },
+        3: {
+            meta: {
+                type: 'checkbox',
+                id: 3,
+                label: 'Option 3',
+                step: '*',
+            },
+            options: [],
+            variables: [],
+        },
+    },
+};
+const mockConditions = {
+    options: {
+        1: [true],
+        2: [true],
+        3: [true],
+    },
+    variables: {
+        1: [true],
+        2: [true],
+    },
+    validators: {
+        options: {
+            1: [true],
+            2: [true],
+            3: [false],
+        },
+        variables: {
+            1: [true],
+            2: [false],
+        },
+    },
+};
+jest.mock('../redux/selectors/inputs', () => ({
+    __esModule: true,
+    selectOptionInput: (id) => mockInputs.options[id],
+    selectOptionInputByIndex: (id, index) => mockInputs.options[id][index],
+}));
+jest.mock('../redux/selectors/references', () => ({
+    __esModule: true,
+    selectSectionReference: (id) => mockReferences.sections.main[id],
+    selectOptionReference: (id) => mockReferences.options[id],
+}));
+jest.mock('../redux/selectors/conditions', () => ({
+    __esModule: true,
+    selectOptionConditionValue: (id, index) => mockConditions.options[id][index],
+    selectOptionValidatorConditionValue: (id, index) => mockConditions.validators.options[id][index],
+    selectVariableConditionValue: (id, index) => mockConditions.variables[id][index],
+    selectVariableValidatorConditionValue: (id, index) => mockConditions.validators.variables[id][index],
+}));
+describe('SectionValidity library test suit', () => {
+    it('Checks valid section', () => {
+        expect(new SectionValidity(1).validity).toBeTruthy();
+    });
+    it('Checks unvalid section', () => {
+        expect(new SectionValidity(2).validity).toBeFalsy();
+    });
+    it('Should throw an error if option reference does not exist', () => {
+        expect(() => new SectionValidity(3).validity).toThrowError('Option 1032 does not exist');
+    });
+    it('Should throw an error if section does not exist', () => {
+        expect(() => new SectionValidity(4).validity).toThrowError('Section 4 does not exist');
+    });
+});

package/dist/libs/SmartScriptStore.d.ts

@@ -0,0 +1,38 @@
+import { Action } from 'redux';
+import { ActionsType } from '../types/Actions.type';
+import { StateType } from '../types/State.type';
+export declare type CallbackType = () => void;
+export declare class SmartScriptStore {
+    static hooks: {
+        variables: Record<string, CallbackType[]>;
+        options: Record<string, CallbackType[]>;
+        init?: CallbackType[];
+        load?: CallbackType[];
+    };
+    static actionsQueue: Action[];
+    static inputs: StateType.Inputs;
+    static grabActions(): Action<any>[];
+    static get triggers(): {
+        options: number[];
+        variables: number[];
+    };
+    static getOptionInput(id: number, index?: number): boolean;
+    static getOptionAllInput(id: number): boolean[];
+    static getVariableInput(id: number, index?: number): string | number;
+    static getVariableAllInput(id: number): (string | number)[];
+    static onChange(inputType: 'option' | 'variable', id: number | number[], callback: CallbackType): void;
+    static onInit(callback: CallbackType): void;
+    static execOnInit(): void;
+    static onLoad(callback: CallbackType): void;
+    static execOnLoad(): void;
+    static onOptionChange(id: number | number[], callback: CallbackType): void;
+    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']) => void;
+    static updateOptionMeta: (id: number, _meta: ActionsType.References.updateOptionMeta['meta']) => void;
+    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;
+}