@legalplace/wizardx-core 0.0.1-alpha.0

package/dist/redux/selectors/app.test.js

@@ -0,0 +1,99 @@
+import { createAppStore, getStore } from '../store';
+import { initPaginationAction, initMetaAction, initInstanceAction, } from '../actions/app';
+import { selectCurrentPage, selectCurrentSectionId, selectAvailableSections, selectPermalink, selectDocumentId, selectDocumentTitle, selectInstanceUniqid, selectInstanceIsPaid, } from './app';
+createAppStore('memory');
+const store = getStore();
+describe('App selectors test suit', () => {
+    it('Returns current page correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 1,
+            currentPage: 13,
+            greatestPage: 1,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectCurrentPage();
+        expect(selector).toBe(13);
+    });
+    it('Returns current section id correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 32,
+            currentPage: 13,
+            greatestPage: 13,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectCurrentSectionId();
+        expect(selector).toBe(32);
+    });
+    it('Returns available sections correctly', () => {
+        store.dispatch(initPaginationAction({
+            currentSectionId: 32,
+            currentPage: 13,
+            greatestPage: 13,
+            availableSections: [1, 2, 3],
+            availableAppStates: ['wizard'],
+            currentAppState: 'wizard',
+        }));
+        const selector = selectAvailableSections();
+        expect(selector).toEqual([1, 2, 3]);
+    });
+    it('Returns permalink correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectPermalink();
+        expect(selector).toBe('some-permalink');
+    });
+    it('Returns document id correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectDocumentId();
+        expect(selector).toBe(123);
+    });
+    it('Returns document title correctly', () => {
+        store.dispatch(initMetaAction({
+            permalink: 'some-permalink',
+            title: 'Some title',
+            prefix: '',
+            id: 123,
+            modelVersion: 1,
+            productType: 'demarche',
+        }));
+        const selector = selectDocumentTitle();
+        expect(selector).toBe('Some title');
+    });
+    it('Returns instance uniqid correctly', () => {
+        store.dispatch(initInstanceAction({
+            dataStatus: 'saved',
+            uniqid: 'SomeUNiqID',
+            isPaid: false,
+            steps: '*',
+        }));
+        const selector = selectInstanceUniqid();
+        expect(selector).toBe('SomeUNiqID');
+    });
+    it('Returns instance isPaid correctly', () => {
+        store.dispatch(initInstanceAction({
+            dataStatus: 'saved',
+            uniqid: 'SomeUNiqID',
+            isPaid: true,
+            steps: '*',
+        }));
+        const selector = selectInstanceIsPaid();
+        expect(selector).toBeTruthy();
+    });
+});

package/dist/redux/selectors/conditions.d.ts

@@ -0,0 +1,14 @@
+export declare function selectOptionConditionValue(id: number): Readonly<boolean[] | undefined>;
+export declare function selectOptionConditionValue(id: number, index: number): Readonly<boolean | undefined>;
+export declare function selectVariableConditionValue(id: number): boolean[] | undefined;
+export declare function selectVariableConditionValue(id: number, index: number): boolean | undefined;
+export declare const selectSectionConditionValue: (id: number, document?: any) => Readonly<boolean | undefined>;
+export declare const selectDocumentConditionValue: (name: string) => Readonly<boolean | undefined>;
+export declare function selectPrefillerConditionValue(id: number): boolean[][] | undefined;
+export declare function selectPrefillerConditionValue(id: number, index: number): boolean[] | undefined;
+export declare function selectOptionValidatorConditionValue(id: number): boolean[] | undefined;
+export declare function selectOptionValidatorConditionValue(id: number, index: number): boolean | undefined;
+export declare function selectVariableValidatorConditionValue(id: number): boolean[] | undefined;
+export declare function selectVariableValidatorConditionValue(id: number, index: number): boolean | undefined;
+export declare const selectIsOptionDisplayed: (id: number, index: number) => Readonly<boolean>;
+export declare const selectIsVariableDisplayed: (id: number, index: number) => Readonly<boolean>;

package/dist/redux/selectors/conditions.js

@@ -0,0 +1,140 @@
+import { createSelector } from './selectors';
+import { selectVariableParents, selectOptionParents, selectVariableParentSection, selectOptionParentSection, } from './references';
+import { selectOptionInputByIndex } from './inputs';
+const optionConditionValueSelector = createSelector((state, id, index) => {
+    if (typeof state.conditions.options[id] === 'undefined')
+        return undefined;
+    return typeof index === 'number'
+        ? state.conditions.options[id][index]
+        : state.conditions.options[id];
+}, (state, id, index) => {
+    if (typeof state.conditions.options[id] === 'undefined')
+        return Math.random();
+    return `${state.conditions.options[id].reduce((p, c) => p + (c ? '1' : '0'), '')}_${id}_${index}`;
+});
+export function selectOptionConditionValue(id, index) {
+    if (typeof index === 'number')
+        return optionConditionValueSelector(id, index);
+    return optionConditionValueSelector(id);
+}
+const variableConditionValueSelector = createSelector((state, id, index) => {
+    if (typeof state.conditions.variables[id] === 'undefined')
+        return undefined;
+    return typeof index === 'number'
+        ? state.conditions.variables[id][index]
+        : state.conditions.variables[id];
+}, (state, id, index) => {
+    if (typeof state.conditions.variables[id] === 'undefined')
+        return Math.random();
+    return `${state.conditions.variables[id].reduce((p, c) => p + (c ? '1' : '0'), '')}_${id}_${index}`;
+});
+export function selectVariableConditionValue(id, index) {
+    if (typeof index === 'number')
+        return variableConditionValueSelector(id, index);
+    return variableConditionValueSelector(id);
+}
+export const selectSectionConditionValue = createSelector((state, id, document = 'main') => {
+    if (state.conditions.sections[document] === undefined)
+        return undefined;
+    return state.conditions.sections[document][id];
+}, (state, id, document = 'main') => {
+    const key = state.conditions.sections[document][id] ? `1_${id}` : `0_${id}`;
+    return document + key;
+});
+export const selectDocumentConditionValue = createSelector((state, name) => {
+    if (typeof state.conditions.documents[name] === 'undefined')
+        return undefined;
+    return state.conditions.documents[name];
+}, (state, name) => {
+    if (typeof state.conditions.documents[name] === 'undefined')
+        return Math.random().toString();
+    return state.conditions.documents[name] ? 'true' : 'false';
+});
+const prefillerConditionValueSelector = createSelector((state, id, index) => {
+    if (state.conditions.prefillers === undefined)
+        return undefined;
+    if (state.conditions.prefillers[id] === undefined)
+        return undefined;
+    return typeof index === 'number'
+        ? state.conditions.prefillers[id][index]
+        : state.conditions.prefillers[id];
+}, (state, id, index) => {
+    const prefillers = state.conditions.prefillers[id].map((v) => v.reduce((p, c) => p + (c ? '1' : '0'), ''));
+    return `${prefillers.reduce((p, c) => p + c, '')}_${id}_${index}`;
+});
+export function selectPrefillerConditionValue(id, index) {
+    if (typeof index === 'number')
+        return prefillerConditionValueSelector(id, index);
+    return prefillerConditionValueSelector(id);
+}
+const optionValidatorConditionValueSelector = createSelector((state, id, index) => {
+    if (typeof state.conditions.validators.options[id] === 'undefined')
+        return undefined;
+    if (typeof index === 'number' &&
+        typeof state.conditions.validators.options[id][index] === 'undefined')
+        return undefined;
+    return typeof index === 'number'
+        ? state.conditions.validators.options[id][index]
+        : state.conditions.validators.options[id];
+}, (state, id, index) => {
+    if (typeof state.conditions.validators.options[id] === 'undefined')
+        return Math.random();
+    return `${state.conditions.validators.options[id].reduce((p, c) => p + (c ? '1' : '0'), '')}-${id.toString()}${index ? index.toString() : ''}`;
+});
+export function selectOptionValidatorConditionValue(id, index) {
+    if (typeof index === 'number')
+        return optionValidatorConditionValueSelector(id, index);
+    return optionValidatorConditionValueSelector(id);
+}
+const variableValidatorConditionValueSelector = createSelector((state, id, index) => {
+    if (typeof state.conditions.validators.variables[id] === 'undefined')
+        return undefined;
+    return typeof index === 'number'
+        ? state.conditions.validators.variables[id][index]
+        : state.conditions.validators.variables[id];
+}, (state, id, index) => {
+    if (typeof state.conditions.validators.variables[id] === 'undefined')
+        return Math.random();
+    return `${state.conditions.validators.variables[id].reduce((p, c) => p + (c ? '1' : '0'), '')}-${id.toString()}${index ? index.toString() : ''}`;
+});
+export function selectVariableValidatorConditionValue(id, index) {
+    if (typeof index === 'number')
+        return variableValidatorConditionValueSelector(id, index);
+    return variableValidatorConditionValueSelector(id);
+}
+export const selectIsOptionDisplayed = createSelector((state, id, index) => {
+    const optionCondition = selectOptionConditionValue(id, index) !== false;
+    const optionParents = selectOptionParents(id);
+    const parentsConditions = optionParents.map((optionId) => {
+        return selectOptionConditionValue(optionId, index) !== false;
+    });
+    const parentsInputs = optionParents.map((optionId) => {
+        return selectOptionInputByIndex(optionId, index);
+    });
+    const parentSectionId = selectOptionParentSection(id);
+    const parentSectionCondition = selectSectionConditionValue(parentSectionId) !== false;
+    return ([
+        optionCondition,
+        parentSectionCondition,
+        ...parentsConditions,
+        ...parentsInputs,
+    ].filter((c) => c !== true).length === 0);
+}, () => Math.random());
+export const selectIsVariableDisplayed = createSelector((state, id, index) => {
+    const variableCondition = selectVariableConditionValue(id, index) !== false;
+    const variableParents = selectVariableParents(id);
+    const parentsConditions = variableParents.map((optionId) => {
+        return selectOptionConditionValue(optionId, index) !== false;
+    });
+    const parentsInputs = variableParents.map((optionId) => {
+        return selectOptionInputByIndex(optionId, index);
+    });
+    const parentSectionId = selectVariableParentSection(id);
+    const parentSectionCondition = selectSectionConditionValue(parentSectionId) !== false;
+    return ([
+        variableCondition,
+        parentSectionCondition,
+        ...parentsConditions,
+        ...parentsInputs,
+    ].filter((c) => c !== true).length === 0);
+}, () => Math.random());

package/dist/redux/selectors/conditions.test.d.ts

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

package/dist/redux/selectors/conditions.test.js

@@ -0,0 +1,70 @@
+import { createAppStore, getStore } from '../store';
+import { initConditionsAction } from '../actions/conditions';
+import { selectOptionConditionValue, selectVariableConditionValue, selectSectionConditionValue, selectPrefillerConditionValue, selectOptionValidatorConditionValue, selectVariableValidatorConditionValue, } from './conditions';
+createAppStore('memory');
+const store = getStore();
+store.dispatch(initConditionsAction({
+    options: {
+        34: [false, true],
+    },
+    variables: {
+        33: [false, true],
+    },
+    prefillers: {
+        53: [[false], [true]],
+    },
+    sections: {
+        main: {
+            31: false,
+        },
+    },
+    documents: {
+        main: true,
+    },
+    validators: {
+        options: {
+            234: [false],
+        },
+        variables: {
+            124: [true],
+        },
+    },
+}));
+describe('Conditions selectors test suit', () => {
+    it('Selects option conditions correctly (all occurencies)', () => {
+        const condition = selectOptionConditionValue(34);
+        expect(condition).toEqual([false, true]);
+    });
+    it('Selects option conditions correctly (specific occurency)', () => {
+        const condition = selectOptionConditionValue(34, 1);
+        expect(condition).toBeTruthy();
+    });
+    it('Selects variable conditions correctly (all occurencies)', () => {
+        const condition = selectVariableConditionValue(33);
+        expect(condition).toEqual([false, true]);
+    });
+    it('Selects variable conditions correctly (specific occurency)', () => {
+        const condition = selectVariableConditionValue(33, 1);
+        expect(condition).toBeTruthy();
+    });
+    it('Selects section conditions correctly ', () => {
+        const condition = selectSectionConditionValue(31);
+        expect(condition).toBeFalsy();
+    });
+    it('Selects prefiller conditions correctly (all occurencies)', () => {
+        const condition = selectPrefillerConditionValue(53);
+        expect(condition).toEqual([[false], [true]]);
+    });
+    it('Selects prefiller conditions correctly (specific occurency)', () => {
+        const condition = selectPrefillerConditionValue(53, 1);
+        expect(condition).toEqual([true]);
+    });
+    it('Selects option validator conditions correctly', () => {
+        const condition = selectOptionValidatorConditionValue(234);
+        expect(condition).toEqual([false]);
+    });
+    it('Selects variable validator conditions correctly', () => {
+        const condition = selectVariableValidatorConditionValue(124);
+        expect(condition).toEqual([true]);
+    });
+});

package/dist/redux/selectors/index.d.ts

@@ -0,0 +1,7 @@
+export * from './app';
+export * from './conditions';
+export * from './inputs';
+export * from './mandatories';
+export * from './references';
+export * from './smartscript';
+export * from './user';

package/dist/redux/selectors/index.js

@@ -0,0 +1,7 @@
+export * from './app';
+export * from './conditions';
+export * from './inputs';
+export * from './mandatories';
+export * from './references';
+export * from './smartscript';
+export * from './user';

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

@@ -0,0 +1,7 @@
+import { StateType } from '../../types/State.type';
+export declare type selectInputsType = () => StateType.Inputs;
+export declare const selectInputs: selectInputsType;
+export declare const selectOptionInput: (id: number) => readonly boolean[];
+export declare const selectOptionInputByIndex: (id: number, index: number) => Readonly<boolean | undefined>;
+export declare const selectVariableInput: (id: number) => readonly (string | number)[];
+export declare const selectVariableInputByIndex: (id: number, index: number) => Readonly<string | number>;

package/dist/redux/selectors/inputs.js

@@ -0,0 +1,20 @@
+import { createSelector } from './selectors';
+export const selectInputs = createSelector((state) => state.inputs, () => Math.random());
+export const selectOptionInput = createSelector((state, id) => state.inputs.options[id], (state, id) => `${state.inputs.options[id].reduce((p, c) => p + (c ? '1' : '0'), '')}_${id.toString()}`);
+export const selectOptionInputByIndex = createSelector((state, id, index) => {
+    if (state.inputs.options[id] === undefined)
+        return undefined;
+    return state.inputs.options[id][index];
+}, (state, id, index) => state.inputs.options[id] !== undefined
+    ? `${state.inputs.options[id].reduce((p, c) => p + (c ? '1' : '0'), '')}_${id.toString()}_${index}`
+    : Math.random());
+export const selectVariableInput = createSelector((state, id) => {
+    if (typeof state.inputs.variables[id] === 'undefined')
+        return [''];
+    return state.inputs.variables[id];
+}, (state, id) => {
+    if (typeof state.inputs.variables[id] === 'undefined')
+        return Math.random();
+    return `${state.inputs.variables[id].reduce((p, c) => `${p}-${c}`, '')}_${id.toString()}`;
+});
+export const selectVariableInputByIndex = createSelector((state, id, index) => state.inputs.variables[id][index], (state, id, index) => `${state.inputs.variables[id].reduce((p, c) => `${p}-${c}`, '')}_${id.toString()}_${index}`);

package/dist/redux/selectors/inputs.test.d.ts

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

package/dist/redux/selectors/inputs.test.js

@@ -0,0 +1,44 @@
+import { createAppStore, getStore } from '../store';
+import { selectOptionInput, selectVariableInput, selectVariableInputByIndex, selectOptionInputByIndex, selectInputs, } from './inputs';
+import { initOptionAction, initVariableAction } from '../actions/inputs';
+createAppStore('memory');
+const store = getStore();
+describe('Inputs selectors test suit', () => {
+    it('Returns Inputs Object properly', () => {
+        store.dispatch(initOptionAction(4, [false, true]));
+        store.dispatch(initOptionAction(5, [true]));
+        store.dispatch(initVariableAction(51, ['Ok', 'Hello']));
+        expect(selectInputs()).toEqual({
+            options: {
+                4: [false, true],
+                5: [true],
+            },
+            variables: {
+                51: ['Ok', 'Hello'],
+            },
+        });
+    });
+    it('Returns current option input (all occurencies)', () => {
+        store.dispatch(initOptionAction(4, [false, true]));
+        const selector = selectOptionInput(4);
+        expect(selector).toEqual([false, true]);
+    });
+    it('Returns current option input (one occurency)', () => {
+        store.dispatch(initOptionAction(4, [false, true]));
+        const selector = selectOptionInputByIndex(4, 1);
+        expect(selector).toBeTruthy();
+    });
+    it('Returns undefined if option does not exist (one occurency)', () => {
+        expect(selectOptionInputByIndex(44, 1)).toBeUndefined();
+    });
+    it('Returns current variable input (all occurencies)', () => {
+        store.dispatch(initVariableAction(4, ['Hello', 'World']));
+        const selector = selectVariableInput(4);
+        expect(selector).toEqual(['Hello', 'World']);
+    });
+    it('Returns current variable input (one occurency)', () => {
+        store.dispatch(initVariableAction(4, ['Hello', 'World']));
+        const selector = selectVariableInputByIndex(4, 1);
+        expect(selector).toBe('World');
+    });
+});

package/dist/redux/selectors/mandatories.d.ts

@@ -0,0 +1,8 @@
+export declare const selectMandatoryIgnore: () => Readonly<boolean>;
+export declare const selectMandatorySection: (id: number) => Readonly<boolean>;
+export declare const selectFirstUnfinishedSectionId: (id: number) => number;
+export declare const selectMandatoryOptionItem: (id: number) => readonly boolean[];
+export declare const selectMandatoryOption: (id: number) => readonly boolean[];
+export declare const selectMandatoryOptionByIndex: (id: number, index: number) => Readonly<boolean>;
+export declare const selectMandatoryVariable: (id: number) => readonly boolean[];
+export declare const selectMandatoryVariableByIndex: (id: number, index: number) => Readonly<boolean>;

package/dist/redux/selectors/mandatories.js

@@ -0,0 +1,26 @@
+import { createSelector } from './selectors';
+export const selectMandatoryIgnore = createSelector((state) => state.mandatories.ignore, (state) => (state.mandatories.ignore ? '1' : '0'));
+export const selectMandatorySection = createSelector((state, id) => state.mandatories.sections[id] === true, (state, id) => `${id}:${state.mandatories.sections[id] ? '1' : '0'}`);
+export const selectFirstUnfinishedSectionId = createSelector((state, id) => {
+    const sectionIds = Object.keys(state.mandatories.sections);
+    if (!sectionIds || !sectionIds.length)
+        return id;
+    const extractedSectionIds = sectionIds.slice(0, sectionIds.indexOf(`${id}`) + 1);
+    const firstUnfinishedSectionId = extractedSectionIds.find((sectionId) => state.mandatories.sections[sectionId] === false) || `${id}`;
+    return parseInt(firstUnfinishedSectionId, 10);
+});
+export const selectMandatoryOptionItem = createSelector((state, id) => state.mandatories.options[id], (state, id) => (state.mandatories.options[id] ? '1' : '0'));
+export const selectMandatoryOption = createSelector((state, id) => state.mandatories.options[id].map((c) => c && true), (state, id) => `${id}:${state.mandatories.options[id]
+    .map((c) => (c ? '1' : '0'))
+    .join('-')}`);
+export const selectMandatoryOptionByIndex = createSelector((state, id, index) => { var _a; return ((_a = state.mandatories.options[id]) === null || _a === void 0 ? void 0 : _a[index]) === true; }, (state, id, index) => {
+    var _a;
+    return `${id}-${index}:${((_a = state.mandatories.options[id]) === null || _a === void 0 ? void 0 : _a[index]) === true ? '1' : '0'}`;
+});
+export const selectMandatoryVariable = createSelector((state, id) => state.mandatories.variables[id].map((c) => c && true), (state, id) => `${id}:${state.mandatories.variables[id]
+    .map((c) => (c ? '1' : '0'))
+    .join('-')}`);
+export const selectMandatoryVariableByIndex = createSelector((state, id, index) => { var _a; return ((_a = state.mandatories.variables[id]) === null || _a === void 0 ? void 0 : _a[index]) === true; }, (state, id, index) => {
+    var _a;
+    return `${id}-${index}:${((_a = state.mandatories.variables[id]) === null || _a === void 0 ? void 0 : _a[index]) === true ? '1' : '0'}`;
+});

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

@@ -0,0 +1,29 @@
+export declare const selectOutputReference: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSingleOutputType | undefined>;
+export declare const selectBoxReference: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSingleBoxType>;
+export declare const isOptionMultiple: (id: number) => Readonly<boolean | undefined>;
+export declare const selectOptionReference: (id: number) => Readonly<import("@legalplace/models-v3-types").OptionV3>;
+export declare const selectOptionRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsOptionsType>;
+export declare const selectSectionRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsSectionsType>;
+export declare const selectOptionParents: (id: number) => readonly number[];
+export declare const selectRadioSiblings: (id: number) => Readonly<number[] | undefined>;
+export declare const selectVariableReference: (id: number, noThrow?: any) => Readonly<import("@legalplace/models-v3-types").VariableV3>;
+export declare const selectVariableRelations: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesRelationsVariablesType>;
+export declare const selectVariableParents: (id: number) => readonly number[];
+export declare const selectAllDocumentsReferences: () => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDocumentsListType>;
+export declare const selectDocumentReference: (document: string) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDocumentType>;
+export declare const selectAllSectionsReferences: (document?: any) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesSectionsDocumentType | undefined>;
+export declare const selectSectionReference: (id: number, document?: any) => Readonly<import("@legalplace/models-v3-types").SectionV3>;
+export declare const selectSectionDefaults: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").ReferencesDefaultsOptionType | undefined>;
+export declare const selectOptionConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+export declare const selectVariableConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+export declare const selectDocumentConditionsObject: (name: string) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+export declare const selectSectionConditionsObject: (id: number, document?: any) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS>;
+export declare const selectPrefillerConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS[] | undefined>;
+export declare const selectOptionValidatorConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+export declare const selectVariableValidatorConditionsObject: (id: number) => Readonly<import("@legalplace/referencesparser/dist/libs/References.type").MAPPED_CONDITIONS | undefined>;
+export declare const areVariablesSiblings: (...args: number[]) => Readonly<boolean | undefined>;
+export declare const selectVariablesByTag: (tag: string) => readonly number[];
+export declare const selectOptionsByTag: (tag: string) => readonly number[];
+export declare const selectOptionParentSection: (id: number) => number;
+export declare const selectVariableParentSection: (id: number) => number;
+export declare const selectUserEmailSectionVariableIds: (sectionId: number) => readonly string[];