@iapps/ng-dhis2-ui 1.2.102 → 1.2.104

package/index.d.ts

@@ -1,13 +1,1311 @@
-export * from './lib/modules/header-bar';
-export * from './lib/modules/button';
-export * from './lib/modules/breadcrumb';
-export * from './lib/modules/period-selector';
-export * from './lib/modules/organisation-unit-selector';
-export * from './lib/modules/react-wrapper/react-wrapper.component';
-export * from './lib/modules/line-list';
-export * from './lib/modules/data-table-ui';
-export * from './lib/modules/form';
-export * from './lib/modules/selection-filters-ui';
-export * from './lib/modules/tracker-form';
-export * from './lib/modules/event-form';
-export * from './lib/modules/program-entry-form';
+import * as i0 from '@angular/core';
+import { OnDestroy, AfterViewInit, ElementRef, EventEmitter, NgZone, SimpleChanges, OnChanges, OnInit, EffectRef, Signal } from '@angular/core';
+import { NgxDhis2HttpClientService } from '@iapps/ngx-dhis2-http-client';
+import React, { ComponentProps } from 'react';
+import * as ReactDOM from 'react-dom/client';
+import * as i2 from '@angular/common';
+import * as _iapps_d2_web_sdk from '@iapps/d2-web-sdk';
+import { TrackedEntityInstance, DHIS2Event, DataQueryFilter, EnrollmentStatus, EventStatus, Option as Option$1, ProgramRuleAction, ProgramRuleVariable, ProgramRule, Program, BaseTrackerQuery, BaseEventQuery, D2EventResponse, D2TrackerResponse } from '@iapps/d2-web-sdk';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import * as i8 from '@angular/forms';
+import { FormGroup, FormControl, UntypedFormGroup } from '@angular/forms';
+import * as _dhis2_ui_loader from '@dhis2-ui/loader';
+import * as _dhis2_app_service_config from '@dhis2/app-service-config';
+
+declare class ReactWrapperModule implements OnDestroy, AfterViewInit {
+    protected elementRef: ElementRef<HTMLElement>;
+    props?: ComponentProps<any>;
+    component: any;
+    content: ElementRef<HTMLElement>;
+    protected reactDomRoot?: ReactDOM.Root;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    protected render(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReactWrapperModule, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReactWrapperModule, "ng-dhis2-ui-wrapper", never, { "props": { "alias": "props"; "required": false; }; "component": { "alias": "component"; "required": false; }; }, {}, ["content"], never, true, never>;
+}
+
+declare class HeaderBarComponent extends ReactWrapperModule {
+    private httpClient;
+    constructor(elementRef: ElementRef<HTMLElement>, httpClient: NgxDhis2HttpClientService);
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderBarComponent, "ng-dhis2-ui-header-bar", never, {}, {}, never, never, false, never>;
+}
+
+declare class SharedDhis2UiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SharedDhis2UiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SharedDhis2UiModule, never, [typeof i2.CommonModule], never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SharedDhis2UiModule>;
+}
+
+declare class HeaderBarModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderBarModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeaderBarModule, [typeof HeaderBarComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule], [typeof HeaderBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeaderBarModule>;
+}
+
+declare class ButtonComponent extends ReactWrapperModule {
+    label: string;
+    primary?: boolean;
+    secondary?: boolean;
+    destructive?: boolean;
+    disabled?: boolean;
+    small?: boolean;
+    large?: boolean;
+    buttonClick: EventEmitter<any>;
+    ngAfterViewInit(): Promise<void>;
+    ngOnInit(): void;
+    onButtonClick(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "ng-dhis2-ui-button", never, { "label": { "alias": "label"; "required": false; }; "primary": { "alias": "primary"; "required": false; }; "secondary": { "alias": "secondary"; "required": false; }; "destructive": { "alias": "destructive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "small": { "alias": "small"; "required": false; }; "large": { "alias": "large"; "required": false; }; }, { "buttonClick": "buttonClick"; }, never, ["*"], false, never>;
+}
+
+declare class ButtonModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ButtonModule, [typeof ButtonComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule], [typeof ButtonComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ButtonModule>;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    url: string;
+    icon?: string;
+    selected?: boolean;
+}
+
+declare class BreadcrumbComponent extends ReactWrapperModule {
+    #private;
+    breadcrumbs: i0.InputSignal<BreadcrumbItem[]>;
+    selectBreadcrumb: EventEmitter<BreadcrumbItem>;
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "ng-dhis2-ui-breadcrumb", never, { "breadcrumbs": { "alias": "breadcrumbs"; "required": true; "isSignal": true; }; }, { "selectBreadcrumb": "selectBreadcrumb"; }, never, ["*"], false, never>;
+}
+
+declare class BreadcrumbModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BreadcrumbModule, [typeof BreadcrumbComponent], [typeof i2.CommonModule], [typeof BreadcrumbComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BreadcrumbModule>;
+}
+
+type PeriodSelectionEvent = {
+    dimensionId: string;
+    items: Record<string, unknown>[];
+};
+declare class PeriodSelectorComponent extends ReactWrapperModule {
+    private ngZone;
+    d2: _iapps_d2_web_sdk.D2Web;
+    selectedPeriods: any[];
+    selectPeriods: EventEmitter<any>;
+    props: Record<string, unknown>;
+    constructor(elementRef: ElementRef<HTMLElement>, ngZone: NgZone);
+    ngAfterViewInit(): Promise<void>;
+    onSelectItems(selectionEvent: PeriodSelectionEvent): void;
+    getExcludedPeriodTypes: (systemSettings?: any) => any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PeriodSelectorComponent, "ng-dhis2-ui-period-selector", never, { "selectedPeriods": { "alias": "selectedPeriods"; "required": false; }; }, { "selectPeriods": "selectPeriods"; }, never, never, false, never>;
+}
+
+declare class PeriodSelectorModalComponent extends ReactWrapperModule {
+    d2: _iapps_d2_web_sdk.D2Web;
+    selectedPeriods: any[];
+    cancel: EventEmitter<any>;
+    confirm: EventEmitter<any>;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): Promise<void>;
+    onCancel(): void;
+    onConfirm(selectedItems: any[]): void;
+    getExcludedPeriodTypes: (systemSettings?: any) => any[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodSelectorModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PeriodSelectorModalComponent, "ng-dhis2-ui-period-selector-modal", never, { "selectedPeriods": { "alias": "selectedPeriods"; "required": false; }; }, { "cancel": "cancel"; "confirm": "confirm"; }, never, never, false, never>;
+}
+
+declare class PeriodSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PeriodSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PeriodSelectorModule, [typeof PeriodSelectorComponent, typeof PeriodSelectorModalComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule], [typeof PeriodSelectorComponent, typeof PeriodSelectorModalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PeriodSelectorModule>;
+}
+
+type OrganisationUnitSelectionUsageType = 'DATA_ENTRY' | 'DATA_VIEW';
+declare class OrganisationUnitSelectionConfig {
+    hideGroupSelect: boolean;
+    hideLevelSelect: boolean;
+    hideUserOrgUnits: boolean;
+    usageType: OrganisationUnitSelectionUsageType;
+    minLevel?: number;
+    allowSingleSelection?: boolean;
+    batchSize?: number;
+    additionalQueryFields?: string[];
+    allowCaching?: boolean;
+    constructor(params?: Partial<OrganisationUnitSelectionConfig>);
+}
+
+type OrganisationUnitSelectionEvent$1 = {
+    dimensionId: string;
+    items: Record<string, unknown>[];
+};
+declare class OrganisationUnitSelectorComponent extends ReactWrapperModule {
+    private ngZone;
+    d2: _iapps_d2_web_sdk.D2Web;
+    selectedOrgUnits: any[];
+    orgUnitSelectionConfig: OrganisationUnitSelectionConfig;
+    selectOrgUnits: EventEmitter<any>;
+    props: Record<string, unknown>;
+    constructor(elementRef: ElementRef<HTMLElement>, ngZone: NgZone);
+    ngAfterViewInit(): Promise<void>;
+    private getAppConfig;
+    getOrgUnitAttributeByUsage(usageType: OrganisationUnitSelectionUsageType): "organisationUnits" | "dataViewOrganisationUnits";
+    getRootOrgUnits(): Promise<string[]>;
+    getOrgUnitGroups(): Promise<any>;
+    getOrgUnitLevels(): Promise<any>;
+    onSelectItems(selectionEvent: OrganisationUnitSelectionEvent$1): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganisationUnitSelectorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OrganisationUnitSelectorComponent, "ng-dhis2-ui-org-unit-selector", never, { "selectedOrgUnits": { "alias": "selectedOrgUnits"; "required": false; }; "orgUnitSelectionConfig": { "alias": "orgUnitSelectionConfig"; "required": false; }; }, { "selectOrgUnits": "selectOrgUnits"; }, never, never, false, never>;
+}
+
+type OrganisationUnitSelectionEvent = {
+    dimensionId: string;
+    items: Record<string, unknown>[];
+};
+declare class OrganisationUnitSelectorModalComponent extends ReactWrapperModule {
+    d2: _iapps_d2_web_sdk.D2Web;
+    selectedOrgUnits: any[];
+    orgUnitSelectionConfig: OrganisationUnitSelectionConfig;
+    selectOrgUnits: EventEmitter<any>;
+    cancel: EventEmitter<any>;
+    confirm: EventEmitter<any>;
+    props: Record<string, unknown>;
+    constructor(elementRef: ElementRef<HTMLElement>);
+    ngAfterViewInit(): Promise<void>;
+    onCancel(): void;
+    onConfirm(selectedItems: any[]): void;
+    private getAppConfig;
+    getOrgUnitAttributeByUsage(usageType: OrganisationUnitSelectionUsageType): "organisationUnits" | "dataViewOrganisationUnits";
+    getRootOrgUnits(): Promise<string[]>;
+    getOrgUnitGroups(): Promise<any>;
+    getOrgUnitLevels(): Promise<any>;
+    onSelectItems(selectionEvent: OrganisationUnitSelectionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganisationUnitSelectorModalComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<OrganisationUnitSelectorModalComponent, "ng-dhis2-ui-org-unit-selector-modal", never, { "selectedOrgUnits": { "alias": "selectedOrgUnits"; "required": false; }; "orgUnitSelectionConfig": { "alias": "orgUnitSelectionConfig"; "required": false; }; }, { "selectOrgUnits": "selectOrgUnits"; "cancel": "cancel"; "confirm": "confirm"; }, never, never, false, never>;
+}
+
+declare class OrganisationUnitSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<OrganisationUnitSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<OrganisationUnitSelectorModule, [typeof OrganisationUnitSelectorComponent, typeof OrganisationUnitSelectorModalComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule], [typeof OrganisationUnitSelectorComponent, typeof OrganisationUnitSelectorModalComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<OrganisationUnitSelectorModule>;
+}
+
+type ActionOptionOrientation = 'DROPDOWN' | 'BUTTON' | 'LINK';
+
+interface DropdownMenuOption$1 {
+    id?: string;
+    label: string;
+    action?: string;
+    description?: string;
+    iconOnly?: boolean;
+    icon?: any;
+    destructive?: boolean;
+}
+
+interface LineListActionOption extends DropdownMenuOption$1 {
+    condition?: string;
+    onClick?: (tableRow: TrackedEntityInstance | DHIS2Event) => void;
+}
+
+interface AttributeFilter {
+    attribute?: string;
+    dataElement?: string;
+    operator: string;
+    value: string | number;
+}
+
+declare class LineListService {
+    private httpClient;
+    constructor(httpClient: NgxDhis2HttpClientService);
+    /**
+      * Fetch orgUnit names for given orgUnit IDs
+      */
+    fetchOrgUnits(orgUnitIds: string[]): Observable<Map<string, string>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LineListService>;
+}
+
+declare class LineListTableComponent extends ReactWrapperModule {
+    triggerToken: string;
+    programId: string;
+    orgUnit: string;
+    programStageId?: string;
+    actionOptions?: LineListActionOption[];
+    actionOptionOrientation: ActionOptionOrientation;
+    attributeFilters?: AttributeFilter[];
+    useOuModeWithOlderDHIS2Instance?: boolean;
+    startDate?: string;
+    endDate?: string;
+    dataQueryFilters?: DataQueryFilter[];
+    ouMode?: string;
+    isButtonLoading: boolean;
+    buttonFilter: string;
+    filterRootOrgUnit: boolean;
+    showFilters: boolean;
+    isOptionSetNameVisible: boolean;
+    allowRowsSelection: boolean;
+    enrollmentStatus: EnrollmentStatus;
+    filterableColumnIds: string[];
+    triggerRefetch: boolean;
+    eventStatus: {
+        programStage: string;
+        status: EventStatus;
+    };
+    actionSelected: EventEmitter<{
+        action: string;
+        data: TrackedEntityInstance | DHIS2Event;
+    }>;
+    rowsSelected: EventEmitter<DHIS2Event[] | TrackedEntityInstance[]>;
+    showActionButtons: boolean;
+    showEnrollmentDates: boolean;
+    showDownloadButton: boolean;
+    searcheableDataElements: string[];
+    private reactStateUpdaters;
+    setReactStateUpdaters: (updaters: any) => void;
+    ngOnChanges(changes: SimpleChanges): void;
+    lineListService: LineListService;
+    LineList: () => React.DetailedReactHTMLElement<null, HTMLElement>;
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineListTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LineListTableComponent, "ng-dhis2-ui-line-list", never, { "triggerToken": { "alias": "triggerToken"; "required": false; }; "programId": { "alias": "programId"; "required": false; }; "orgUnit": { "alias": "orgUnit"; "required": false; }; "programStageId": { "alias": "programStageId"; "required": false; }; "actionOptions": { "alias": "actionOptions"; "required": false; }; "actionOptionOrientation": { "alias": "actionOptionOrientation"; "required": false; }; "attributeFilters": { "alias": "attributeFilters"; "required": false; }; "useOuModeWithOlderDHIS2Instance": { "alias": "useOuModeWithOlderDHIS2Instance"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "dataQueryFilters": { "alias": "dataQueryFilters"; "required": false; }; "ouMode": { "alias": "ouMode"; "required": false; }; "isButtonLoading": { "alias": "isButtonLoading"; "required": false; }; "buttonFilter": { "alias": "buttonFilter"; "required": false; }; "filterRootOrgUnit": { "alias": "filterRootOrgUnit"; "required": false; }; "showFilters": { "alias": "showFilters"; "required": false; }; "isOptionSetNameVisible": { "alias": "isOptionSetNameVisible"; "required": false; }; "allowRowsSelection": { "alias": "allowRowsSelection"; "required": false; }; "enrollmentStatus": { "alias": "enrollmentStatus"; "required": false; }; "filterableColumnIds": { "alias": "filterableColumnIds"; "required": false; }; "triggerRefetch": { "alias": "triggerRefetch"; "required": false; }; "eventStatus": { "alias": "eventStatus"; "required": false; }; "showActionButtons": { "alias": "showActionButtons"; "required": false; }; "showEnrollmentDates": { "alias": "showEnrollmentDates"; "required": false; }; "showDownloadButton": { "alias": "showDownloadButton"; "required": false; }; "searcheableDataElements": { "alias": "searcheableDataElements"; "required": false; }; }, { "actionSelected": "actionSelected"; "rowsSelected": "rowsSelected"; }, never, ["*"], false, never>;
+}
+
+declare class LineListModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LineListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LineListModule, [typeof LineListTableComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule, typeof ReactWrapperModule], [typeof LineListTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LineListModule>;
+}
+
+interface TableRow$1 {
+    [key: string]: string | number;
+    index: number;
+}
+interface ColumnDefinition {
+    column: string;
+    display: string;
+    index?: string;
+    visible?: boolean;
+}
+
+interface DropdownMenuOption {
+    id?: string;
+    label: string;
+    description?: string;
+    icon?: any;
+    destructive?: boolean;
+    onClick?: Function;
+}
+
+declare class DataTableUIComponent extends ReactWrapperModule implements AfterViewInit, OnChanges {
+    data: TableRow$1[];
+    columnDefinitions: ColumnDefinition[];
+    actionOptions?: DropdownMenuOption[];
+    actionSelected: EventEmitter<{
+        action: string;
+        row: TableRow$1;
+    }>;
+    DataTableUI: () => React.DetailedReactHTMLElement<null, HTMLElement>;
+    ngAfterViewInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableUIComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DataTableUIComponent, "app-data-table-ui", never, { "data": { "alias": "data"; "required": false; }; "columnDefinitions": { "alias": "columnDefinitions"; "required": false; }; "actionOptions": { "alias": "actionOptions"; "required": false; }; }, { "actionSelected": "actionSelected"; }, never, ["*"], false, never>;
+}
+
+declare class DataTableUIModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DataTableUIModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DataTableUIModule, [typeof DataTableUIComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule, typeof ReactWrapperModule], [typeof DataTableUIComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DataTableUIModule>;
+}
+
+interface IFieldDropdown {
+    key: string;
+    value: string;
+    label: string;
+    order?: number;
+    code?: string;
+}
+
+type FieldControlType = 'dropdown' | 'multi-dropdown' | 'textbox' | 'textarea' | 'checkbox' | 'date' | 'date-time' | 'image' | 'org-unit' | 'file' | 'boolean' | 'transfer' | 'search';
+
+type FormFieldMetaType = 'DATA_ELEMENT' | 'ATTRIBUTE';
+
+interface FormFieldExtension {
+    id: string;
+    accept?: string[];
+    sizeLimit?: number;
+    isDataElementUnique?: boolean;
+}
+
+interface IFormField<T> {
+    value?: T | '';
+    id: string;
+    code?: string;
+    key: string;
+    referenceKey?: string;
+    label: string;
+    required: boolean;
+    order?: number;
+    controlType: FieldControlType;
+    type: string;
+    disabled?: boolean;
+    options?: IFieldDropdown[];
+    placeholder?: string;
+    min?: number | Date | string;
+    max?: number | Date | string;
+    maxLength?: number | string;
+    hidden: boolean;
+    units?: string;
+    generated?: boolean;
+    isDataElement?: boolean;
+    isAttribute?: boolean;
+    isOrgUnit?: boolean;
+    isEnrollmentDate?: boolean;
+    event?: string;
+    programStage?: string;
+    program?: string;
+    trackedEntityInstance?: string;
+    trackedEntityType?: string;
+    hasOptions?: boolean;
+    dependentField?: any;
+    fieldOptionsDependsOn?: string;
+    displayInList?: boolean;
+    displayInReports?: boolean;
+    searchable?: boolean;
+    unique?: boolean;
+    metaType?: FormFieldMetaType;
+    stepId?: string;
+    availableOptionsLabel?: string;
+    selectedOptionsLabel?: string;
+    allowFutureDate?: boolean;
+    extension?: FormFieldExtension;
+}
+
+declare enum FieldType {
+    TEXT = "TEXT",
+    MULTI_TEXT = "MULTI_TEXT",
+    TRUE_ONLY = "TRUE_ONLY",
+    LONG_TEXT = "LONG_TEXT",
+    BOOLEAN = "BOOLEAN",
+    NUMBER = "NUMBER",
+    INTEGER_ZERO_OR_POSITIVE = "INTEGER_ZERO_OR_POSITIVE",
+    IMAGE = "IMAGE",
+    FILE_RESOURCE = "FILE_RESOURCE",
+    DATE = "DATE",
+    DATE_TIME = "DATETIME",
+    ORG_UNIT = "ORGANISATION_UNIT",
+    PHONE_NUMBER = "PHONE_NUMBER",
+    EMAIL = "EMAIL"
+}
+
+interface FormGroupField {
+    id: string;
+    label?: string;
+    formName?: string;
+    fieldType: 'ATTRIBUTE' | 'DATA_ELEMENT' | 'ORG_UNIT' | 'ENROLLMENT_DATE' | 'CUSTOM';
+    disabled?: boolean;
+    mandatory?: boolean;
+    fieldOptionsDependsOn?: string;
+    optionType?: 'ORG_UNIT' | 'PORT_OF_ENTRY' | 'CUSTOM';
+    hasOptions?: boolean;
+    valueType?: string;
+    openFutureDays?: number;
+    openPreviousDays?: number;
+    skipSaving?: boolean;
+    stageId?: string;
+    trackedEntityInstance?: string;
+    event?: string;
+    min?: number | Date | string;
+    max?: number | Date | string;
+    optionSet?: any;
+    translations?: any;
+}
+interface FormFieldGroup$1 {
+    id: string;
+    name: string;
+    translations?: any;
+    isFormHorizontal?: boolean;
+    attributes?: string[] | object[];
+    dataElements?: string[] | object[];
+    booleanGroupedDataElements?: string[] | object[];
+    fields: any[];
+    repeatableStage?: string;
+    repeatDependentField?: string;
+}
+interface FormSection {
+    id: string;
+    name: string;
+    sectionStateComplete?: boolean;
+    description?: string;
+    translations?: any;
+    fieldGroups: FormFieldGroup$1[];
+}
+interface AddtionalAttributeFilter {
+    attribute: string;
+    value: any;
+}
+interface FormConfiguration {
+    id: string;
+    name: string;
+    description?: string;
+    program: string;
+    topOrgUnit?: string;
+    trackedEntityType?: string;
+    autoFilledAttributes?: string[];
+    reservedAttribute?: string;
+    sections: FormSection[];
+    additionalAttributeFilters?: AddtionalAttributeFilter[];
+    downloadSqlView?: string;
+    sectionCategories?: Record<string, string[]>;
+    optionGroups?: string[];
+    dataElementGroup?: string[];
+}
+
+interface IFormFieldGroup {
+    dataKey?: string;
+    id: string;
+    name?: string;
+    sortOrder?: number;
+    translations?: any;
+    isFormHorizontal?: boolean;
+    attributes?: string[] | object[];
+    dataElements?: string[] | object[];
+    booleanGroupedDataElements?: string[] | object[];
+    fields: IFormField<string>[];
+    repeatableStage?: string;
+    repeatDependentField?: string;
+}
+
+interface IFormMetadataSection {
+    id: string;
+    name: string;
+    program?: string;
+    sectionStateComplete?: boolean;
+    description?: string;
+    translations?: any;
+    fieldGroups: IFormFieldGroup[];
+}
+
+interface IFormMetadata {
+    id: string;
+    name: string;
+    description?: string;
+    fields: IFormField<string>[];
+    sections: IFormMetadataSection[];
+    rules: any[];
+    downloadSqlView?: string;
+}
+
+interface FormFieldFunction<T> {
+    setMax: (field: Partial<IFormField<T>>) => string | number | Date | undefined;
+}
+declare class FormField<T> implements IFormField<T>, FormFieldFunction<T> {
+    value?: T | '';
+    id: string;
+    code?: string;
+    key: string;
+    referenceKey?: string;
+    label: string;
+    required: boolean;
+    order?: number;
+    controlType: FieldControlType;
+    type: string;
+    disabled?: boolean;
+    options?: IFieldDropdown[];
+    placeholder?: string;
+    min?: number | Date | string;
+    max?: number | Date | string;
+    maxLength?: number | string;
+    hidden: boolean;
+    units?: string;
+    generated?: boolean;
+    unique?: boolean;
+    isDataElement?: boolean;
+    isAttribute?: boolean;
+    isOrgUnit?: boolean;
+    isEnrollmentDate?: boolean;
+    event?: string;
+    programStage?: string;
+    program?: string;
+    trackedEntityInstance?: string;
+    trackedEntityType?: string;
+    hasOptions?: boolean;
+    dependentField?: any;
+    fieldOptionsDependsOn?: string;
+    displayInList?: boolean;
+    displayInReports?: boolean;
+    searchable?: boolean;
+    metaType?: FormFieldMetaType;
+    stepId?: string;
+    availableOptionsLabel?: string;
+    selectedOptionsLabel?: string;
+    allowFutureDate?: boolean;
+    extension?: FormFieldExtension;
+    constructor(options?: Partial<FormField<T>>);
+    setMax(field: Partial<FormField<T>>): string | number | Date | undefined;
+}
+
+declare class Boolean extends FormField<string> {
+    controlType: FieldControlType;
+}
+
+declare class CheckBox extends FormField<string> {
+    controlType: FieldControlType;
+}
+
+declare class DateField extends FormField<string> {
+    controlType: FieldControlType;
+    type: string;
+    constructor(field: Partial<DateField>);
+}
+
+interface DropdownOption {
+    key: string;
+    value: string;
+    label: string;
+    order?: number;
+}
+
+declare class Dropdown extends FormField<string> {
+    controlType: FieldControlType;
+}
+
+interface FieldsData {
+    [uuid: string]: FieldData;
+}
+interface FieldData {
+    uuid: string;
+    latest: any;
+    history: any[];
+}
+
+declare class FieldConfig {
+    hideLabel?: boolean;
+    inputWidth: string;
+    constructor(config?: Partial<FieldConfig>);
+}
+
+declare class DateRangeValue {
+    startDate: string;
+    endDate: string;
+}
+
+declare class FieldDropdown implements IFieldDropdown {
+    key: string;
+    value: string;
+    label: string;
+    order?: number | undefined;
+    constructor(params: IFieldDropdown);
+    toJson(): IFieldDropdown;
+    static getDropdownOptions(field: any, locale?: string): FieldDropdown[];
+}
+
+type FormDirection = 'horizontal' | 'vertical';
+declare class FormConfig {
+    direction: FormDirection;
+    showSaveButton: boolean;
+    formName?: string;
+    fieldConfig: FieldConfig;
+    constructor(config?: Partial<FormConfig>);
+    get directionClassName(): "form-vertical" | "form-horizontal";
+}
+
+declare class FormFieldGroup implements IFormFieldGroup {
+    private params;
+    id: string;
+    name: string;
+    translations?: any;
+    isFormHorizontal?: boolean | undefined;
+    attributes?: string[] | object[] | undefined;
+    dataElements?: string[] | object[] | undefined;
+    booleanGroupedDataElements?: string[] | object[] | undefined;
+    repeatableStage?: string | undefined;
+    repeatDependentField?: string | undefined;
+    dataKey?: string | undefined;
+    constructor(params: {
+        formFieldGroup: Partial<FormFieldGroup>;
+        fieldMetaData: Record<string, unknown>[];
+        locale?: string;
+        formFieldExtensions?: FormFieldExtension[];
+    });
+    get fields(): IFormField<string>[];
+    toJson(): IFormFieldGroup;
+}
+
+interface JsonTransformer<T> {
+    toJson: () => T;
+}
+interface IMetadataRuleAction {
+    field: string;
+    actionType: string;
+    assignedData?: string;
+    displayedContent?: string;
+    options?: Partial<Option$1>[];
+}
+declare class MetadataRuleAction implements IMetadataRuleAction, JsonTransformer<IMetadataRuleAction> {
+    private ruleAction;
+    private ruleVariables;
+    constructor(ruleAction: ProgramRuleAction, ruleVariables: ProgramRuleVariable[]);
+    get field(): string;
+    get actionType(): string;
+    get assignedData(): string | undefined;
+    get displayedContent(): string | undefined;
+    get options(): Partial<Option$1>[] | undefined;
+    toJson(): IMetadataRuleAction;
+}
+interface IMetadataRule {
+    actions: IMetadataRuleAction[];
+    condition: string;
+}
+declare class MetadataRule implements IMetadataRule, JsonTransformer<IMetadataRule> {
+    private rule;
+    private ruleVariables;
+    constructor(rule: ProgramRule, ruleVariables: ProgramRuleVariable[]);
+    get actions(): MetadataRuleAction[];
+    get condition(): string;
+    toJson(): IMetadataRule;
+}
+
+declare class FormMetadataSection implements IFormMetadataSection {
+    private params;
+    id: string;
+    name: string;
+    program?: string | undefined;
+    sectionStateComplete?: boolean | undefined;
+    description?: string | undefined;
+    translations?: any;
+    inheritedAttributes: any[];
+    constructor(params: {
+        section: Partial<IFormMetadataSection>;
+        program: Record<string, unknown>;
+        locale?: string;
+        excludeInheritedAttributes?: boolean;
+        formFieldExtensions?: FormFieldExtension[];
+    });
+    get attributes(): {
+        sortOrder: unknown;
+        mandatory: unknown;
+        allowFutureDate: unknown;
+        trackedEntityType: unknown;
+        metaType: string;
+    }[];
+    get dataElements(): {
+        mandatory: unknown;
+        allowFutureDate: unknown;
+        stepId: unknown;
+        metaType: string;
+    }[];
+    get fieldGroups(): IFormFieldGroup[];
+    toJson(): IFormMetadataSection;
+}
+
+declare class FormMetaData implements IFormMetadata {
+    #private;
+    private params;
+    id: string;
+    name: string;
+    description?: string | undefined;
+    downloadSqlView?: string | undefined;
+    constructor(params: {
+        programs: Program[];
+        locale?: string;
+        splitRegistrationSection?: boolean;
+        includeAllProgramStages?: boolean;
+        disableEnrollmentDate?: boolean;
+        excludeInheritedAttributes?: boolean;
+        programStage?: string;
+        customFormMetaData?: Partial<FormMetaData>;
+        formFieldExtensions?: FormFieldExtension[];
+    });
+    get sections(): IFormMetadataSection[];
+    get fields(): IFormField<string>[];
+    get rules(): IMetadataRule[];
+    toJson(): IFormMetadata;
+}
+
+declare class FormValue {
+    form: FormGroup;
+    fields: IFormField<string>[];
+    changedField?: IFormField<string>;
+    constructor(form: FormGroup, fields: IFormField<string>[], changedField?: IFormField<string>);
+    get isValid(): boolean;
+    clear(): void;
+    getValues(options?: {
+        valueOnly?: boolean;
+    }): {
+        [id: string]: {
+            id: string;
+            value: string;
+            options: any[];
+        };
+    };
+}
+
+interface EocForm {
+    id: string;
+    uuid: string;
+    name: string;
+    setMembers: EocForm[];
+    options?: DropdownOption[];
+    dataType?: string;
+    formClass: string;
+    formField?: FormField<string>;
+    formFields: FormField<string>[];
+    concept?: any;
+}
+
+type CustomOrgUnitConfig = {
+    field: string;
+    orgUnit: string;
+};
+
+declare class FormFieldComponent implements OnInit, OnChanges, OnDestroy {
+    #private;
+    field: i0.InputSignal<IFormField<string>>;
+    fieldConfig: i0.InputSignal<FieldConfig>;
+    form: FormGroup;
+    isCheckBoxButton: i0.InputSignal<boolean>;
+    fieldClass: i0.InputSignal<string>;
+    programRuleActions: i0.InputSignal<IMetadataRuleAction[]>;
+    dataEntities: i0.InputSignal<any>;
+    minDate: i0.InputSignal<any>;
+    maxDate: i0.InputSignal<Date>;
+    dataId: i0.InputSignal<string>;
+    customOrgUnitRoots: i0.InputSignal<CustomOrgUnitConfig[]>;
+    color: string;
+    fieldUpdate: EventEmitter<FormGroup>;
+    immediateFieldUpdate: EventEmitter<{
+        value: string;
+    }>;
+    runtimeOptionChange: EventEmitter<any>;
+    value: i0.WritableSignal<any>;
+    runtimeError: i0.WritableSignal<string>;
+    private _runtimeOptions;
+    runtimeOptions: any;
+    fieldFilterControl: FormControl;
+    protected _onDestroy: Subject<void>;
+    optionSearchTerm: string;
+    isValueAssigned: i0.WritableSignal<boolean>;
+    ruleProcessor: EffectRef;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    get isValid(): boolean;
+    get fieldError(): string | undefined;
+    get minErrorText(): string | undefined;
+    get maxErrorText(): string | undefined;
+    get isInvalid(): boolean;
+    get isDate(): boolean;
+    get isDateTime(): boolean;
+    get isBoolean(): boolean;
+    get isCheckbox(): boolean;
+    get isCommonField(): boolean;
+    get fieldId(): string;
+    onValueChange(): void;
+    onImmediateChange(event: {
+        value: string;
+    }): void;
+    onFieldUpdate(e?: any, isDate?: boolean, isDateTime?: boolean): void;
+    onUpdateRuntimeOptions(options: any[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "ng-dhis2-ui-form-field", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "fieldConfig": { "alias": "fieldConfig"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": false; }; "isCheckBoxButton": { "alias": "isCheckBoxButton"; "required": false; "isSignal": true; }; "fieldClass": { "alias": "fieldClass"; "required": false; "isSignal": true; }; "programRuleActions": { "alias": "programRuleActions"; "required": false; "isSignal": true; }; "dataEntities": { "alias": "dataEntities"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "dataId": { "alias": "dataId"; "required": false; "isSignal": true; }; "customOrgUnitRoots": { "alias": "customOrgUnitRoots"; "required": false; "isSignal": true; }; }, { "fieldUpdate": "fieldUpdate"; "immediateFieldUpdate": "immediateFieldUpdate"; "runtimeOptionChange": "runtimeOptionChange"; }, never, never, false, never>;
+}
+
+declare class FormComponent implements OnChanges, OnDestroy, OnInit {
+    #private;
+    formConfig: i0.InputSignal<FormConfig>;
+    fields: i0.InputSignal<IFormField<string>[]>;
+    form: i0.InputSignal<FormGroup<any>>;
+    isFormHorizontal: i0.InputSignal<boolean>;
+    showSaveButton: i0.InputSignal<boolean>;
+    fieldsData: i0.InputSignal<FieldsData>;
+    fieldClass: i0.InputSignal<string>;
+    shouldRenderAsCheckBoxesButton: i0.InputSignal<boolean>;
+    programRuleActions: i0.InputSignal<IMetadataRuleAction[]>;
+    dataEntities: i0.InputSignal<any>;
+    dataId: i0.InputSignal<string>;
+    customOrgUnitRoots: i0.InputSignal<CustomOrgUnitConfig[]>;
+    configuration: i0.Signal<FormConfig>;
+    formUpdate: EventEmitter<any>;
+    formValidityUpdate: EventEmitter<boolean>;
+    fieldComponents: FormFieldComponent[];
+    values: any;
+    get sanitizedFields(): IFormField<string>[];
+    get layoutCssClass(): string;
+    ruleProcessor: EffectRef;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    onSubmit(): void;
+    onFieldUpdate(form: FormGroup, field: IFormField<string>): void;
+    onClear(): void;
+    isFormInValid(): boolean;
+    onRunTimeOptionUpdate(result: any): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormComponent, "ng-dhis2-ui-form", never, { "formConfig": { "alias": "formConfig"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "isFormHorizontal": { "alias": "isFormHorizontal"; "required": false; "isSignal": true; }; "showSaveButton": { "alias": "showSaveButton"; "required": false; "isSignal": true; }; "fieldsData": { "alias": "fieldsData"; "required": false; "isSignal": true; }; "fieldClass": { "alias": "fieldClass"; "required": false; "isSignal": true; }; "shouldRenderAsCheckBoxesButton": { "alias": "shouldRenderAsCheckBoxesButton"; "required": false; "isSignal": true; }; "programRuleActions": { "alias": "programRuleActions"; "required": false; "isSignal": true; }; "dataEntities": { "alias": "dataEntities"; "required": false; "isSignal": true; }; "dataId": { "alias": "dataId"; "required": false; "isSignal": true; }; "customOrgUnitRoots": { "alias": "customOrgUnitRoots"; "required": false; "isSignal": true; }; }, { "formUpdate": "formUpdate"; "formValidityUpdate": "formValidityUpdate"; }, never, never, false, never>;
+}
+
+declare class RepeatableFormComponent implements OnInit {
+    #private;
+    ngZone: NgZone;
+    formObject: any;
+    formData: any;
+    fieldGroup: i0.InputSignal<IFormFieldGroup>;
+    form: FormGroup;
+    numberOfRows: number | string;
+    programRuleActions: any[];
+    events: i0.ModelSignal<unknown>;
+    program: string;
+    programStage: string;
+    repeatDependentField: string;
+    dataEntities: i0.InputSignal<Record<string, unknown>>;
+    repeatableEvents: any[];
+    repeatableData: {
+        [index: number]: FormValue;
+    };
+    repeatableStageUpdate: EventEmitter<any>;
+    repeatableFormEntities: {
+        [event: string]: FormGroup;
+    };
+    eventForm: FormGroup;
+    eventFormValue: i0.WritableSignal<FormValue>;
+    showForm: i0.WritableSignal<boolean>;
+    eventIndex: i0.WritableSignal<number>;
+    constructor();
+    get isValid(): boolean;
+    ngOnInit(): void;
+    onFormUpdate(formValue: FormValue): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RepeatableFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RepeatableFormComponent, "ng-dhis2-ui-repeatable-form", never, { "formObject": { "alias": "formObject"; "required": false; }; "formData": { "alias": "formData"; "required": false; }; "fieldGroup": { "alias": "fieldGroup"; "required": true; "isSignal": true; }; "form": { "alias": "form"; "required": false; }; "numberOfRows": { "alias": "numberOfRows"; "required": false; }; "programRuleActions": { "alias": "programRuleActions"; "required": false; }; "events": { "alias": "events"; "required": false; "isSignal": true; }; "program": { "alias": "program"; "required": false; }; "programStage": { "alias": "programStage"; "required": false; }; "repeatDependentField": { "alias": "repeatDependentField"; "required": false; }; "dataEntities": { "alias": "dataEntities"; "required": true; "isSignal": true; }; }, { "events": "eventsChange"; "repeatableStageUpdate": "repeatableStageUpdate"; }, never, never, false, never>;
+}
+
+declare class SectionFormComponent implements OnInit {
+    #private;
+    ngZone: NgZone;
+    loading: i0.InputSignal<boolean>;
+    isloading: boolean;
+    formMetaData: i0.InputSignal<IFormMetadata>;
+    dataValueEntities: i0.InputSignal<Record<string, unknown>>;
+    formGroups: Record<string, FormGroup>;
+    formValueEntity: Record<string, FormValue>;
+    repeatableFormValueEntity: Record<string, Record<number, FormValue>>;
+    ruleActions: i0.WritableSignal<any[]>;
+    save: EventEmitter<Record<string, unknown>>;
+    formUpdate: EventEmitter<Record<string, unknown>>;
+    cancel: EventEmitter<any>;
+    formValidityUpdate: EventEmitter<boolean>;
+    inValid: i0.WritableSignal<boolean>;
+    inValid$: Observable<boolean>;
+    constructor();
+    ngOnInit(): void;
+    onUpdateRepeatableStage(repeatableData: Record<number, FormValue>, fieldGroup: IFormFieldGroup): void;
+    onFormUpdate(formValue: FormValue, fieldGroupId: string): void;
+    onSubmit(): void;
+    onCancel(event?: MouseEvent): void;
+    checkIfInValid(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SectionFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SectionFormComponent, "ng-dhis2-ui-section-form", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "formMetaData": { "alias": "formMetaData"; "required": true; "isSignal": true; }; "dataValueEntities": { "alias": "dataValueEntities"; "required": true; "isSignal": true; }; }, { "save": "save"; "formUpdate": "formUpdate"; "cancel": "cancel"; "formValidityUpdate": "formValidityUpdate"; }, never, never, false, never>;
+}
+
+declare class BaseFormWrapperComponent implements OnDestroy {
+    #private;
+    ngZone: NgZone;
+    name: i0.InputSignal<string>;
+    fields: i0.InputSignal<IFormField<string>[]>;
+    rules: i0.InputSignal<IMetadataRule[]>;
+    dataValues: i0.InputSignal<Record<string, unknown>>;
+    dataId: i0.InputSignal<string>;
+    customOrgUnitRoots: i0.InputSignal<CustomOrgUnitConfig[]>;
+    ruleActions: i0.WritableSignal<IMetadataRuleAction[]>;
+    isFormValid: i0.WritableSignal<boolean>;
+    formSave: EventEmitter<Record<string, unknown>>;
+    formUpdate: EventEmitter<Record<string, unknown>>;
+    formCancel: EventEmitter<void>;
+    formValidityUpdate: EventEmitter<boolean>;
+    ruleProcessor: EffectRef;
+    constructor();
+    updateDataValues(dataValues: Record<string, unknown>): void;
+    updateFormValidity(isFormValid: boolean): void;
+    protected executeRules(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormWrapperComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormWrapperComponent, never, never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": true; "isSignal": true; }; "rules": { "alias": "rules"; "required": false; "isSignal": true; }; "dataValues": { "alias": "dataValues"; "required": false; "isSignal": true; }; "dataId": { "alias": "dataId"; "required": false; "isSignal": true; }; "customOrgUnitRoots": { "alias": "customOrgUnitRoots"; "required": false; "isSignal": true; }; }, { "formSave": "formSave"; "formUpdate": "formUpdate"; "formCancel": "formCancel"; "formValidityUpdate": "formValidityUpdate"; }, never, never, true, never>;
+}
+
+declare class FlatFormComponent extends BaseFormWrapperComponent implements OnInit {
+    formGroup: FormGroup;
+    ngOnInit(): void;
+    onFormUpdate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlatFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FlatFormComponent, "ng-dhis2-ui-flat-form", never, {}, {}, never, never, false, never>;
+}
+
+declare class BaseFormFieldComponent extends ReactWrapperModule {
+    #private;
+    ngZone: NgZone;
+    fieldType: string;
+    field: i0.InputSignal<IFormField<string>>;
+    fieldError: i0.InputSignal<string>;
+    fieldConfig: i0.InputSignal<FieldConfig>;
+    form: i0.ModelSignal<FormGroup<any>>;
+    isValid: i0.InputSignal<boolean>;
+    isValueAssigned: i0.InputSignal<boolean>;
+    dataId: i0.InputSignal<string>;
+    customOrgUnitRoots: i0.InputSignal<CustomOrgUnitConfig[]>;
+    value: i0.ModelSignal<string>;
+    protected value$: rxjs.Observable<string>;
+    protected isValueAssigned$: rxjs.Observable<boolean>;
+    protected fieldError$: rxjs.Observable<string>;
+    label: Signal<string | undefined>;
+    placeholder: Signal<string>;
+    InputField: () => React.JSX.Element;
+    update: EventEmitter<{
+        form: FormGroup;
+        value: any;
+    }>;
+    immediateUpdate: EventEmitter<{
+        form: FormGroup;
+        value: any;
+    }>;
+    ngAfterViewInit(): Promise<void>;
+    onChange(event: any): void;
+    searchForDuplicates(value: string): Promise<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseFormFieldComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseFormFieldComponent, never, never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "fieldError": { "alias": "fieldError"; "required": false; "isSignal": true; }; "fieldConfig": { "alias": "fieldConfig"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": true; "isSignal": true; }; "isValid": { "alias": "isValid"; "required": false; "isSignal": true; }; "isValueAssigned": { "alias": "isValueAssigned"; "required": false; "isSignal": true; }; "dataId": { "alias": "dataId"; "required": false; "isSignal": true; }; "customOrgUnitRoots": { "alias": "customOrgUnitRoots"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "form": "formChange"; "value": "valueChange"; "update": "update"; "immediateUpdate": "immediateUpdate"; }, never, never, true, never>;
+}
+
+declare class FormFieldItemComponent extends BaseFormFieldComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldItemComponent, "ng-dhis2-ui-form-field-item", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class D2FormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<D2FormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<D2FormModule, [typeof FormFieldComponent, typeof FormComponent, typeof RepeatableFormComponent, typeof SectionFormComponent, typeof FlatFormComponent, typeof FormFieldItemComponent], [typeof i2.CommonModule, typeof i8.ReactiveFormsModule, typeof ReactWrapperModule, typeof OrganisationUnitSelectorModule], [typeof FormFieldComponent, typeof FormComponent, typeof RepeatableFormComponent, typeof SectionFormComponent, typeof FlatFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<D2FormModule>;
+}
+
+declare class FieldUtil {
+    static getFieldDropdownOptions(field: any): DropdownOption[];
+    static sanitizeOptions(options: any[]): any;
+    static getFieldType(valueType: string): "email" | "number" | "text" | "tel" | "date" | "org-unit" | "file";
+    static getFieldControlType(valueType: string, hasOptions: boolean): FieldControlType;
+    static getOptionEntities?(options: any[]): any;
+}
+
+declare class FieldControlTypeUtil {
+    static getFieldControlType(valueType: string, hasOptions: boolean): FieldControlType;
+}
+
+declare class FormFieldTypeUtil {
+    static getFieldType(valueType: string): "number" | "text" | "image" | "org-unit" | "file";
+}
+
+declare class FormUtil {
+    static getFormGroup(fields: IFormField<string>[], dataEntities: any): UntypedFormGroup;
+    static getFieldValue(field: IFormField<string>, dataEntities: Record<string, any>): any;
+    static getFormFields(fields: any[]): FormField<string>[];
+    static createField(id: string, label: string, required: boolean, controlType: 'textbox' | 'dropdown' | 'textarea' | 'transfer' | 'search' | 'file', disabled?: boolean, placeholder?: string, options?: Array<any>): FormField<string>;
+}
+
+declare class FormValueUtil {
+    static getFormDataEntities(formValueEntities: Record<string, FormValue>): {};
+}
+
+declare class TranslationUtil {
+    static getTranslatedFormName(field: Record<string, unknown>, locale?: string): string;
+}
+
+interface SelectionFiltersProps {
+    actionOptions: ActionOption[];
+    programAttributesFilters: ProgramAttributesFilter[];
+    programStageDataElementFilters: ProgramStageDataElementFilter[];
+    startDate: string;
+    endDate: string;
+    program: string;
+    organisationUnit: string;
+}
+interface ActionOption {
+    label: string;
+    onClick: () => void;
+}
+interface Option {
+    id: string;
+    code: string;
+    name: string;
+}
+interface ProgramAttributesFilter {
+    attribute: string;
+    program: string;
+    operator: string;
+    valueType?: string;
+    name: string;
+    hasOptions: boolean;
+    shortName: string;
+    formName: string;
+    code: string;
+    value: string;
+    options: Option[];
+}
+interface ProgramStageDataElementFilter {
+    programStage: string;
+    program: string;
+    dataElement: string;
+    hasOptions: boolean;
+    valueType?: string;
+    name: string;
+    operator: string;
+    shortName: string;
+    formName: string;
+    value: string;
+    options: Option[];
+}
+interface TableRow {
+    [key: string]: string | number;
+    index: number;
+}
+
+declare class SelectionFiltersComponent extends ReactWrapperModule implements AfterViewInit {
+    d2: _iapps_d2_web_sdk.D2Web;
+    actionOptions: {
+        label: string;
+        onClick: (row: TableRow) => void;
+    }[];
+    programAttributesFilters: ProgramAttributesFilter[];
+    programStageDataElementFilters: ProgramStageDataElementFilter[];
+    startDate?: string;
+    endDate?: string;
+    program?: string;
+    organisationUnit?: string;
+    actionSelected: EventEmitter<SelectionFiltersProps>;
+    ngZone: NgZone;
+    private getAppConfig;
+    getRootOrgUnits(): Promise<string[]>;
+    getOrgUnitGroups(): Promise<any>;
+    getOrgUnitLevels(): Promise<any>;
+    onSelectOrgUnit(selectedOrgUnits: Record<string, string>[]): void;
+    getOrgUnitAttributeByUsage(usageType: string): "organisationUnits" | "dataViewOrganisationUnits";
+    FieldOrgUnitSelector: (props: {
+        onSelectOrgUnit: (selectedOrgUnits: any) => void;
+        onCancelOrgUnit: () => void;
+    }) => React.FunctionComponentElement<{
+        config: _dhis2_app_service_config.Config;
+        children: React.ReactNode;
+        offlineInterface?: any;
+        plugin: boolean;
+        parentAlertsAdd: any;
+        showAlertsInPlugin: boolean;
+    }> | React.FunctionComponentElement<_dhis2_ui_loader.CircularLoaderProps>;
+    showOrgUnitTree: i0.WritableSignal<boolean>;
+    orgUnitSelectionConfig: OrganisationUnitSelectionConfig;
+    selectedOrgUnit: i0.WritableSignal<any>;
+    selectedOrgUnit$: rxjs.Observable<any>;
+    SelectionFiltersUI: () => React.DetailedReactHTMLElement<{
+        style: {
+            fontFamily: "Arial, sans-serif";
+            padding: string;
+            backgroundColor: "#f9f9f9";
+            borderRadius: string;
+            boxShadow: "0 4px 8px rgba(0, 0, 0, 0.1)";
+        };
+    }, HTMLElement>;
+    ngAfterViewInit(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionFiltersComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionFiltersComponent, "app-selection-filters-ui", never, { "actionOptions": { "alias": "actionOptions"; "required": false; }; "programAttributesFilters": { "alias": "programAttributesFilters"; "required": false; }; "programStageDataElementFilters": { "alias": "programStageDataElementFilters"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "program": { "alias": "program"; "required": false; }; "organisationUnit": { "alias": "organisationUnit"; "required": false; }; }, { "actionSelected": "actionSelected"; }, never, ["*"], false, never>;
+}
+
+declare class SelectionFiltersUiModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionFiltersUiModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<SelectionFiltersUiModule, [typeof SelectionFiltersComponent], [typeof i2.CommonModule, typeof SharedDhis2UiModule, typeof ReactWrapperModule, typeof OrganisationUnitSelectorModule], [typeof SelectionFiltersComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<SelectionFiltersUiModule>;
+}
+
+declare class TrackerFormComponent implements OnInit {
+    program: i0.InputSignal<string>;
+    programStage: i0.InputSignal<string>;
+    trackedEntity: i0.InputSignal<string>;
+    d2: _iapps_d2_web_sdk.D2Web;
+    trackerQuery: BaseTrackerQuery<TrackedEntityInstance>;
+    formMetaData: IFormMetadata;
+    instance: TrackedEntityInstance;
+    ngOnInit(): Promise<void>;
+    onFormUpdate(values: any): void;
+    onSave(event: any): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackerFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TrackerFormComponent, "ng-dhis2-ui-tracker-form", never, { "program": { "alias": "program"; "required": true; "isSignal": true; }; "programStage": { "alias": "programStage"; "required": false; "isSignal": true; }; "trackedEntity": { "alias": "trackedEntity"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class TrackerFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackerFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TrackerFormModule, [typeof TrackerFormComponent], [typeof i2.CommonModule, typeof D2FormModule], [typeof TrackerFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TrackerFormModule>;
+}
+
+declare class EventFormComponent implements OnInit {
+    program: i0.InputSignal<string>;
+    programStage: i0.InputSignal<string>;
+    eventId: i0.InputSignal<string>;
+    enrollment: i0.InputSignal<string>;
+    trackedEntity: i0.InputSignal<string>;
+    d2: _iapps_d2_web_sdk.D2Web;
+    eventQuery: BaseEventQuery<DHIS2Event>;
+    formMetaData: IFormMetadata;
+    instance: DHIS2Event;
+    ngOnInit(): Promise<void>;
+    onFormUpdate(values: any): void;
+    onSave(event: any): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EventFormComponent, "ng-dhis2-ui-event-form", never, { "program": { "alias": "program"; "required": true; "isSignal": true; }; "programStage": { "alias": "programStage"; "required": true; "isSignal": true; }; "eventId": { "alias": "eventId"; "required": false; "isSignal": true; }; "enrollment": { "alias": "enrollment"; "required": false; "isSignal": true; }; "trackedEntity": { "alias": "trackedEntity"; "required": false; "isSignal": true; }; }, {}, never, never, false, never>;
+}
+
+declare class EventFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<EventFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<EventFormModule, [typeof EventFormComponent], [typeof i2.CommonModule, typeof D2FormModule], [typeof EventFormComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<EventFormModule>;
+}
+
+type AutoAssignedValues = {
+    field: string;
+    value: string;
+};
+interface IProgramEntryFormConfig {
+    program: string;
+    programStage?: string;
+    displayType: 'FLAT' | 'SECTION' | 'CUSTOM';
+    formType: 'TRACKER' | 'EVENT';
+    hideRegistrationUnit?: boolean;
+    hideEnrollmentDate?: boolean;
+    hideTrackedEntityTypeAttributes?: boolean;
+    disableRegistrationUnit?: boolean;
+    disableEnrollmentDate?: boolean;
+    disabledIncidentDate?: boolean;
+    excludeProgramStages?: boolean;
+    excludeInheritedAttributes?: boolean;
+    includedProgramStages?: string[];
+    submitButtonLabel?: string;
+    cancelButtonLabel?: string;
+    hideActionButtons?: boolean;
+    hideSubmitButton?: boolean;
+    hideCancelButton?: boolean;
+    ignoreRepeatability?: boolean;
+    autoAssignedValues?: AutoAssignedValues[];
+    hideCustomAssignedFields?: boolean;
+    autoComplete?: boolean;
+    formFieldExtensions?: FormFieldExtension[];
+    updateTeiOrgUnit?: boolean;
+}
+declare class ProgramEntryFormConfig implements IProgramEntryFormConfig {
+    program: string;
+    programStage?: string;
+    displayType: 'FLAT' | 'SECTION' | 'CUSTOM';
+    formType: 'TRACKER' | 'EVENT';
+    hideRegistrationUnit?: boolean;
+    hideEnrollmentDate?: boolean;
+    hideTrackedEntityTypeAttributes?: boolean;
+    disableRegistrationUnit?: boolean;
+    disableEnrollmentDate?: boolean;
+    disabledIncidentDate?: boolean;
+    excludeProgramStages?: boolean;
+    excludeInheritedAttributes?: boolean;
+    includedProgramStages?: string[];
+    submitButtonLabel: string;
+    cancelButtonLabel: string;
+    hideActionButtons?: boolean;
+    hideSubmitButton?: boolean;
+    hideCancelButton?: boolean;
+    ignoreRepeatability?: boolean;
+    autoAssignedValues?: AutoAssignedValues[];
+    hideCustomAssignedFields?: boolean;
+    autoComplete?: boolean;
+    formFieldExtensions?: FormFieldExtension[];
+    updateTeiOrgUnit: boolean;
+    constructor(config: IProgramEntryFormConfig);
+}
+
+interface IProgramEntryFormSection {
+    id: string;
+    name: string;
+    description?: string;
+    formFields: IFormField<string>[];
+    orientation: 'HORIZONTAL' | 'VERTICAL';
+}
+declare class ProgramEntryFormSection implements IProgramEntryFormSection {
+    id: string;
+    name: string;
+    description?: string;
+    formFields: IFormField<string>[];
+    orientation: 'HORIZONTAL' | 'VERTICAL';
+    constructor(props: IProgramEntryFormSection);
+}
+
+interface IProgramEntryFormMetaData {
+    id: string;
+    name: string;
+    description?: string;
+    program: Program;
+    formFields: IFormField<string>[];
+    sections: IProgramEntryFormSection[];
+    rules: IMetadataRule[];
+}
+declare class ProgramEntryFormMetaData implements IProgramEntryFormMetaData {
+    #private;
+    id: string;
+    name: string;
+    description?: string;
+    d2: _iapps_d2_web_sdk.D2Web;
+    config: ProgramEntryFormConfig;
+    program: Program;
+    setConfig(config: ProgramEntryFormConfig): ProgramEntryFormMetaData;
+    getProgramPromise(): Promise<_iapps_d2_web_sdk.D2Response<Program>>;
+    get formFields(): IFormField<string>[];
+    get sections(): IProgramEntryFormSection[];
+    get rules(): IMetadataRule[];
+    toJson(): IProgramEntryFormMetaData;
+    get(): Promise<IProgramEntryFormMetaData>;
+}
+
+declare class ProgramEntryFormModule {
+    #private;
+    config: i0.InputSignal<ProgramEntryFormConfig>;
+    trackedEntity: i0.InputSignal<string>;
+    event: i0.InputSignal<string>;
+    enrollment: i0.InputSignal<string>;
+    orgUnit: i0.InputSignal<string>;
+    customOrgUnitRoots: i0.InputSignal<CustomOrgUnitConfig[]>;
+    ngZone: NgZone;
+    d2: _iapps_d2_web_sdk.D2Web;
+    loading: i0.WritableSignal<boolean>;
+    metaData: i0.WritableSignal<IProgramEntryFormMetaData>;
+    isFormValid: i0.WritableSignal<boolean>;
+    isFormValid$: Observable<boolean>;
+    instance: i0.WritableSignal<TrackedEntityInstance | DHIS2Event>;
+    instanceQuery: BaseTrackerQuery<TrackedEntityInstance> | BaseEventQuery<DHIS2Event>;
+    instanceSave: EventEmitter<TrackedEntityInstance | DHIS2Event>;
+    instanceSaveCompleted: EventEmitter<D2EventResponse<DHIS2Event> | D2TrackerResponse<TrackedEntityInstance>>;
+    instanceUpdate: EventEmitter<TrackedEntityInstance | DHIS2Event>;
+    formValidityUpdate: EventEmitter<boolean>;
+    formCancel: EventEmitter<any>;
+    FormLoader: () => React.JSX.Element;
+    dataId: i0.Signal<any>;
+    FormActionButtons: i0.Signal<React.JSX.Element | (() => React.JSX.Element)>;
+    ngOnInit(): Promise<void>;
+    onFormUpdate(dataValues: Record<string, unknown>): void;
+    onValidityUpdate(isFormValid: boolean): void;
+    onCancel(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProgramEntryFormModule, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProgramEntryFormModule, "ng-dhis2-ui-program-entry-form", never, { "config": { "alias": "config"; "required": true; "isSignal": true; }; "trackedEntity": { "alias": "trackedEntity"; "required": false; "isSignal": true; }; "event": { "alias": "event"; "required": false; "isSignal": true; }; "enrollment": { "alias": "enrollment"; "required": false; "isSignal": true; }; "orgUnit": { "alias": "orgUnit"; "required": false; "isSignal": true; }; "customOrgUnitRoots": { "alias": "customOrgUnitRoots"; "required": false; "isSignal": true; }; }, { "instanceSave": "instanceSave"; "instanceSaveCompleted": "instanceSaveCompleted"; "instanceUpdate": "instanceUpdate"; "formValidityUpdate": "formValidityUpdate"; "formCancel": "formCancel"; }, never, never, true, never>;
+}
+
+export { Boolean, BreadcrumbComponent, BreadcrumbModule, ButtonComponent, ButtonModule, CheckBox, D2FormModule, DataTableUIComponent, DataTableUIModule, DateField, DateRangeValue, Dropdown, EventFormComponent, EventFormModule, FieldConfig, FieldControlTypeUtil, FieldDropdown, FieldType, FieldUtil, FlatFormComponent, FormComponent, FormConfig, FormField, FormFieldComponent, FormFieldGroup, FormFieldTypeUtil, FormMetaData, FormMetadataSection, FormUtil, FormValue, FormValueUtil, HeaderBarComponent, HeaderBarModule, LineListModule, LineListTableComponent, MetadataRule, MetadataRuleAction, OrganisationUnitSelectionConfig, OrganisationUnitSelectorComponent, OrganisationUnitSelectorModalComponent, OrganisationUnitSelectorModule, PeriodSelectorComponent, PeriodSelectorModalComponent, PeriodSelectorModule, ProgramEntryFormConfig, ProgramEntryFormMetaData, ProgramEntryFormModule, ProgramEntryFormSection, ReactWrapperModule, RepeatableFormComponent, SectionFormComponent, SelectionFiltersComponent, SelectionFiltersUiModule, TrackerFormComponent, TrackerFormModule, TranslationUtil };
+export type { ActionOptionOrientation, AddtionalAttributeFilter, AutoAssignedValues, BreadcrumbItem, ColumnDefinition, DropdownMenuOption$1 as DropdownMenuOption, DropdownOption, EocForm, FieldControlType, FieldData, FieldsData, FormConfiguration, FormDirection, FormFieldExtension, FormFieldMetaType, FormGroupField, FormSection, IFieldDropdown, IFormField, IFormFieldGroup, IFormMetadata, IFormMetadataSection, IMetadataRule, IMetadataRuleAction, IProgramEntryFormConfig, IProgramEntryFormMetaData, IProgramEntryFormSection, LineListActionOption, OrganisationUnitSelectionUsageType, TableRow$1 as TableRow };