import * as i0 from '@angular/core';
import { AfterViewInit, ChangeDetectorRef, TemplateRef, EventEmitter, ViewContainerRef, ComponentRef, OnDestroy } from '@angular/core';
import { FieldType, FieldFormat } from '@laserfiche/lf-ui-components/shared';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { FormControl, FormGroup, FormArray } from '@angular/forms';
import { MatCheckboxChange } from '@angular/material/checkbox';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { AppLocalizationService } from '@laserfiche/lf-ui-components/internal-shared';
import { MatSelectChange } from '@angular/material/select';

interface LfFieldInfo {
    name: string;
    id: number;
    displayName: string;
    description?: string;
    fieldType: FieldType;
    length?: number;
    defaultValue?: string;
    isMultiValue?: boolean;
    isRequired?: boolean;
    constraint?: string;
    constraintError?: string;
    listValues?: Array<string>;
    format?: FieldFormat;
    currency?: string;
    formatPattern?: string;
}
type LfFieldValue = string;
interface FieldValue {
    fieldId: number;
    fieldName?: string;
    values?: Array<{
        [key: string]: string;
    }>;
    fieldType?: FieldType;
    groupId?: number;
    flags?: number;
}
interface FieldValues {
    [fieldId: number]: FieldValue;
}
interface TemplateInfo {
    id: number;
    name: string;
    displayName: string;
    description?: string;
    fieldCount?: number;
    color?: LfColor;
}
interface TemplateValue {
    name: string;
    id: number;
    fieldValues: {
        [key: string]: FieldValue;
    };
}
interface LfColor {
    a: number;
    r: number;
    g: number;
    b: number;
}
interface TemplateFieldInfo extends LfFieldInfo {
    rule?: Rule;
    groupId?: number;
    groupName?: string;
}
interface Rule {
    ancestors: number[];
}

interface LfFieldAdhocContainerService {
    getAllFieldDefinitionsAsync(): Promise<LfFieldInfo[]>;
}

interface LfFieldTemplateContainerService {
    getAvailableTemplatesAsync(): Promise<TemplateInfo[]>;
    getTemplateFieldsAsync(templateIdentifier: number | string): Promise<TemplateFieldInfo[]>;
    getTemplateDefinitionAsync(templateIdentifier: string | number): Promise<TemplateInfo | undefined>;
    getDynamicFieldValueOptionsAsync(templateId: number, currentValues: FieldValues): Promise<{
        [fieldId: number]: string[];
    }>;
}

interface LfFieldContainerService extends LfFieldAdhocContainerService, LfFieldTemplateContainerService {
}

interface AdhocFieldInfo extends LfFieldInfo {
    inTemplateSelected?: boolean;
}

/**
 * @internal
 */
declare enum AddRemoveState {
    DEFAULT = "default",
    LOADING = "isLoading",
    HAS_ERROR = "hasError",
    DISPLAY_FIELD = "displayField"
}
/**
 * @internal
 */
declare class LfFieldAddRemoveComponent implements AfterViewInit {
    private adHocConnectorService;
    ref: ChangeDetectorRef;
    popupDialog: MatDialog;
    private localizationService;
    private readonly APPLY_CHANGES;
    private readonly DO_YOU_WANT_TO_APPLY_YOUR_FIELD_CHANGES;
    private readonly YES;
    private readonly NO;
    readonly CANCEL: Observable<string>;
    readonly APPLY: Observable<string>;
    readonly ADD_REMOVE_FIELDS: Observable<string>;
    readonly NO_MATCHING_FIELDS_FOUND: Observable<string>;
    readonly SEARCH_FIELDS: Observable<string>;
    readonly AN_ERROR_OCCURED: Observable<string>;
    readonly LOCALIZED_FIELD_TYPES: Map<string, Observable<string>>;
    allFieldInfos: AdhocFieldInfo[];
    displayFieldInfos: AdhocFieldInfo[];
    selectedFieldIds: Set<number>;
    areCheckboxChanges: boolean;
    filterFieldsControl: FormControl;
    fieldFilterText: string;
    state: AddRemoveState;
    adhocFieldContainerService: LfFieldAdhocContainerService;
    dialogRef?: MatDialogRef<any>;
    popupModal?: TemplateRef<any>;
    checkboxUpdate: EventEmitter<void>;
    clickBack: EventEmitter<void>;
    ngAfterViewInit(): void;
    initAsync: (adhocContainerService: LfFieldAdhocContainerService) => Promise<void>;
    /** @internal */
    get shouldShowErrorMessage(): boolean;
    /** @internal */
    get isLoading(): boolean;
    onClickBack(): Promise<void>;
    onModalButtonClick(event: string): void;
    onClickApply(): void;
    onClickCancel(): void;
    onConfirmNo(): void;
    private filterDisplayedFields;
    onClearFields(): void;
    onUpdateCheckbox(changeEvent: MatCheckboxChange, field: LfFieldInfo): void;
    ignoreEscapeKeydown(event: Event): void;
    private updateSelectedOptions;
    updateSortedFieldInfos(): Promise<void>;
    private partitionFieldInfos;
    isFieldSelected(field: AdhocFieldInfo): boolean;
    getAppliedFields(): void;
    private loadFieldDefinitionsInOrderAsync;
    private getCurrentFieldOptionsAsync;
    /** @internal */
    private orderFieldInfosByName;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldAddRemoveComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldAddRemoveComponent, "lf-field-add-remove-component", never, { "initAsync": { "alias": "initAsync"; "required": false; }; }, { "checkboxUpdate": "checkboxUpdate"; "clickBack": "clickBack"; }, never, never, true, never>;
}

declare class LfFieldComponent {
    /**@internal */
    private fb;
    /**@internal */
    private ref;
    /** @internal */
    lfFieldInfo: LfFieldInfo;
    /** @internal */
    lfFieldValue: LfFieldValue;
    /** @internal */
    singleFieldParentForm: FormGroup;
    /** @internal */
    showLoader: boolean;
    /** @internal */
    fieldValueChanged: EventEmitter<string>;
    /** @internal */
    dynamicFieldValueOptions: string[] | undefined;
    /** @internal */
    showField: boolean;
    /** @internal */
    constructor();
    /** @internal */
    getSingleField(): FormControl;
    /** @internal */
    isValid(): boolean;
    /** @internal */
    forceValidation: () => boolean;
    /** @internal */
    getOptions(): string[] | undefined;
    /** @internal */
    initAsync: (field: LfFieldInfo, fieldValue?: LfFieldValue, dynamicFieldValueOptions?: string[]) => Promise<void>;
    /** @internal */
    private removeInvalidFieldValues;
    /** @internal */
    private getInitialValue;
    /** @internal */
    getFieldValue: () => FieldValue;
    /** @internal */
    fieldDataChange(value: LfFieldValue): void;
    /** @internal */
    get isLoading(): boolean;
    /** @internal */
    set isLoading(val: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldComponent, "lf-field-component", never, { "forceValidation": { "alias": "forceValidation"; "required": false; }; "initAsync": { "alias": "initAsync"; "required": false; }; "getFieldValue": { "alias": "getFieldValue"; "required": false; }; }, { "fieldValueChanged": "fieldValueChanged"; }, never, never, true, never>;
}

declare class LfFieldMultivalueComponent {
    /**@internal */
    private fb;
    /**@internal */
    private cdr;
    /** @internal */
    lfFieldInfo: LfFieldInfo;
    /** @internal */
    lfFieldValues: LfFieldValue[];
    /** @internal */
    multiValueFieldParentForm: FormGroup;
    /** @internal */
    showLoader: boolean;
    /** @internal */
    fieldValuesChanged: EventEmitter<{
        fieldValues: LfFieldValue[];
        indexChanged: number;
    }>;
    /** @internal */
    dynamicFieldOptions: string[][] | undefined;
    /** @internal */
    showField: boolean;
    /** @internal */
    constructor();
    /** @internal */
    private getArray;
    /** @internal */
    getSingleField(index: number): FormControl;
    /** @internal */
    getLfFieldInfo(currentIndex: number): LfFieldInfo;
    /** @internal */
    isValid(): boolean;
    /** @internal */
    initAsync: (fieldDefinition: LfFieldInfo, fieldValues?: LfFieldValue[], dynamicFieldOptions?: string[][]) => Promise<void>;
    /** @internal */
    forceValidation: () => boolean;
    /** @internal */
    private removeInvalidFieldValues;
    /** @internal */
    getOptions(): string[] | undefined;
    /** @internal */
    syncFormControlDataToFieldValues(): void;
    /** @internal */
    getFieldValue: () => FieldValue;
    /** @internal */
    onChange(value: LfFieldValue, indexChanged: number): void;
    /** @internal */
    private lastValueIsValid;
    /** @internal */
    private fieldHasValue;
    /** @internal */
    private isLastInArray;
    /** @internal */
    private addNewBlankField;
    /** @internal */
    removeField(indexChanged: number): void;
    /** @internal */
    trackByIndex(index: number, option: string): string;
    /** @internal */
    get isLoading(): boolean;
    /** @internal */
    set isLoading(val: boolean);
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldMultivalueComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldMultivalueComponent, "lf-field-multivalue-component", never, { "initAsync": { "alias": "initAsync"; "required": false; }; "forceValidation": { "alias": "forceValidation"; "required": false; }; "getFieldValue": { "alias": "getFieldValue"; "required": false; }; }, { "fieldValuesChanged": "fieldValuesChanged"; }, never, never, true, never>;
}

/** @internal */
declare class LfFieldMetadataConnectorService {
    private allFieldValues;
    private readonly templateFields;
    private readonly adhocFieldsRefresh;
    private readonly adhocDialogOpened;
    constructor();
    setFieldValue(fieldValue: FieldValue): void;
    setAllFieldValues(fieldValues: FieldValues): void;
    getAllFieldValues(): FieldValues;
    clearAllFieldValues(): void;
    selectTemplateFields(newFields: number[]): void;
    getTemplateFields(): Observable<number[]>;
    adhocFieldDataUpdated(): Observable<void>;
    updatedAdhocFieldData(): void;
    setAddRemoveContainerToggled(open: boolean): void;
    getAddRemoveContainerToggled(): Subject<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldMetadataConnectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LfFieldMetadataConnectorService>;
}

/** @internal */
declare class LfFieldViewDirective {
    viewContainerRef: ViewContainerRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldViewDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LfFieldViewDirective, "[lfFieldView]", never, {}, {}, never, never, true, never>;
}

/** @internal */
interface FieldDefinition {
    fieldInfo: TemplateFieldInfo;
    fieldValues?: LfFieldValue[];
}

declare class LfFieldGroupComponent {
    /**@internal */
    private fb;
    /**@internal */
    private ref;
    /**@internal */
    localizationService: AppLocalizationService;
    /** @internal */
    fieldDefinitions: FieldDefinition[];
    /** @internal */
    fieldGroups: FormArray<FormGroup>;
    /** @internal */
    fieldValues: Map<number, FieldValue>;
    /** @internal */
    groupId: number;
    /** @internal */
    dynamicFieldOptions: Map<number, string[][]> | undefined;
    /** @internal */
    fieldValuesChanged: EventEmitter<{
        fieldValue: FieldValue;
        indicesChanged?: number[];
    }>;
    /** @internal */
    showLoaderIndex: number | undefined;
    /** @internal */
    readonly res_0_of_1: rxjs.Observable<string>;
    /** @internal */
    constructor();
    /** @internal */
    getFieldValues: () => Map<number, FieldValue>;
    /** @internal */
    initAsync: (fieldDefinitions: FieldDefinition[], dynamicFieldOptions?: Map<number, string[][]>) => Promise<void>;
    /** @internal */
    getOptions(fieldInfo: TemplateFieldInfo, index: number): string[] | undefined;
    /** @internal */
    forceValidation: () => boolean;
    /** @internal */
    isLoading(fieldInfo: TemplateFieldInfo, currentIndex: number): boolean;
    /** @internal */
    showLoader(index: number): void;
    /** @internal */
    private setFieldGroups;
    /** @internal */
    private addFieldFormControl;
    /** @internal */
    private updateFieldValues;
    /** @internal */
    fieldDataChange(event: string, fieldInfo: TemplateFieldInfo, indexChanged: number): void;
    /** @internal */
    getSingleField(index: number, fieldId: number): FormControl;
    /** @internal */
    isValid(): boolean;
    /** @internal */
    onDragAndDrop(event: CdkDragDrop<FormGroup[]>): void;
    /** @internal */
    fieldGroupControlsArray(): FormGroup[];
    /** @internal */
    onClickDelete(index: number): void;
    /** @internal */
    private resetPositionValues;
    /** @internal */
    onClickAdd(currentIndex: number): void;
    /** @internal */
    onClickUp(currentIndex: number): void;
    /** @internal */
    onClickDown(currentIndex: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldGroupComponent, "lf-field-group-component", never, { "getFieldValues": { "alias": "getFieldValues"; "required": false; }; "initAsync": { "alias": "initAsync"; "required": false; }; "forceValidation": { "alias": "forceValidation"; "required": false; }; "showLoader": { "alias": "showLoader"; "required": false; }; }, { "fieldValuesChanged": "fieldValuesChanged"; }, never, never, true, never>;
}

declare abstract class LfFieldContainerDirective {
    /** @internal */
    metadataFieldConnectorService: LfFieldMetadataConnectorService;
    fieldValuesChanged: EventEmitter<boolean>;
    /** @internal */
    lfFieldView: LfFieldViewDirective;
    /** @internal */
    componentRefs: ComponentRef<LfFieldComponent | LfFieldMultivalueComponent>[];
    /** @internal */
    groupComponentRefs: ComponentRef<LfFieldGroupComponent>[];
    /** @internal */
    allFieldInfos: (TemplateFieldInfo | LfFieldInfo | AdhocFieldInfo)[];
    /** @internal */
    allFieldValues: FieldValues;
    /** @internal */
    private readonly VALUE_ACCESSOR;
    /** @internal */
    constructor();
    /** @internal */
    abstract clearAsync(): Promise<void>;
    /** @internal */
    abstract onFieldValueChangedAsync(fieldValues: string[], lfFieldInfo: LfFieldInfo, indicesChanged?: number[]): Promise<void>;
    /** @internal */
    abstract renderFieldsAsync(fieldInfos: (TemplateFieldInfo | LfFieldInfo | AdhocFieldInfo)[]): Promise<void>;
    /** @internal */
    abstract multivalueComponentInitAsync(componentRef: ComponentRef<LfFieldMultivalueComponent>, fieldInfo: LfFieldInfo, stringValues: LfFieldValue[]): Promise<void>;
    /** @internal */
    abstract fieldComponentInitAsync(componentRef: ComponentRef<LfFieldComponent>, fieldInfo: LfFieldInfo, stringValues: LfFieldValue): Promise<void>;
    forceValidation: () => boolean;
    /**
     * @internal
     * Returns whether container is valid without forcing validation
     */
    isValid(): boolean;
    /** @internal */
    setFieldValue(fieldId: number, values: string[]): void;
    /** @internal */
    getOrCreateFieldValue(fieldId: number): FieldValue;
    /** @internal */
    protected initializeFieldComponentAsync(fieldComponentRef: ComponentRef<LfFieldComponent>, fieldInfo: LfFieldInfo, value: string): Promise<void>;
    /** @internal */
    protected initializeMultivalueComponentAsync(multivalueComponentRef: ComponentRef<LfFieldMultivalueComponent>, fieldInfo: LfFieldInfo, stringValues: string[]): Promise<void>;
    /** @internal */
    protected getValuesById(fieldId: number): string[];
    /** @internal */
    private createDefaultFieldValue;
    /** @internal */
    private createFieldValueFromFieldInfo;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldContainerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<LfFieldContainerDirective, never, never, { "forceValidation": { "alias": "forceValidation"; "required": false; }; }, { "fieldValuesChanged": "fieldValuesChanged"; }, never, never, true, never>;
}

declare class LfFieldAdhocContainerComponent extends LfFieldContainerDirective implements OnDestroy, AfterViewInit {
    /**@internal */
    private adhocFieldConnectorService;
    /**@internal */
    private ref;
    /**@internal */
    private localizationService;
    /** @internal */
    addRemoveComponent: LfFieldAddRemoveComponent;
    dialogOpened: EventEmitter<void>;
    dialogClosed: EventEmitter<void>;
    /** @internal */
    readonly ADD_REMOVE_FIELDS: rxjs.Observable<string>;
    /** @internal */
    readonly NO_ADDITIONAL_FIELDS_ASSIGNED: rxjs.Observable<string>;
    /** @internal */
    showAdhocModal: boolean;
    /** @internal */
    adhocFieldContainerService: LfFieldAdhocContainerService;
    /** @internal */
    templateFields: number[];
    /** @internal */
    private selectedFieldIds;
    /** @internal */
    private templateFieldsSub;
    /** @internal */
    constructor();
    /** @internal */
    ngAfterViewInit(): void;
    /** @internal */
    ngOnDestroy(): void;
    getFieldValues: () => {
        [fieldName: string]: FieldValue;
    };
    clearAsync: () => Promise<void>;
    initAsync: (adhocFieldContainerService: LfFieldAdhocContainerService) => Promise<void>;
    resetFieldDataAsync: (fields: {
        value: FieldValue;
        definition: LfFieldInfo;
    }[]) => Promise<void>;
    updateFieldValuesAsync: (values: FieldValue[]) => Promise<void>;
    /** @internal */
    private resetComponentValues;
    /** @internal */
    renderFieldsAsync(fieldInfos: (LfFieldInfo | AdhocFieldInfo)[]): Promise<void>;
    /** @internal */
    fieldComponentInitAsync(fieldComponentRef: ComponentRef<LfFieldComponent>, fieldInfo: LfFieldInfo, value: string): Promise<void>;
    /** @internal */
    multivalueComponentInitAsync(multivalueFieldComponentRef: ComponentRef<LfFieldMultivalueComponent>, fieldInfo: LfFieldInfo, values: string[]): Promise<void>;
    /** @internal */
    private loadSelectedFieldValues;
    /** @internal */
    getMappedFieldValues(fieldValues: FieldValue[]): FieldValues;
    /** @internal */
    getFieldIds(fieldValues: FieldValue[]): Set<number>;
    /** @internal */
    private getInitialSelectedOptions;
    /** @internal */
    fieldsEmpty(): boolean;
    /** @internal */
    addRemoveFieldsAsync(adhocPanel?: HTMLElement): Promise<void>;
    /** @internal */
    onClickBackAsync(): Promise<void>;
    /** @internal */
    private toggleAdhocModal;
    /** @internal */
    refreshFieldsAsync(): Promise<void>;
    /** @internal */
    getSelectedFieldInfos(): LfFieldInfo[];
    /** @internal */
    private updateTemplateFields;
    /** @internal */
    onFieldValueChangedAsync(values: string[], fieldInfo: LfFieldInfo): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldAdhocContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldAdhocContainerComponent, "lf-field-adhoc-container", never, { "getFieldValues": { "alias": "getFieldValues"; "required": false; }; "clearAsync": { "alias": "clearAsync"; "required": false; }; "initAsync": { "alias": "initAsync"; "required": false; }; "resetFieldDataAsync": { "alias": "resetFieldDataAsync"; "required": false; }; "updateFieldValuesAsync": { "alias": "updateFieldValuesAsync"; "required": false; }; }, { "dialogOpened": "dialogOpened"; "dialogClosed": "dialogClosed"; }, never, never, true, never>;
}

interface LfFieldTemplateProviders {
    templateFieldContainerService: LfFieldTemplateContainerService;
}

/**
 * @internal
 */
declare enum DropDownState {
    DEFAULT = "default",
    LOADING = "isLoading",
    HAS_ERROR = "hasError"
}
/**
 * @internal
 */
declare enum TemplateState {
    DEFAULT = "default",
    LOADING = "isLoading",
    HAS_ERROR = "hasError",
    SHOW_TEMPLATE = "showTemplate"
}

declare class LfFieldTemplateContainerComponent extends LfFieldContainerDirective implements AfterViewInit, OnDestroy {
    /**@internal */
    private localizationService;
    /**@internal */
    private ref;
    templateSelectedChange: EventEmitter<number>;
    /** @internal */
    hideTemplate: boolean;
    /** @internal */
    availableTemplates: TemplateInfo[];
    /** @internal */
    loadedTemplates: boolean;
    /** @internal */
    templateFieldContainerService: LfFieldTemplateContainerService;
    /** @internal */
    templateErrorMessage: Observable<string> | undefined;
    /** @internal */
    readonly emptyTemplateName: Observable<string>;
    /** @internal */
    templateSelected: TemplateInfo | undefined;
    /** @internal */
    dynamicOptions: Map<number, string[][]>;
    /** @internal */
    private adhocFieldsSub;
    /** @internal */
    private adhocDialogOpenedSub;
    /** @internal */
    readonly AN_ERROR_OCCURED: Observable<string>;
    /** @internal */
    dropdownState: DropDownState;
    /** @internal */
    templateState: TemplateState;
    /** @internal */
    private readonly TEMPLATE_HAS_FAILED_TO_LOAD;
    /** @internal */
    ngAfterViewInit(): void;
    /** @internal */
    ngOnDestroy(): void;
    initAsync: (providers: LfFieldTemplateProviders, templateIdentifier?: number | string) => Promise<void>;
    clearAsync: () => Promise<void>;
    getTemplateValue: () => TemplateValue | undefined;
    /** @internal */
    get isDropdownError(): boolean;
    /** @internal */
    get isDropdownLoading(): boolean;
    /** @internal */
    get isDropdownDefault(): boolean;
    /** @internal */
    get isTemplateLoading(): boolean;
    /** @internal */
    get isTemplateError(): boolean;
    /** @internal */
    get isTemplateDisplay(): boolean;
    /** @internal */
    private resetComponentValues;
    /** @internal */
    renderFieldsAsync(fieldInfos: (TemplateFieldInfo | LfFieldInfo)[]): Promise<void>;
    /** @internal */
    private initializeFieldGroupAsync;
    /** @internal */
    private addDefinitionToExistingGroup;
    /** @internal */
    private createAndAddNewGroupRef;
    /** @internal */
    private initializeFieldGroupComponentAsync;
    /** @internal */
    fieldComponentInitAsync(fieldComponentRef: ComponentRef<LfFieldComponent>, fieldInfo: LfFieldInfo, value: string): Promise<void>;
    /** @internal */
    multivalueComponentInitAsync(multivalueFieldComponentRef: ComponentRef<LfFieldMultivalueComponent>, fieldInfo: LfFieldInfo, values: string[]): Promise<void>;
    /** @internal */
    compareTemplateInfoFunc(object1: TemplateInfo, object2: TemplateInfo): boolean;
    /** @internal */
    onToggleDropdownAsync(open: boolean): Promise<void>;
    /** @internal */
    onTemplateChangedAsync(event: MatSelectChange): Promise<void>;
    /** @internal */
    private selectTemplateAsync;
    /** @internal */
    private updateTemplateFieldsAsync;
    /** @internal */
    private updateTemplateFieldInfoAsync;
    /** @internal */
    private initBaseDynamicFieldAsync;
    /** @internal */
    private getValueIfSingleOption;
    /** @internal */
    private updateAllFieldInfosFromServiceAsync;
    /** @internal */
    private getOrCreateDynamicOptions;
    /** @internal */
    onFieldValueChangedAsync(fieldValues: string[], lfFieldInfo: TemplateFieldInfo, indicesChanged?: number[]): Promise<void>;
    /** @internal */
    private addFieldOptionsForIndexAsync;
    /** @internal */
    private showLoader;
    /** @internal */
    private updateDynamicFieldsAsync;
    /** @internal */
    private getUpdatedChildValue;
    /** @internal */
    private getDynamicFieldValueOptionsAsync;
    /** @internal */
    private getRelevantValuesForIndex;
    /** @internal */
    private getDynamicFieldChildren;
    /** @internal */
    private getDynamicFieldValues;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldTemplateContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldTemplateContainerComponent, "lf-field-template-container", never, { "initAsync": { "alias": "initAsync"; "required": false; }; "clearAsync": { "alias": "clearAsync"; "required": false; }; "getTemplateValue": { "alias": "getTemplateValue"; "required": false; }; }, { "templateSelectedChange": "templateSelectedChange"; }, never, never, true, never>;
}

declare class LfFieldContainerComponent {
    /**@internal */
    private ref;
    /**@internal */
    localizationService: AppLocalizationService;
    collapsible: boolean;
    start_collapsed: boolean;
    fieldValuesChanged: EventEmitter<boolean>;
    templateSelectedChanged: EventEmitter<number>;
    dialogOpened: EventEmitter<void>;
    dialogClosed: EventEmitter<void>;
    /** @internal */
    templateContainer: LfFieldTemplateContainerComponent;
    /** @internal */
    adhocContainer: LfFieldAdhocContainerComponent;
    /** @internal */
    private lfFieldContainerService;
    /** @internal */
    panelOpenState: boolean;
    /** @internal */
    readonly FIELDS: Observable<string>;
    /** @internal */
    readonly TEMPLATE: Observable<string>;
    /** @internal */
    SELECTED_TEMPLATE_NAME: Observable<string>;
    /** @internal */
    getSelectedTemplateName(): Observable<string>;
    initAsync: (lfFieldContainerService: LfFieldContainerService, templateIdentifier?: number | string) => Promise<void>;
    forceValidation: () => boolean;
    clearAsync: () => Promise<void>;
    getFieldValues: () => {
        [fieldName: string]: FieldValue;
    };
    getNumAdhocFields: () => number;
    resetFieldDataAsync: (fields: {
        value: FieldValue;
        definition: LfFieldInfo;
    }[]) => Promise<void>;
    updateFieldValuesAsync: (values: FieldValue[]) => Promise<void>;
    getTemplateValue: () => TemplateValue | undefined;
    /** @internal */
    onFieldValuesChanged(): void;
    /** @internal */
    onTemplateSelectedChange(selectedTemplateId: number): void;
    /** @internal */
    onDialogOpened(): void;
    /** @internal */
    onDialogClosed(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LfFieldContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LfFieldContainerComponent, "lf-field-container", never, { "collapsible": { "alias": "collapsible"; "required": false; }; "start_collapsed": { "alias": "start_collapsed"; "required": false; }; "initAsync": { "alias": "initAsync"; "required": false; }; "forceValidation": { "alias": "forceValidation"; "required": false; }; "clearAsync": { "alias": "clearAsync"; "required": false; }; "getFieldValues": { "alias": "getFieldValues"; "required": false; }; "getNumAdhocFields": { "alias": "getNumAdhocFields"; "required": false; }; "resetFieldDataAsync": { "alias": "resetFieldDataAsync"; "required": false; }; "updateFieldValuesAsync": { "alias": "updateFieldValuesAsync"; "required": false; }; "getTemplateValue": { "alias": "getTemplateValue"; "required": false; }; }, { "fieldValuesChanged": "fieldValuesChanged"; "templateSelectedChanged": "templateSelectedChanged"; "dialogOpened": "dialogOpened"; "dialogClosed": "dialogClosed"; }, never, never, true, never>;
}

export { LfFieldAdhocContainerComponent, LfFieldContainerComponent, LfFieldTemplateContainerComponent };
export type { FieldValue, LfFieldAdhocContainerService, LfFieldContainerService, LfFieldInfo, LfFieldTemplateContainerService, LfFieldTemplateProviders, TemplateFieldInfo };