@piserve-tech/form-submission 1.3.317 → 1.3.319

package/question/confirm-dialog/confirm-dialog.component.d.ts

@@ -0,0 +1,12 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import * as i0 from "@angular/core";
+export declare class ConfirmDialogComponent {
+    data: any;
+    dialogRef: MatDialogRef<ConfirmDialogComponent>;
+    constructor(data: any, dialogRef: MatDialogRef<ConfirmDialogComponent>);
+    message: string;
+    messageHeader: string;
+    closeModal(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ConfirmDialogComponent, "lib-confirm-dialog", never, {}, {}, never, never, false, never>;
+}

package/question/form-elements/form-elements.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FormElementsComponent {
+    private injectedGrid;
+    private injectedState;
+    private injectedAnswer;
+    currentPageIndex: number;
+    edit: boolean;
+    acceptedLanguage: string;
+    subFormChange: EventEmitter<any>;
+    answer: string;
+    grid: any;
+    state: string;
+    pages: any[];
+    constructor(injectedGrid: any, injectedState: string, injectedAnswer: string);
+    ngOnInit(): void;
+    updateSubFormWithSubmissions(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormElementsComponent, [{ optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormElementsComponent, "lib-form-elements", never, { "currentPageIndex": { "alias": "currentPageIndex"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; "answer": { "alias": "answer"; "required": false; }; "grid": { "alias": "grid"; "required": false; }; "state": { "alias": "state"; "required": false; }; "pages": { "alias": "pages"; "required": false; }; }, { "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/question/inline-multiple-subform/inline-multiple-subform.component.d.ts

@@ -0,0 +1,47 @@
+import { EventEmitter } from '@angular/core';
+import { ScoreCalculationService } from '../../services/score.service';
+import { Submission } from '../../models/submission.model';
+import { DataService } from '../../services/data.service';
+import { WhenClauseService } from '../../services/whenClause.service';
+import * as i0 from "@angular/core";
+export declare class InlineMultipleSubformComponent {
+    private scoreCalcService;
+    private dataService;
+    whenClauseService: WhenClauseService;
+    subForm: any;
+    subFormChange: EventEmitter<any>;
+    acceptedLanguage: string;
+    maxPossibleScore: number;
+    maxPossibleGoodScore: number;
+    maxPossibleBadScore: number;
+    submissions: Submission[];
+    deletedSubmissions: string[];
+    displayedColumns: string[];
+    addButtonLabel: string;
+    user: string;
+    elementsWithWhenClause: any;
+    editableQuestions: string[];
+    constructor(scoreCalcService: ScoreCalculationService, dataService: DataService, whenClauseService: WhenClauseService);
+    ngOnInit(): void;
+    updateWhenClause(): void;
+    initializeDisplayedColumns(): void;
+    populateHiddenFieldAnswers(): void;
+    findQuestionById(rows: any[], questionId: string): any;
+    resolveHiddenFieldValue(hiddenField: {
+        value: string | null;
+        valueSource: string | null;
+        key: string | null;
+    }): any;
+    private resolvePredefinedVariable;
+    addNewSubmission(): void;
+    isSubmissionEditable(submission: any, questionId: string): boolean;
+    updateSubFormWithSubmissions(): void;
+    getSubmissionQuestion(submission: Submission, formElement: any): any;
+    updateInlineAnswer(submission: Submission, question: any, newAnswerObject: any): void;
+    updateDeletedFiles(submission: Submission, question: any, deletedFiles: string[]): void;
+    deleteSubmission(index: number): void;
+    clearEmptySubmissions(): void;
+    clearHiddenAnswers(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineMultipleSubformComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineMultipleSubformComponent, "lib-inline-multiple-subform", never, { "subForm": { "alias": "subForm"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; }, { "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/question/multifields/multifields.component.d.ts

@@ -0,0 +1,11 @@
+import { Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class MultifieldsComponent {
+    multiFields: any;
+    acceptedLanguage: string;
+    grid: any;
+    loadFormElementsComponent(grid: any): Promise<typeof import("../form-elements/form-elements.component").FormElementsComponent>;
+    createInjector(): Injector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultifieldsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultifieldsComponent, "lib-multifields", never, { "multiFields": { "alias": "multiFields"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; }, {}, never, never, false, never>;
+}

package/question/multiple-subform/multiple-subform.component.d.ts

@@ -0,0 +1,39 @@
+import { EventEmitter } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { DomSanitizer } from '@angular/platform-browser';
+import { ScoreCalculationService } from '../../services/score.service';
+import { Submission } from '../../models/submission.model';
+import { Answer } from '../../models/answer.model';
+import { WhenClauseService } from '../../services/whenClause.service';
+import * as i0 from "@angular/core";
+export declare class MultipleSubformComponent {
+    dialog: MatDialog;
+    private sanitizer;
+    private scoreCalcService;
+    private whenClauseService;
+    subForm: any;
+    subFormChange: EventEmitter<any>;
+    acceptedLanguage: string;
+    submissions: Submission[];
+    deletedSubmissions: string[];
+    displayedColumns: string[];
+    addButtonLabel: string;
+    maxPossibleGoodScore: number;
+    maxPossibleBadScore: number;
+    constructor(dialog: MatDialog, sanitizer: DomSanitizer, scoreCalcService: ScoreCalculationService, whenClauseService: WhenClauseService);
+    ngOnInit(): void;
+    initializeDisplayedColumns(): void;
+    getAnswerByQuestionId(submission: Submission, question: any): Answer | null;
+    fetchCurrencySymbol(question: any): string;
+    subFormSubmission(subForm: any): void;
+    editSubFormSubmission(index: number, submission: Submission): void;
+    bindAnswers(subForm: any, submission: Submission): any;
+    deleteSubForm(index: number): void;
+    addNewSubmission(): void;
+    cleanCircularReferences(obj: any, seen?: WeakSet<object>): any;
+    updateSubmission(result: any, index: number): void;
+    updateSubFormWithSubmissions(): void;
+    clearEmptyRows(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MultipleSubformComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MultipleSubformComponent, "lib-multiple-subform", never, { "subForm": { "alias": "subForm"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; }, { "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/question/question/question.component.d.ts

@@ -0,0 +1,30 @@
+import { ChangeDetectorRef, EventEmitter, Injector } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class QuestionComponent {
+    private cdr;
+    question: any;
+    edit: boolean;
+    acceptedLanguage: string;
+    currentPageIndex: number;
+    emitValidations: EventEmitter<any>;
+    subFormChange: EventEmitter<any>;
+    validations: any;
+    componentToLoad: any;
+    injector: Injector;
+    childLogicCache: {
+        [key: string]: {
+            component: Promise<any>;
+            injector: Injector;
+        };
+    };
+    constructor(cdr: ChangeDetectorRef);
+    ngOnInit(): void;
+    removeCircularReferences(obj: any): any;
+    private loadComponent;
+    private loadFormElementsComponent;
+    createInjector(): Injector;
+    updateSubFormWithSubmissions(event: any): void;
+    handleValidation(validation: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuestionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuestionComponent, "lib-question", never, { "question": { "alias": "question"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; "currentPageIndex": { "alias": "currentPageIndex"; "required": false; }; }, { "emitValidations": "emitValidations"; "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/question/question-group/question-group.component.d.ts

@@ -0,0 +1,29 @@
+import { Injector } from '@angular/core';
+import { WhenClauseService } from '../../services/whenClause.service';
+import * as i0 from "@angular/core";
+export declare class QuestionGroupComponent {
+    private whenClauseService;
+    questionGroup: any;
+    edit: boolean;
+    acceptedLanguage: string;
+    decodedDescription: string;
+    grid: any;
+    childLogicCache: {
+        [key: string]: {
+            component: Promise<any>;
+            injector: Injector;
+        };
+    };
+    componentToLoad: any;
+    injector: Injector;
+    constructor(whenClauseService: WhenClauseService);
+    ngOnInit(): void;
+    decodeHtml(html: string): string;
+    ngOnChanges(): void;
+    removeCircularReferences(obj: any): any;
+    private loadComponent;
+    private loadFormElementsComponent;
+    createInjector(): Injector;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuestionGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<QuestionGroupComponent, "lib-question-group", never, { "questionGroup": { "alias": "questionGroup"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; }, {}, never, never, false, never>;
+}

package/question/recursive-logic/recursive-logic.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '@angular/core';
+import { WhenClauseService } from '../../services/whenClause.service';
+import * as i0 from "@angular/core";
+export declare class RecursiveLogicComponent {
+    private whenClauseService;
+    grid: any;
+    currentPageIndex: number;
+    edit: boolean;
+    acceptedLanguage: string;
+    subFormChange: EventEmitter<any>;
+    state: string;
+    answer: string;
+    pages: any[];
+    constructor(whenClauseService: WhenClauseService);
+    ngOnInit(): void;
+    updateSubFormWithSubmissions(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecursiveLogicComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RecursiveLogicComponent, "lib-recursive-logic", never, { "grid": { "alias": "grid"; "required": false; }; "currentPageIndex": { "alias": "currentPageIndex"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; "state": { "alias": "state"; "required": false; }; "answer": { "alias": "answer"; "required": false; }; "pages": { "alias": "pages"; "required": false; }; }, { "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/question/sub-form/sub-form.component.d.ts

@@ -0,0 +1,70 @@
+import { EventEmitter, Injector, OnInit } from '@angular/core';
+import { SubformCopyService } from '../../services/subform-copy.service';
+import { MatDialog } from '@angular/material/dialog';
+import { Submission } from '../../models/submission.model';
+import { DataService } from '../../services/data.service';
+import { FormService } from '../../services/form.service';
+import { WhenClauseService } from '../../services/whenClause.service';
+import { ValidationService } from '../../services/validation.service';
+import { ScoreCalculationService } from '../../services/score.service';
+import * as i0 from "@angular/core";
+export declare class SubFormComponent implements OnInit {
+    private subformCopyService;
+    dialog: MatDialog;
+    private dataService;
+    private formService;
+    private whenClauseService;
+    private validationService;
+    private scoreCalcService;
+    subForm: any;
+    edit: boolean;
+    subFormChange: EventEmitter<any>;
+    acceptedLanguage: string;
+    pages: any[];
+    decodedDescription: string;
+    grid: any;
+    state: string;
+    childLogicCache: {
+        [key: string]: {
+            component: Promise<any>;
+            injector: Injector;
+        };
+    };
+    componentToLoad: any;
+    injector: Injector;
+    copySubFormdata: any;
+    subformDescription: string;
+    subformTitle: string;
+    editor: any;
+    allowCopy: boolean;
+    allowDelete: boolean;
+    private dialogRef?;
+    subformData: any;
+    previousSubmissions: any[];
+    maxPossibleGoodScore: number;
+    maxPossibleBadScore: number;
+    constructor(subformCopyService: SubformCopyService, dialog: MatDialog, dataService: DataService, formService: FormService, whenClauseService: WhenClauseService, validationService: ValidationService, scoreCalcService: ScoreCalculationService);
+    private tryLoadPreviousSubmissions;
+    loadPreviousSubmissions(): void;
+    ngOnInit(): void;
+    editorCreated(editorInstance: any): void;
+    private loadComponent;
+    private loadFormElementsComponent;
+    createInjector(): Injector;
+    decodeHtml(html: string): string;
+    bindAnswersToFormElements(): void;
+    updateSubFormWithSubmissions(event: any): void;
+    ngOnChanges(): void;
+    copySubform(): void;
+    updateSubformData(event: any, subformId: string, field: 'title' | 'description'): void;
+    deleteCopySubform(subformId: string): void;
+    deleteMainSubform(subformId: string): void;
+    createSubmissionsFromApi(apiSubmissions: any[], subform: any): Submission[];
+    get isInvalid(): boolean;
+    get errorMessage(): string | null;
+    clearInvalid(): void;
+    onAnyClick(event: MouseEvent): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubFormComponent, "lib-sub-form", never, { "subForm": { "alias": "subForm"; "required": false; }; "edit": { "alias": "edit"; "required": false; }; "acceptedLanguage": { "alias": "acceptedLanguage"; "required": false; }; "pages": { "alias": "pages"; "required": false; }; }, { "subFormChange": "subFormChange"; }, never, never, false, never>;
+}

package/services/aggregate.service.d.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AggregationFunctionService {
+    private aggregateFieldsMap;
+    private numberFieldsMap;
+    private aggregateFieldResultsSubject;
+    aggregateFieldResults$: Observable<{
+        id: string;
+        result: number;
+        evaluated: boolean;
+    } | null>;
+    constructor();
+    /**
+     * Store or update an aggregate field in the map
+     */
+    setAggregateField(rowId: string, fieldId: string, operation: string, formula: string): void;
+    /**
+     * Store or update a number field in the map
+     */
+    setNumberField(rowId: string, fieldId: string, answer: number): void;
+    private emitAggregateResult;
+    evaluateCustomFormula(rowId: string, formula: string): number | null;
+    evaluatePredefinedOperation(rowId: string, operation: string, formula: string): number | null;
+    checkAndEvaluateFormulas(rowId: string): void;
+    clearAll(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationFunctionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AggregationFunctionService>;
+}

package/services/countryService.d.ts

@@ -0,0 +1,21 @@
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { DataService } from './data.service';
+import * as i0 from "@angular/core";
+interface CountryData {
+    value: string;
+    label: string;
+    image: string;
+}
+export declare class CountryService {
+    private http;
+    private dataService;
+    private apiUrl;
+    header: any;
+    constructor(http: HttpClient, dataService: DataService);
+    loadCountryDetails(questionId: string, page: number, size: number, searchKey: string): Observable<any>;
+    processCountryDetails(data: any[], displayFlag: boolean, displayCode: boolean, showCountryName: boolean): CountryData[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<CountryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CountryService>;
+}
+export {};

package/services/data.service.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DataService {
+    constructor();
+    private dataSubject;
+    apiUrl$: Observable<string>;
+    private headerSubject;
+    header$: Observable<any>;
+    private subformSubject;
+    subform$: Observable<any>;
+    private parentQuestionsSubject;
+    parentQuestions$: Observable<any>;
+    setApiUrl(data: string): void;
+    setHeader(data: any): void;
+    setParentQuestions(data: any): void;
+    setSubformData(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;
+}

package/services/element-tracker.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class ElementTrackerService {
+    private elementIds;
+    registerElement(id: string): void;
+    unregisterElement(id: string): void;
+    getAllElementIds(): string[];
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ElementTrackerService>;
+}

package/services/form-validation.service.d.ts

@@ -0,0 +1,16 @@
+import { ValidationService } from './validation.service';
+import * as i0 from "@angular/core";
+export declare class FormValidationService {
+    private validationService;
+    constructor(validationService: ValidationService);
+    /**
+     * Validate all required questions on a page.
+     * Assumes your `page` object has a `pageIndex: number` property.
+     */
+    validateRequiredQuestions(page: any): {
+        isValid: boolean;
+        message: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormValidationService>;
+}

package/services/form.service.d.ts

@@ -0,0 +1,27 @@
+import { HttpClient } from '@angular/common/http';
+import { DataService } from './data.service';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class FormService {
+    private http;
+    private dataService;
+    private apiUrl;
+    header: any;
+    parentQuestions: any;
+    subformData: any;
+    constructor(http: HttpClient, dataService: DataService);
+    getQuestions(moduleName: string, pageNumber?: number, rowSet?: number, progressiveLoading?: boolean, country?: string): Observable<any>;
+    fetchDataFromDatabase(database: any, pageNumber?: number, pageSize?: number, searchString?: string, enablePagination?: boolean): Observable<any>;
+    fetchDataFromLookup(tableName: string): Observable<any>;
+    fetchDataFromExternalAPI(apiConfig: any, selectedValues?: any[]): Observable<any>;
+    submitForm(moduleName: string, formData: FormData, reCAPTCHAToken?: string): Observable<any>;
+    getSubmittedForm(moduleName: string, submissionId: string, pageNumber?: number, rowSet?: number, navigateTo?: string): Observable<any>;
+    updateForm(moduleName: string, submissionId: string, formData: FormData, reCAPTCHAToken?: string): Observable<any>;
+    previewFile(url: any): Observable<any>;
+    getSubformSubmissions(subFormData: any): Observable<Object> | undefined;
+    getSafeHeaders(): {
+        [key: string]: string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormService>;
+}

package/services/mapper.service.d.ts

@@ -0,0 +1,31 @@
+import { Page } from '../models/page.model';
+import { PublicForm } from '../models/publicForm.model';
+import { Question } from '../models/question.model';
+import { Section } from '../models/section.model';
+import { SubForm } from '../models/subForm.model';
+import { FormElementType } from '../models/formElementType.model';
+import { QuestionGroup } from '../models/questionGroup.model';
+import { Multifields } from '../models/multifields.model';
+import { DefaultAnswersModel } from '../models/defaultAnswersModel.model';
+import { DefaultAnswerEntry } from '../models/defaultAnswerEntry.model';
+import { DefaultQuestionAnswer } from '../models/defaultQuestionAnswer.model';
+import { EmitterDTO } from '../models/emitters.model';
+import { SubmissionCopyConfig } from '../models/submissionCopyConfig.mopdel';
+export declare function mapPublicFormToModel(apiPublicForm: any): PublicForm;
+export declare function mapEmitterToModel(apiEmitter: any): EmitterDTO;
+export declare function mapPageToModel(apiPage: any, currency: any, defaultCurrency: any): Page;
+export declare function mapWhenClauseModel(whenClauseDTO: any): {
+    activate: boolean;
+    whenClauseActions: any;
+    whenClauseCondition: any;
+};
+export declare function mapSectionToModel(apiSection: any): Section;
+export declare function mapQuestionToModel(apiQuestion: any, currency: any, defaultCurrency: any): Question;
+export declare function mapSubFormToModel(apiSubForm: any, currency: any, defaultCurrency: any): SubForm;
+export declare function mapSubmissionCopyConfig(copyConfig: any): SubmissionCopyConfig | undefined;
+export declare function mapDefaultAnswersToModel(apiDefaultAnswers: any): DefaultAnswersModel;
+export declare function mapDefaultAnswerEntry(apiEntry: any): DefaultAnswerEntry;
+export declare function mapDefaultQuestionAnswer(apiQuestion: any): DefaultQuestionAnswer;
+export declare function mapQuestionGroupToModel(apiQuestionGroup: any, currency: any, defaultCurrency: any): QuestionGroup;
+export declare function mapMultifieldsToModel(apiQuestionGroup: any, currency: any, defaultCurrency: any): Multifields;
+export declare function mapFormElementTypeToModel(apiFormElementType: any): FormElementType<any>;

package/services/recaptcha.service.d.ts

@@ -0,0 +1,46 @@
+import { HttpClient } from '@angular/common/http';
+import { ToastrService } from 'ngx-toastr';
+import { Observable } from 'rxjs';
+import { DataService } from './data.service';
+import * as i0 from "@angular/core";
+declare global {
+    interface Window {
+        onRecaptchaLoadCallback: () => void;
+    }
+    var grecaptcha: {
+        ready: (callback: () => void) => void;
+        render: (container: string | HTMLElement, parameters: {
+            sitekey: string;
+            callback?: (token: string) => void;
+            'expired-callback'?: () => void;
+            'error-callback'?: () => void;
+            size?: 'normal' | 'compact' | 'invisible';
+            theme?: 'light' | 'dark';
+        }) => number;
+        execute: (widgetId?: number) => void;
+        getResponse: (widgetId?: number) => string;
+        reset: (widgetId?: number) => void;
+    };
+}
+export declare class RecaptchaService {
+    private toastr;
+    private http;
+    private dataService;
+    private siteKey;
+    private apiUrl;
+    private widgetId;
+    private initialized;
+    private resolved;
+    constructor(toastr: ToastrService, http: HttpClient, dataService: DataService);
+    ngOnInit(): void;
+    fetchSiteKeyFromApi(): Observable<string>;
+    initialize(): Promise<void>;
+    render(containerId: string, callback: (token: string) => void): void;
+    reset(): void;
+    getResponse(): string;
+    isRendered(): boolean;
+    isResolved(): boolean;
+    removeRecaptchaScript(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RecaptchaService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RecaptchaService>;
+}

package/services/score.service.d.ts

@@ -0,0 +1,27 @@
+import { Answer } from '../models/answer.model';
+import { Submission } from '../models/submission.model';
+import * as i0 from "@angular/core";
+interface SubmissionScore {
+    scoreType: string;
+    score: number;
+}
+export declare class ScoreCalculationService {
+    constructor();
+    calculateScoreFromAnswer(newAnswer: string[] | string, question: any): {
+        scores: {
+            scoreType: string;
+            score: number;
+        }[];
+    } | null;
+    getMaxPossibleScore(subform: any): {
+        goodMax: number;
+        badMax: number;
+    };
+    calculateSubmissionScore: (answers: Answer[], enableScoringType?: boolean) => SubmissionScore[];
+    calculateFinalScore(submissions: Submission[], maxPossibleGoodScore: number, maxPossibleBadScore: number): SubmissionScore[];
+    getMaxPossibleScoreForQuestion(question: any): number;
+    shouldCalculateScore(subForm: any, submission: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScoreCalculationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScoreCalculationService>;
+}
+export {};

package/services/subform-copy.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class SubformCopyService {
+    copySubform(subForm: any, pages: any[]): {
+        updatedPages: any[];
+    };
+    private deepCopyWithNewIds;
+    private findPageContainingSubform;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubformCopyService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubformCopyService>;
+}

package/services/validation.service.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class ValidationService {
+    private invalidQuestions;
+    setInvalid(questionId: string, message: string, pageIndex: number): void;
+    clearInvalid(questionId: string): void;
+    getFirstInvalid(): {
+        id: string;
+        pageIndex: number;
+    } | null;
+    getErrorMessage(questionId: string): string | null;
+    clearAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationService>;
+}

package/services/whenClause.service.d.ts

@@ -0,0 +1,45 @@
+import { Submission } from '../models/submission.model';
+import * as i0 from "@angular/core";
+export declare class WhenClauseService {
+    private activeWhenClauseGrids;
+    private questionAnswerMap;
+    private questionChange$;
+    isInitialLoad: boolean;
+    constructor();
+    markLoadCompleted(): void;
+    onQuestionChange(): import("rxjs").Observable<{
+        questionId: string;
+    }>;
+    /**
+     * Check if a grid has an active when clause
+     */
+    isActiveWhenClause(grid: any): boolean;
+    /**
+     * Add a grid to tracking list if it has an active when clause
+     */
+    addGrid(grid: any): void;
+    setQuestionAnswer(questionId: string, answer: any, initial?: boolean): void;
+    getAnswer(questionId: string): any;
+    private evaluateAllWhenClauses;
+    evaluateCondition(answer: any, operator: string, value: any): boolean;
+    addGridsFromSubform(subform: any): void;
+    /**
+     * Recursively process childLogics structure
+     */
+    private processChildLogics;
+    /**
+     * Return ALL elements with an active whenClause inside a subform,
+     * including nested childLogics (recursive)
+     */
+    getWhenClauseElements(subform: any): any[];
+    /**
+     * Recursively gather grids with active whenClause inside childLogics
+     */
+    private getElementsFromChildLogics;
+    checkElementVisibility(id: string, submission: Submission): boolean;
+    evaluateSubformWhenClauses(changedAnswer: any, submission: Submission, changedQuestionId: string, elementsWithWhenClause: any): void;
+    resetService(): void;
+    getActiveWhenClauseGrids(): any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<WhenClauseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WhenClauseService>;
+}

package/shared/shared.module.d.ts

@@ -0,0 +1,25 @@
+import * as i0 from "@angular/core";
+import * as i1 from "../question/recursive-logic/recursive-logic.component";
+import * as i2 from "../question/question/question.component";
+import * as i3 from "../question/sub-form/sub-form.component";
+import * as i4 from "../question/form-elements/form-elements.component";
+import * as i5 from "../question/multiple-subform/multiple-subform.component";
+import * as i6 from "../sub-form/submission-modal/submission-modal.component";
+import * as i7 from "../question/question-group/question-group.component";
+import * as i8 from "../question/inline-multiple-subform/inline-multiple-subform.component";
+import * as i9 from "../question/multifields/multifields.component";
+import * as i10 from "../question/card-subform/card-subform.component";
+import * as i11 from "@angular/common";
+import * as i12 from "../form-fields/form-fields.module";
+import * as i13 from "@angular/material/dialog";
+import * as i14 from "@angular/material/table";
+import * as i15 from "@angular/material/menu";
+import * as i16 from "@angular/material/icon";
+import * as i17 from "ngx-quill";
+import * as i18 from "@angular/forms";
+import * as i19 from "@ng-bootstrap/ng-bootstrap";
+export declare class SharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedModule, [typeof i1.RecursiveLogicComponent, typeof i2.QuestionComponent, typeof i3.SubFormComponent, typeof i4.FormElementsComponent, typeof i5.MultipleSubformComponent, typeof i6.SubmissionModalComponent, typeof i7.QuestionGroupComponent, typeof i8.InlineMultipleSubformComponent, typeof i9.MultifieldsComponent, typeof i10.CardSubformComponent], [typeof i11.CommonModule, typeof i12.FormFieldsModule, typeof i13.MatDialogModule, typeof i14.MatTableModule, typeof i15.MatMenuModule, typeof i16.MatIconModule, typeof i17.QuillModule, typeof i18.FormsModule, typeof i19.NgbModule], [typeof i1.RecursiveLogicComponent, typeof i2.QuestionComponent, typeof i3.SubFormComponent, typeof i4.FormElementsComponent, typeof i7.QuestionGroupComponent, typeof i8.InlineMultipleSubformComponent, typeof i9.MultifieldsComponent, typeof i10.CardSubformComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedModule>;
+}