@openmrs/ngx-formentry 3.0.0

package/form-entry/control-alerts/alert-helpers.d.ts

@@ -0,0 +1,9 @@
+import { CanGenerateAlert, Alert } from './can-generate-alert';
+export declare class AlertHelper {
+    hideAlert(control: Alert): void;
+    showAlert(control: Alert): void;
+    setAlertsForControl(control: CanGenerateAlert, alert: Alert): void;
+    clearAlertsForControl(control: CanGenerateAlert): void;
+    evaluateControlAlerts(control: CanGenerateAlert): void;
+    setUpReEvaluationWhenValueChanges(control: CanGenerateAlert): void;
+}

package/form-entry/control-alerts/can-generate-alert.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+export interface CanGenerateAlert {
+    alerts: Alert[];
+    alert: string;
+    valueChanges?: Observable<any>;
+    setAlertFn(newMessage: Alert): any;
+    clearMessageFns(): any;
+    updateAlert(): any;
+}
+export interface Alert {
+    shown: boolean;
+    alertWhenExpression: string;
+    alertMessage: string;
+    reEvaluateAlertExpression: EvaluateExpressionFn;
+}
+export interface EvaluateExpressionFn {
+    (): any;
+}

package/form-entry/control-calculators/can-calculate.d.ts

@@ -0,0 +1,5 @@
+export interface CanCalculate {
+    calculator: Function;
+    setCalculatorFn(newCalculator: Function): any;
+    updateCalculatedValue(): any;
+}

package/form-entry/control-hiders-disablers/can-disable.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+export interface CanDisable {
+    disablers: Disabler[];
+    disabled: boolean;
+    valueChanges?: Observable<any>;
+    disable(): any;
+    enable(): any;
+    setDisablingFn(newHider: Disabler): any;
+    clearDisablingFns(): any;
+    updateDisabledState(): any;
+}
+export interface Disabler {
+    toDisable: boolean;
+    disableWhenExpression: string;
+    reEvaluateDisablingExpression: EvaluateExpressionFn;
+}
+export interface EvaluateExpressionFn {
+    (): any;
+}

package/form-entry/control-hiders-disablers/can-hide.d.ts

@@ -0,0 +1,20 @@
+import { Observable } from 'rxjs';
+import { EvaluateExpressionFn } from './can-disable';
+export interface CanHide {
+    hiders: Hider[];
+    hidden: boolean;
+    disabled?: boolean;
+    valueChanges?: Observable<any>;
+    disable?(): any;
+    hide(): any;
+    show(): any;
+    setHidingFn(newHider: Hider): any;
+    clearHidingFns(): any;
+    updateHiddenState(): any;
+    setValue?(value: any): any;
+}
+export interface Hider {
+    toHide: boolean;
+    hideWhenExpression: string;
+    reEvaluateHidingExpression: EvaluateExpressionFn;
+}

package/form-entry/control-hiders-disablers/disabler-helper.d.ts

@@ -0,0 +1,7 @@
+import { CanDisable, Disabler } from './can-disable';
+export declare class DisablerHelper {
+    setDisablerForControl(control: CanDisable, disabler: Disabler): void;
+    clearDisablersForControl(control: CanDisable): void;
+    evaluateControlDisablers(control: CanDisable): void;
+    setUpReEvaluationWhenValueChanges(control: CanDisable): void;
+}

package/form-entry/control-hiders-disablers/hider-helpers.d.ts

@@ -0,0 +1,9 @@
+import { CanHide, Hider } from './can-hide';
+export declare class HiderHelper {
+    hideControl(control: CanHide): void;
+    showControl(control: CanHide): void;
+    setHiderForControl(control: CanHide, hider: Hider): void;
+    clearHidersForControl(control: CanHide): void;
+    evaluateControlHiders(control: CanHide): void;
+    setUpReEvaluationWhenValueChanges(control: CanHide): void;
+}

package/form-entry/data-sources/data-sources.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class DataSources {
+    private _dataSources;
+    constructor();
+    get dataSources(): any;
+    registerDataSource(key: string, dataSource: any, unWrap?: boolean): void;
+    clearDataSource(key: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataSources, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DataSources>;
+}

package/form-entry/data-sources/dummy-data-source.d.ts

@@ -0,0 +1,18 @@
+import { Option } from '../question-models/select-option';
+import { DataSource } from '../question-models/interfaces/data-source';
+import { Observable } from 'rxjs';
+export declare class DummyDataSource implements DataSource {
+    options: Observable<Option[]>;
+    option: Observable<Option>;
+    returnErrorOnNext: boolean;
+    constructor();
+    resolveSelectedValue(value: any): Observable<Option>;
+    fileUpload(url: any): Observable<{
+        image: string;
+    }>;
+    fetchFile(url: any): Observable<{
+        image: string;
+    }>;
+    searchOptions(searchText: any): Observable<Option[]>;
+    sampleData(): any;
+}

package/form-entry/directives/collapse-animations.d.ts

@@ -0,0 +1,4 @@
+import { AnimationMetadata } from '@angular/animations';
+export declare const COLLAPSE_ANIMATION_TIMING = "400ms cubic-bezier(0.4,0.0,0.2,1)";
+export declare const expandAnimation: AnimationMetadata[];
+export declare const collapseAnimation: AnimationMetadata[];

package/form-entry/directives/collapse.directive.d.ts

@@ -0,0 +1,45 @@
+import { AnimationBuilder } from '@angular/animations';
+import { AfterViewChecked, ElementRef, EventEmitter, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class CollapseDirective implements AfterViewChecked {
+    private _el;
+    private _renderer;
+    /** This event fires as soon as content collapses */
+    collapsed: EventEmitter<CollapseDirective>;
+    /** This event fires when collapsing is started */
+    collapses: EventEmitter<CollapseDirective>;
+    /** This event fires as soon as content becomes visible */
+    expanded: EventEmitter<CollapseDirective>;
+    /** This event fires when expansion is started */
+    expands: EventEmitter<CollapseDirective>;
+    isExpanded: boolean;
+    collapseNewValue: boolean;
+    isCollapsed: boolean;
+    isCollapse: boolean;
+    isCollapsing: boolean;
+    set display(value: string);
+    /** turn on/off animation */
+    isAnimated: boolean;
+    /** A flag indicating visibility of content (shown or hidden) */
+    set collapse(value: boolean);
+    get collapse(): boolean;
+    private _display;
+    private _isAnimationDone?;
+    private _player?;
+    private _stylesLoaded;
+    private _COLLAPSE_ACTION_NAME;
+    private _EXPAND_ACTION_NAME;
+    private readonly _factoryCollapseAnimation;
+    private readonly _factoryExpandAnimation;
+    constructor(_el: ElementRef, _renderer: Renderer2, _builder: AnimationBuilder);
+    ngAfterViewChecked(): void;
+    /** allows to manually toggle content visibility */
+    toggle(): void;
+    /** allows to manually hide content */
+    hide(): void;
+    /** allows to manually show collapsed content */
+    show(): void;
+    animationRun(isAnimated: boolean, action: string): (callback: () => void) => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CollapseDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CollapseDirective, "[ofeCollapse]", ["bs-collapse"], { "display": "display"; "isAnimated": "isAnimated"; "collapse": "collapse"; }, { "collapsed": "collapsed"; "collapses": "collapses"; "expanded": "expanded"; "expands": "expands"; }, never>;
+}

package/form-entry/directives/historical-value.directive.d.ts

@@ -0,0 +1,16 @@
+import { EventEmitter } from '@angular/core';
+import { HistoricalFieldHelperService } from '../helpers/historical-field-helper-service';
+import { NodeBase } from '../form-factory/form-node';
+import * as i0 from "@angular/core";
+export declare class HistoricalValueDirective {
+    private historicalFieldHelper;
+    _node: NodeBase;
+    _nodeChange: EventEmitter<Object>;
+    historicalDisplay: string;
+    constructor(historicalFieldHelper: HistoricalFieldHelperService);
+    setValue(e: any): void;
+    set node(node: NodeBase);
+    private compareStrings;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalValueDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HistoricalValueDirective, "[node]", never, { "_node": "_node"; "node": "node"; }, { "_nodeChange": "_nodeChange"; }, never>;
+}

package/form-entry/error-renderer/error-renderer.component.d.ts

@@ -0,0 +1,18 @@
+import { Form } from '../form-factory/form';
+import { ValidationFactory } from '../form-factory/validation.factory';
+import { NodeBase, LeafNode } from '../form-factory/form-node';
+import { FormErrorsService } from '../services/form-errors.service';
+import * as i0 from "@angular/core";
+export declare class ErrorRendererComponent {
+    private validationFactory;
+    private formErrorsService;
+    form: Form;
+    constructor(validationFactory: ValidationFactory, formErrorsService: FormErrorsService);
+    showErrors(): boolean;
+    get errorNodes(): any;
+    getControlError(node: LeafNode): string[];
+    announceErrorField(errorNode: LeafNode): void;
+    getPageIndex(node: NodeBase): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ErrorRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ErrorRendererComponent, "ofe-error-renderer", never, { "form": "form"; }, {}, never, never>;
+}

package/form-entry/expression-runner/expression-runner.d.ts

@@ -0,0 +1,18 @@
+import { AfeFormControl, AfeFormArray, AfeFormGroup } from '../../abstract-controls-extension/control-extensions';
+import { Form } from '../form-factory/form';
+import * as i0 from "@angular/core";
+export declare class ExpressionRunner {
+    getRunnable(expression: string, control: AfeFormArray | AfeFormGroup | AfeFormControl, helper: any, dataDependencies: any, form?: Form): Runnable;
+    private getControlRelationValueString;
+    private setControlQuestion;
+    private setControlArrayValues;
+    private _getFormControlKeys;
+    private _getValuesForKey;
+    private getHelperMethods;
+    private getDataDependencies;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpressionRunner, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExpressionRunner>;
+}
+export interface Runnable {
+    run(): any;
+}

package/form-entry/form-entry.module.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./form-renderer/form-renderer.component";
+import * as i2 from "../components/afe-ng-select.component";
+import * as i3 from "../components/appointments-overview/appointments-overview.component";
+import * as i4 from "./directives/historical-value.directive";
+import * as i5 from "./error-renderer/error-renderer.component";
+import * as i6 from "./pipes/time-ago.pipe";
+import * as i7 from "./directives/collapse.directive";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/forms";
+import * as i10 from "../components/select/select.module";
+import * as i11 from "@ng-select/ng-select";
+import * as i12 from "../components/number-input/number-input.module";
+import * as i13 from "../components/input/input.module";
+import * as i14 from "../components/date-time-picker/date-time-picker.module";
+import * as i15 from "../components/ngx-remote-select/ngx-remote-select.module";
+import * as i16 from "../components/file-upload/file-upload.module";
+import * as i17 from "../components/check-box/checkbox.module";
+import * as i18 from "../components/radio-button/radio.module";
+import * as i19 from "../components/ngx-datetime-picker/ngx-datetime-picker.module";
+import * as i20 from "../shared.module";
+import * as i21 from "../components/custom-control-wrapper/custom-control-wrapper..module";
+import * as i22 from "../components/custom-component-wrapper/custom-component-wrapper..module";
+import * as i23 from "../components/ngx-tabset/modules/ngx-tabset.module";
+import * as i24 from "@ngx-translate/core";
+export declare class FormEntryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormEntryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FormEntryModule, [typeof i1.FormRendererComponent, typeof i2.AfeNgSelectComponent, typeof i3.AppointmentsOverviewComponent, typeof i4.HistoricalValueDirective, typeof i5.ErrorRendererComponent, typeof i6.TimeAgoPipe, typeof i7.CollapseDirective], [typeof i8.CommonModule, typeof i9.ReactiveFormsModule, typeof i10.SelectModule, typeof i11.NgSelectModule, typeof i12.NumberInputModule, typeof i13.InputModule, typeof i14.DateTimePickerModule, typeof i15.NgxRemoteSelectModule, typeof i16.RemoteFileUploadModule, typeof i17.CheckboxModule, typeof i18.RadioModule, typeof i19.NgxDateTimePickerModule, typeof i20.SharedModule, typeof i21.CustomControlWrapperModule, typeof i22.CustomComponentWrapperModule, typeof i23.NgxTabSetModule, typeof i24.TranslateModule], [typeof i1.FormRendererComponent, typeof i2.AfeNgSelectComponent, typeof i5.ErrorRendererComponent, typeof i14.DateTimePickerModule, typeof i19.NgxDateTimePickerModule, typeof i24.TranslateModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FormEntryModule>;
+}

package/form-entry/form-factory/control-relations.factory.d.ts

@@ -0,0 +1,18 @@
+import { QuestionBase } from '../question-models/question-base';
+import { NodeBase, GroupNode } from './form-node';
+import { AfeFormControl } from '../../abstract-controls-extension/afe-form-control';
+import { AfeFormArray } from '../../abstract-controls-extension/afe-form-array';
+import * as i0 from "@angular/core";
+export declare class ControlRelationsFactory {
+    constructor();
+    buildRelations(rootNode: GroupNode): void;
+    buildArrayNodeRelations(node: GroupNode): void;
+    createRelationsToArrayControls(node: GroupNode): void;
+    getRelationsForControl(id: any, node: GroupNode): Array<AfeFormControl | AfeFormArray>;
+    mapControlIds(node: GroupNode, controlsStore: any): any;
+    setRelations(controlsStore: any, nodeBase: NodeBase): void;
+    hasRelation(id: string, questionBase: QuestionBase, nodeBase?: NodeBase): boolean;
+    addRelationToControl(control: AfeFormControl | AfeFormArray, related: AfeFormControl | AfeFormArray): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlRelationsFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ControlRelationsFactory>;
+}

package/form-entry/form-factory/form-control.service.d.ts

@@ -0,0 +1,25 @@
+import { AfeFormControl, AfeFormArray, AfeFormGroup } from '../../abstract-controls-extension';
+import { NestedQuestion } from '../question-models/interfaces/nested-questions';
+import { QuestionBase } from '../question-models/question-base';
+import { ValidationFactory } from '../form-factory/validation.factory';
+import { HidersDisablersFactory } from './hiders-disablers.factory';
+import { AlertsFactory } from './show-messages.factory';
+import { Form } from './form';
+import * as i0 from "@angular/core";
+export declare class FormControlService {
+    private alertsFactory;
+    controls: any[];
+    validationFactory: ValidationFactory;
+    hidersDisablersFactory: HidersDisablersFactory;
+    constructor(validationFactory: ValidationFactory, hidersDisablersFactory: HidersDisablersFactory, alertsFactory: AlertsFactory);
+    generateControlModel(questionModel: QuestionBase | NestedQuestion, parentControl: AfeFormGroup, generateChildren: boolean, form?: Form): AfeFormControl | AfeFormArray | AfeFormGroup;
+    generateFormGroupModel(question: QuestionBase, generateChildren: boolean, parentControl?: AfeFormGroup, form?: Form): AfeFormGroup;
+    _generateFormGroupChildrenModel(questions: QuestionBase[], parentControl: AfeFormGroup, form?: Form): void;
+    generateFormArray(question: QuestionBase, parentControl?: AfeFormGroup, form?: Form): AfeFormArray;
+    generateFormControl(question: QuestionBase, parentControl?: AfeFormGroup, form?: Form): AfeFormControl;
+    private wireAlerts;
+    private wireHidersDisablers;
+    private wireCalculator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormControlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormControlService>;
+}

package/form-entry/form-factory/form-node.d.ts

@@ -0,0 +1,52 @@
+import { FormFactory } from './form.factory';
+import { Form } from './form';
+import { QuestionBase, RepeatingQuestion } from '../question-models/models';
+import { AfeFormControl, AfeFormArray, AfeFormGroup } from '../../abstract-controls-extension';
+export interface ChildNodeCreatedListener {
+    addChildNodeCreatedListener(func: any): any;
+    fireChildNodeCreatedListener(node: GroupNode): any;
+}
+export declare type CreateArrayChildNodeFunction = (question: RepeatingQuestion, node: ArrayNode, factory?: FormFactory, position?: number) => GroupNode;
+export interface RemoveArrayChildNodeFunction {
+    (index: number, node: ArrayNode): any;
+}
+export declare abstract class NodeBase {
+    abstract children?: any;
+    nodeIndex?: Number;
+    private _control;
+    private _questionModel;
+    private _form;
+    private _path;
+    initialValue: any;
+    constructor(question: QuestionBase, control?: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form, parentPath?: string);
+    get question(): QuestionBase;
+    get control(): AfeFormControl | AfeFormArray | AfeFormGroup;
+    get form(): Form;
+    get path(): string;
+    removeAt(index: number): void;
+    createChildNode(): void;
+    removeChildNode(): void;
+}
+export declare class LeafNode extends NodeBase {
+    get children(): any;
+    constructor(question: QuestionBase, control?: AfeFormControl | AfeFormArray | AfeFormGroup, parentControl?: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form, parentPath?: string);
+}
+export declare class GroupNode extends NodeBase {
+    private _children;
+    constructor(question: QuestionBase, control?: AfeFormControl | AfeFormArray | AfeFormGroup, parentControl?: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form, parentPath?: string);
+    get children(): any;
+    setChild(key: string, node: NodeBase): void;
+}
+export declare class ArrayNode extends NodeBase implements ChildNodeCreatedListener {
+    private formFactory?;
+    private childNodeCreatedEvents;
+    private _children;
+    createChildFunc: CreateArrayChildNodeFunction;
+    removeChildFunc: RemoveArrayChildNodeFunction;
+    constructor(question: QuestionBase, control?: AfeFormControl | AfeFormArray | AfeFormGroup, parentControl?: AfeFormControl | AfeFormArray | AfeFormGroup, formFactory?: FormFactory, form?: Form, parentPath?: string);
+    get children(): GroupNode[];
+    createChildNode(): GroupNode;
+    removeAt(index: number): GroupNode;
+    addChildNodeCreatedListener(func: any): void;
+    fireChildNodeCreatedListener(node: GroupNode): void;
+}

package/form-entry/form-factory/form.d.ts

@@ -0,0 +1,28 @@
+import { FormFactory } from './form.factory';
+import { QuestionFactory } from './question.factory';
+import { DataSources } from '../data-sources/data-sources';
+import { NodeBase, GroupNode } from './form-node';
+export declare class Form {
+    schema: any;
+    formFactory: FormFactory;
+    questionFactory: QuestionFactory;
+    rootNode: GroupNode;
+    valueProcessingInfo: any;
+    existingOrders: any;
+    private _dataSourcesContainer;
+    private _showErrors;
+    constructor(schema: any, formFactory: FormFactory, questionFactory: QuestionFactory);
+    get dataSourcesContainer(): DataSources;
+    searchNodeByPath(node: GroupNode, path: any, found: Array<NodeBase>): NodeBase[];
+    searchNodeByQuestionId(questionId: string, questionType?: string): Array<NodeBase>;
+    searchNodeByQuestionType(rootNode: any, questionType: string, found: Array<NodeBase>): void;
+    private findNodesByQuestionId;
+    get valid(): boolean;
+    set showErrors(show: boolean);
+    get showErrors(): boolean;
+    markInvalidControls(node: GroupNode, invalidControlNodes?: any): any;
+    updateHiddenDisabledStateForAllControls(): void;
+    updateAlertsForAllControls(): void;
+    private _updateAlertsForAllControls;
+    private _updateHiddenDisabledStateForAllControls;
+}

package/form-entry/form-factory/form.factory.d.ts

@@ -0,0 +1,27 @@
+import { LeafNode, GroupNode, ArrayNode, NodeBase } from './form-node';
+import { QuestionBase, NestedQuestion, RepeatingQuestion } from '../question-models/models';
+import { FormControlService } from './form-control.service';
+import { QuestionFactory } from './question.factory';
+import { AfeFormGroup } from '../../abstract-controls-extension';
+import { ControlRelationsFactory } from './control-relations.factory';
+import { Form } from './form';
+import * as i0 from "@angular/core";
+export declare class FormFactory {
+    controlService: FormControlService;
+    questionFactroy: QuestionFactory;
+    controlRelationsFactory: ControlRelationsFactory;
+    private nodeIndex;
+    hd: any;
+    constructor(controlService: FormControlService, questionFactroy: QuestionFactory, controlRelationsFactory: ControlRelationsFactory);
+    createForm(schema: any, dataSource?: any): Form;
+    buildRelations(rootNode: GroupNode): void;
+    createNode(question: QuestionBase | NestedQuestion, parentNode?: GroupNode, parentControl?: AfeFormGroup, form?: Form): NodeBase;
+    createLeafNode(question: QuestionBase, parentNode: GroupNode, parentControl?: AfeFormGroup, form?: Form): LeafNode;
+    createGroupNode(question: NestedQuestion, parentNode?: GroupNode, parentControl?: AfeFormGroup, form?: Form): GroupNode;
+    createArrayNode(question: NestedQuestion, parentNode?: GroupNode, parentControl?: AfeFormGroup, form?: Form): ArrayNode;
+    createNodeChildren(question: NestedQuestion, node: GroupNode, parentControl?: AfeFormGroup, form?: Form): any;
+    createArrayNodeChild(question: RepeatingQuestion, node: ArrayNode, factory?: FormFactory, position?: number): GroupNode;
+    removeArrayNodeChild(index: number, node: ArrayNode): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormFactory>;
+}

package/form-entry/form-factory/hiders-disablers.factory.d.ts

@@ -0,0 +1,20 @@
+import { Disabler } from '../control-hiders-disablers/can-disable';
+import { Hider } from '../control-hiders-disablers/can-hide';
+import { ExpressionRunner } from '../expression-runner/expression-runner';
+import { AfeFormControl, AfeFormArray, AfeFormGroup } from '../../abstract-controls-extension';
+import { QuestionBase } from '../question-models/question-base';
+import { JsExpressionHelper } from '../helpers/js-expression-helper';
+import { Form } from './form';
+import { DebugModeService } from './../services/debug-mode.service';
+import * as i0 from "@angular/core";
+export declare class HidersDisablersFactory {
+    private expressionRunner;
+    private expressionHelper;
+    private _debugModeService;
+    constructor(expressionRunner: ExpressionRunner, expressionHelper: JsExpressionHelper, _debugModeService: DebugModeService);
+    getJsExpressionDisabler(question: QuestionBase, control: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form): Disabler;
+    getJsExpressionHider(question: QuestionBase, control: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form): Hider;
+    convertHideObjectToString(hide: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HidersDisablersFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HidersDisablersFactory>;
+}

package/form-entry/form-factory/question.factory.d.ts

@@ -0,0 +1,62 @@
+import { TextInputQuestion } from '../question-models/text-input-question';
+import { TextAreaInputQuestion } from '../question-models/text-area-input-question';
+import { SelectQuestion } from '../question-models/select-question';
+import { UiSelectQuestion } from '../question-models/ui-select-question';
+import { DateQuestion } from '../question-models/date-question';
+import { MultiSelectQuestion } from '../question-models/multi-select-question';
+import { QuestionGroup } from '../question-models/group-question';
+import { RepeatingQuestion } from '../question-models/repeating-question';
+import { QuestionBase } from '../question-models/question-base';
+import { FileUploadQuestion } from '../question-models/file-upload-question';
+import { TestOrderQuestion } from '../question-models/test-order-question';
+import { ValidationModel } from '../question-models/validation.model';
+import { HistoricalHelperService } from '../helpers/historical-expression-helper-service';
+import { Form } from './form';
+import { CheckBoxQuestion } from '../question-models/models';
+import { RadioButtonQuestion } from '../question-models/models';
+import * as i0 from "@angular/core";
+export declare class QuestionFactory {
+    dataSources: any;
+    historicalHelperService: HistoricalHelperService;
+    quetionIndex: number;
+    constructor();
+    createQuestionModel(formSchema: any, form?: Form): QuestionBase;
+    toSelectQuestion(schemaQuestion: any): SelectQuestion;
+    toNumericQuestion(schemaQuestion: any): TextInputQuestion;
+    toNumberQuestion(schemaQuestion: any): TextInputQuestion;
+    toDateQuestion(schemaQuestion: any): DateQuestion;
+    toEncounterDatetimeQuestion(schemaQuestion: any): DateQuestion;
+    toCheckBoxQuestion(schemaQuestion: any): CheckBoxQuestion;
+    toRadioButtonQuestion(schemaQuestion: any): RadioButtonQuestion;
+    toMultiCheckboxQuestion(schemaQuestion: any): MultiSelectQuestion;
+    toTextAreaQuestion(schemaQuestion: any): TextAreaInputQuestion;
+    toTextQuestion(schemaQuestion: any): TextInputQuestion;
+    toFileUploadQuestion(schemaQuestion: any): FileUploadQuestion;
+    toDrugQuestion(schemaQuestion: any): SelectQuestion;
+    toProblemQuestion(schemaQuestion: any): SelectQuestion;
+    toConceptAnswerSelect(schemaQuestion: any): SelectQuestion;
+    toRepeatingQuestion(schemaQuestion: any): RepeatingQuestion;
+    toGroupQuestion(schemaQuestion: any): QuestionGroup;
+    toPageQuestion(schemaQuestion: any): QuestionGroup;
+    toFormQuestionModel(schemaQuestion: any): QuestionGroup;
+    toSectionQuestion(schemaQuestion: any): QuestionGroup;
+    toPersonAttributeQuestion(schemaQuestion: any): UiSelectQuestion;
+    toEncounterProviderQuestion(schemaQuestion: any): UiSelectQuestion;
+    toFieldSetQuestion(schemaQuestion: any): QuestionGroup;
+    toEncounterLocationQuestion(schemaQuestion: any): UiSelectQuestion;
+    toTestOrderQuestion(schemaQuestion: any): TestOrderQuestion;
+    getSchemaQuestions(schema: any): any;
+    getQuestions(schema: any, foundArray: any): any;
+    getChildrenQuestionModels(schema: any): any;
+    toModel(schema: any, renderType: string): any;
+    convertOldVersionComplexObsQuestionToNewVersion(schemaQuestion: any): any;
+    copyProperties(mappings: any, source: any, destination: QuestionBase): void;
+    addValidators(schemaQuestion: any): Array<ValidationModel>;
+    addHistoricalExpressions(schemaQuestion: any, question: QuestionBase): any;
+    addCalculatorProperty(schemaQuestion: any, question: QuestionBase): any;
+    addAlertProperty(schemaQuestion: any, question: QuestionBase): any;
+    addDisableOrHideProperty(schemaQuestion: any, question: QuestionBase): any;
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QuestionFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<QuestionFactory>;
+}

package/form-entry/form-factory/show-messages.factory.d.ts

@@ -0,0 +1,15 @@
+import { Alert } from '../control-alerts/can-generate-alert';
+import { ExpressionRunner } from '../expression-runner/expression-runner';
+import { AfeFormControl, AfeFormArray, AfeFormGroup } from '../../abstract-controls-extension';
+import { QuestionBase } from '../question-models/question-base';
+import { JsExpressionHelper } from '../helpers/js-expression-helper';
+import { Form } from './form';
+import * as i0 from "@angular/core";
+export declare class AlertsFactory {
+    private expressionRunner;
+    private expressionHelper;
+    constructor(expressionRunner: ExpressionRunner, expressionHelper: JsExpressionHelper);
+    getJsExpressionshowAlert(question: QuestionBase, control: AfeFormControl | AfeFormArray | AfeFormGroup, form?: Form): Alert;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AlertsFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AlertsFactory>;
+}

package/form-entry/form-factory/validation.factory.d.ts

@@ -0,0 +1,25 @@
+import { Validators } from '@angular/forms';
+import { ConditionalRequiredValidator } from '../validators/conditional-required.validator';
+import { ConditionalAnsweredValidator } from '../validators/conditional-answered.validator';
+import { JsExpressionValidator } from '../validators/js-expression.validator';
+import { QuestionBase } from '../question-models/question-base';
+import * as i0 from "@angular/core";
+export declare class ValidationFactory {
+    constructor();
+    getValidators(question: QuestionBase, form?: any): any[];
+    get conditionalRequiredValidator(): ConditionalRequiredValidator;
+    get conditionalAnsweredValidator(): ConditionalAnsweredValidator;
+    get requiredValidator(): any;
+    get dateValidator(): any;
+    get futureDateRestrictionValidator(): any;
+    get maxDateValidator(): any;
+    get minDateValidator(): any;
+    get minLengthValidator(): any;
+    get maxLengthValidator(): typeof Validators.maxLength;
+    getMinValueValidator(min: number): any;
+    getMaxValueValidator(max: number): any;
+    get jsExpressionValidator(): JsExpressionValidator;
+    errors(errors: any, question: QuestionBase): Array<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidationFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ValidationFactory>;
+}

package/form-entry/form-renderer/form-renderer.component.d.ts

@@ -0,0 +1,63 @@
+import { OnInit, OnChanges, SimpleChanges } from '@angular/core';
+import { DataSources } from '../data-sources/data-sources';
+import { NodeBase, LeafNode } from '../form-factory/form-node';
+import { AfeFormGroup } from '../../abstract-controls-extension/afe-form-group';
+import { ValidationFactory } from '../form-factory/validation.factory';
+import { DataSource } from '../question-models/interfaces/data-source';
+import { FormErrorsService } from '../services/form-errors.service';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare class FormRendererComponent implements OnInit, OnChanges {
+    private validationFactory;
+    private dataSources;
+    private formErrorsService;
+    translate: TranslateService;
+    private document;
+    parentComponent: FormRendererComponent;
+    node: NodeBase;
+    parentGroup: AfeFormGroup;
+    theme: string;
+    labelMap: Object;
+    controlId: String;
+    childComponents: FormRendererComponent[];
+    showTime: boolean;
+    showWeeks: boolean;
+    activeTab: number;
+    dataSource: DataSource;
+    isCollapsed: boolean;
+    auto: any;
+    followFocus: boolean;
+    cacheActive: boolean;
+    isNavigation: boolean;
+    type: string;
+    inlineDatePicker: Date;
+    constructor(validationFactory: ValidationFactory, dataSources: DataSources, formErrorsService: FormErrorsService, translate: TranslateService, document: any);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    addChildComponent(child: FormRendererComponent): void;
+    setUpRemoteSelect(): void;
+    setUpFileUpload(): void;
+    loadLabels(): void;
+    checkSection(node: NodeBase): boolean;
+    clickTab(tabNumber: number): void;
+    loadPreviousTab(): void;
+    isCurrentTabFirst(): boolean;
+    isCurrentTabLast(): boolean;
+    loadNextTab(): void;
+    tabSelected($event: any): void;
+    setPreviousTab(): void;
+    hasErrors(): boolean;
+    errors(): string[];
+    scrollToControl(error: string): void;
+    onDateChanged(node: LeafNode): void;
+    upload(event: any): void;
+    toggleInformation(infoId: any): void;
+    private getErrors;
+    showErrors(): boolean;
+    get errorNodes(): any;
+    getControlError(node: LeafNode): string[];
+    announceErrorField(errorNode: LeafNode): void;
+    getPageIndex(node: NodeBase): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormRendererComponent, "ofe-form-renderer", never, { "parentComponent": "parentComponent"; "node": "node"; "parentGroup": "parentGroup"; "theme": "theme"; "labelMap": "labelMap"; "controlId": "controlId"; }, {}, never, never>;
+}

package/form-entry/helpers/historical-expression-helper-service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class HistoricalHelperService {
+    constructor();
+    evaluate(expr: string, dataSources: Record<string, unknown>, additionalScopeValues: Record<string, unknown> | null): any;
+    evaluatePrecondition(expr: string, dataSources: any, historicalValue: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoricalHelperService>;
+}

package/form-entry/helpers/historical-field-helper-service.d.ts

@@ -0,0 +1,7 @@
+import { QuestionBase } from '../question-models/question-base';
+import * as i0 from "@angular/core";
+export declare class HistoricalFieldHelperService {
+    getDisplayTextFromOptions(question: QuestionBase, valueProperty: string, displayProperty: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HistoricalFieldHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HistoricalFieldHelperService>;
+}