import * as _angular_core from '@angular/core';
import { OnDestroy, AfterViewInit, OnChanges, SimpleChanges, OnInit, InjectionToken, PipeTransform, ModuleWithProviders } from '@angular/core';
import * as i1 from '@angular/platform-browser';
import * as i2 from '@angular/platform-browser/animations';
import * as i3 from '@angular/common';
import * as i4 from '@angular/forms';
import { FormControl, ControlValueAccessor, AbstractControl } from '@angular/forms';
import * as i5 from '@progress/kendo-angular-dateinputs';
import { DatePickerComponent, PopupSettings, TimePickerComponent } from '@progress/kendo-angular-dateinputs';
import { Subject, Observable, BehaviorSubject } from 'rxjs';
import * as _ngx_formly_core from '@ngx-formly/core';
import { FormlyFieldProps, FormlyFieldConfig, FormlyConfig, FieldType, FieldTypeConfig, ConfigOption } from '@ngx-formly/core';
export { ɵgetFieldValue as getFieldValue } from '@ngx-formly/core';
import { PropertyOption } from '@holocentric/angular-app-config';
import * as i11 from '@holocentric/angular-metamodel';
import { Property, ItemRoleEnd, MetamodelManager, FeatureBase } from '@holocentric/angular-metamodel';
import { TinyMCE, Editor, RawEditorOptions, Bookmark } from 'tinymce';
import * as i10 from '@holocentric/angular-core';
import { RichTextImageService, FeatureToggleManager } from '@holocentric/angular-core';
import * as i1$1 from '@angular/material/button';
import * as i2$1 from '@angular/material/checkbox';
import { MatCheckboxChange } from '@angular/material/checkbox';
import * as i3$1 from '@angular/material/dialog';
import * as i4$1 from '@angular/material/radio';
import * as i7 from '@progress/kendo-angular-dropdowns';
import { DropDownListComponent, PopupSettings as PopupSettings$1 } from '@progress/kendo-angular-dropdowns';
import * as i9 from '@tinymce/tinymce-angular';
import * as i12 from 'ngx-scrollbar';

declare class HoloDatePickerControl implements OnDestroy, AfterViewInit {
    private changeDetectorRef;
    private element;
    readonly max: _angular_core.InputSignal<Date | null>;
    readonly min: _angular_core.InputSignal<Date | null>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly format: _angular_core.InputSignal<string | undefined>;
    readonly passedInFormControl: _angular_core.InputSignal<FormControl<any> | undefined>;
    readonly field: _angular_core.InputSignal<any>;
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly showClearIcon: _angular_core.InputSignal<boolean>;
    readonly className: _angular_core.InputSignal<string>;
    readonly isTextSelectable: _angular_core.InputSignal<boolean>;
    readonly valueChange: _angular_core.OutputEmitterRef<Date>;
    readonly datepicker: _angular_core.Signal<DatePickerComponent | undefined>;
    isDestroyed$: Subject<void>;
    showClearButton: boolean;
    popupSettings: PopupSettings;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    mouseUp(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloDatePickerControl, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloDatePickerControl, "holo-datepicker-control", never, { "max": { "alias": "max"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "passedInFormControl": { "alias": "passedInFormControl"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "showClearIcon": { "alias": "showClearIcon"; "required": false; "isSignal": true; }; "className": { "alias": "className"; "required": false; "isSignal": true; }; "isTextSelectable": { "alias": "isTextSelectable"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class KendoDatePickerClearInputDirective implements OnChanges, OnDestroy {
    private element;
    private formControlDirective;
    private button;
    private buttonWrapper;
    readonly visible: _angular_core.InputSignal<boolean | undefined>;
    private clickHandler;
    private checkShowButton;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KendoDatePickerClearInputDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KendoDatePickerClearInputDirective, "[holoClearInputButton]", never, { "visible": { "alias": "holoClearInputButton"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DatepickerModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatepickerModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DatepickerModule, never, [typeof i1.BrowserModule, typeof i2.BrowserAnimationsModule, typeof i3.CommonModule, typeof i4.ReactiveFormsModule, typeof i5.DateInputsModule, typeof HoloDatePickerControl, typeof KendoDatePickerClearInputDirective], [typeof HoloDatePickerControl, typeof KendoDatePickerClearInputDirective]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DatepickerModule>;
}

type PropsWithAdditionalProperties = FormlyFieldProps & Record<string, any>;

declare class TextInputComponent implements OnInit {
    readonly control: _angular_core.InputSignal<FormControl<any>>;
    readonly props: _angular_core.InputSignal<PropsWithAdditionalProperties>;
    readonly field: _angular_core.InputSignal<FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
        [additionalProperties: string]: any;
    }> | undefined>;
    readonly inputBlur: _angular_core.OutputEmitterRef<Event>;
    readonly inputFocus: _angular_core.OutputEmitterRef<Event>;
    type: string;
    private _trim;
    private trimOptions;
    set trim(value: any);
    get trim(): any;
    ngOnInit(): void;
    inputFocused: boolean | undefined;
    onInput(event: Event): void;
    onBlur($event: Event): void;
    onFocus($event: Event): void;
    clearValue(): void;
    hasInputValue(): boolean;
    private trimValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextInputComponent, "holo-text-input", never, { "control": { "alias": "control"; "required": true; "isSignal": true; }; "props": { "alias": "props"; "required": true; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; }, { "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; }, never, never, true, never>;
}

declare class FileValueAccessorDirective implements ControlValueAccessor {
    onChange: (file: FileList) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileValueAccessorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FileValueAccessorDirective, "[holoInputFile]", never, {}, {}, never, never, true, never>;
}

declare class FormlyValueAccessorDirective implements ControlValueAccessor {
    private formlyForm;
    onChange: (...args: any[]) => void;
    onTouched: () => void;
    writeValue(model: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormlyValueAccessorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormlyValueAccessorDirective, "[holoFormlyFormValueAccessor]", never, {}, {}, never, never, true, never>;
}

declare const insertMenuButtonName = "holo-insert";
type TinyMceConfig = Parameters<TinyMCE['init']>[0];
declare const defaultRichtextConfig: TinyMceConfig;
declare function postprocessTinyMcePaste(plugin: Editor, args: any): void;
declare function postprocessContentInElement(element: HTMLElement): void;
declare function removeUnsupportedStyles(element: HTMLElement): void;
declare function stripHtml(html: string): string;

declare const FORMLY_HOLO_CONFIG_TOKEN: InjectionToken<any>;
declare const FORMLY_FIELD_CONFIG_FACTORIES_TOKEN: InjectionToken<any>;
declare const FORMLY_FIELD_RICHTEXT_CONFIG: InjectionToken<any>;
type FormlyFieldConfigFactoryMap = Record<string, Function>;
declare const defaultFormlyFieldConfigFactories: FormlyFieldConfigFactoryMap;
interface FormlyClassNameConfig {
    rowClassName?: string;
    fieldClassName?: string;
}
interface HoloFormlyConfig {
    classNames?: FormlyClassNameConfig;
    richtext?: TinyMceConfig;
    richtextFunction?: () => TinyMceConfig;
}
type PropertyWithPropertyOption = Property & ItemRoleEnd & PropertyOption;
declare class FormlyManager {
    protected fc: FormlyConfig;
    protected config: HoloFormlyConfig;
    protected formlyFieldConfigFactories: FormlyFieldConfigFactoryMap;
    protected metamodelManager: MetamodelManager;
    classNameConfig: FormlyClassNameConfig;
    constructor();
    makeFormlyField({ property, additionalProps, hasFieldContentCopyRights, }: {
        property: PropertyWithPropertyOption;
        additionalProps: Record<string, Record<string, any>>;
        hasFieldContentCopyRights: boolean;
    }): Observable<FormlyFieldConfig>;
    /**
     * Return formly field for category heading. If no category is given, it will just be a separator.
     * @param category category label
     */
    makeCategoryFormlyFieldConfig(category?: string): FormlyFieldConfig;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormlyManager, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FormlyManager>;
}
declare function makeBooleanFormlyFieldConfig(property: PropertyWithPropertyOption, config: FormlyClassNameConfig): FormlyFieldConfig;
declare function makeMultipleFormlyFieldConfig(): FormlyFieldConfig | null;
declare function makeStringFormlyFieldConfig(property: PropertyWithPropertyOption, config: FormlyClassNameConfig, hasFieldContentCopyRights: boolean, additionalProps: Record<string, any>): FormlyFieldConfig;
declare function makeComboboxFormlyFieldConfig(property: PropertyWithPropertyOption, config: FormlyClassNameConfig, hasFieldContentCopyRights: boolean): FormlyFieldConfig;
declare function makeTextFormlyFieldConfig(property: PropertyWithPropertyOption, config: FormlyClassNameConfig, hasFieldContentCopyRights: boolean): FormlyFieldConfig;
declare function makeDateTimePickerFormlyFieldConfig(property: PropertyWithPropertyOption, config: FormlyClassNameConfig, hasFieldContentCopyRights: boolean): FormlyFieldConfig;
/**
 * Return formly field for category heading. If no category is given, it will just be a separator.
 * @param category category label
 */
declare function makeCategoryFormlyFieldConfig(config: FormlyClassNameConfig, label?: string): FormlyFieldConfig;
declare function attemptTemplateOptionFunction(props: Record<string, any>, formlyTypename: string, functionName: string, ...args: any[]): any;
declare function makeRelationshipFormlyFieldConfig({ property, config, additionalProps, metamodelManager, hasFieldContentCopyRights, }: {
    property: PropertyWithPropertyOption;
    config: FormlyClassNameConfig;
    additionalProps: Record<string, any>;
    metamodelManager: MetamodelManager;
    hasFieldContentCopyRights: boolean;
}): Observable<FormlyFieldConfig>;
declare function getFieldLabel(feature: FeatureBase): string;
declare function unfreezeProps(field: FormlyFieldConfig): void;

declare class MaterialModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaterialModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1$1.MatButtonModule, typeof i2$1.MatCheckboxModule, typeof i3$1.MatDialogModule, typeof i4$1.MatRadioModule], [typeof i1$1.MatButtonModule, typeof i2$1.MatCheckboxModule, typeof i3$1.MatDialogModule, typeof i4$1.MatRadioModule, typeof i3$1.MatDialogTitle, typeof i3$1.MatDialogContent, typeof i3$1.MatDialogActions, typeof i3$1.MatDialogClose]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<MaterialModule>;
}

interface TextWithIcon {
    showIcon?: boolean;
    iconClass?: string;
    overlayClass?: string;
    overlay?: string;
    textClass?: string;
    text?: string;
    hintClass?: string;
    hint?: string;
}
interface TextWithClass {
    text?: string;
    class?: string;
}
type StyledItemLabels = {
    tag?: string;
    class?: string;
    label: string;
}[];
type StyledItemLabelsFunction = (item: any) => StyledItemLabels;
declare class HoloRelationshipField extends FieldType<FieldTypeConfig> {
    control: AbstractControl | undefined;
    onOpen(item: any): void;
    canOpen(): boolean;
    onRemove(toRemoveItem: any): void;
    onClickWhenEmpty(event: Event): void;
    onPerformCommand(params: {
        command: any;
        selectedItems: any[];
    }): void;
    onSelectionChange(items: any[]): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipField, "holo-relationship", never, {}, {}, never, never, true, never>;
}
declare class HoloRelationshipComponentBase {
    readonly fieldType: FieldType<FieldTypeConfig> | undefined;
    readonly open: _angular_core.OutputEmitterRef<any>;
    readonly remove: _angular_core.OutputEmitterRef<any>;
    readonly clickWhenEmpty: _angular_core.OutputEmitterRef<Event>;
    get props(): any;
    get hideExternalIcon(): boolean;
    onChange: ((value: any) => void) | undefined;
    onTouched: (() => void) | undefined;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    onOpen(item: any): void;
    onRemove(item: any): void;
    onClickWhenEmpty(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipComponentBase, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipComponentBase, "holo-relationship-base", never, {}, { "open": "open"; "remove": "remove"; "clickWhenEmpty": "clickWhenEmpty"; }, never, never, true, never>;
}
declare class HoloRelationshipSingleComponent extends HoloRelationshipComponentBase implements ControlValueAccessor, OnChanges {
    private cdr;
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly commands: _angular_core.InputSignal<any[]>;
    readonly styledItemLabelsFunction: _angular_core.InputSignal<StyledItemLabelsFunction | undefined>;
    readonly itemLabelFunction: _angular_core.InputSignal<Function | undefined>;
    readonly additionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly endAdditionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly showTypeLabel: _angular_core.InputSignal<boolean>;
    readonly showClearIcon: _angular_core.InputSignal<boolean>;
    readonly textWithIcon: _angular_core.InputSignal<TextWithIcon | undefined>;
    readonly hideElementUids: _angular_core.InputSignal<string[]>;
    readonly errorMessage: _angular_core.InputSignal<string>;
    readonly isLinkable: _angular_core.InputSignal<Function | undefined>;
    readonly filterTypes: _angular_core.InputSignal<string[]>;
    readonly alwaysShowCommands: _angular_core.InputSignal<boolean>;
    readonly isTextSelectable: _angular_core.InputSignal<boolean>;
    readonly performCommand: _angular_core.OutputEmitterRef<any>;
    item: any;
    hiddenItem: any;
    commandGroups: any;
    commandGroupKeys: string[] | undefined;
    derivedPlaceholder: string;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    setDisabledState(isDisabled: boolean): void;
    getSelectedItems(): any;
    setPlaceHolder(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipSingleComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipSingleComponent, "holo-relationship-single", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "commands": { "alias": "commands"; "required": false; "isSignal": true; }; "styledItemLabelsFunction": { "alias": "styledItemLabelsFunction"; "required": false; "isSignal": true; }; "itemLabelFunction": { "alias": "itemLabelFunction"; "required": false; "isSignal": true; }; "additionalTextsFunction": { "alias": "additionalTextsFunction"; "required": false; "isSignal": true; }; "endAdditionalTextsFunction": { "alias": "endAdditionalTextsFunction"; "required": false; "isSignal": true; }; "showTypeLabel": { "alias": "showTypeLabel"; "required": false; "isSignal": true; }; "showClearIcon": { "alias": "showClearIcon"; "required": false; "isSignal": true; }; "textWithIcon": { "alias": "textWithIcon"; "required": false; "isSignal": true; }; "hideElementUids": { "alias": "hideElementUids"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "isLinkable": { "alias": "isLinkable"; "required": false; "isSignal": true; }; "filterTypes": { "alias": "filterTypes"; "required": false; "isSignal": true; }; "alwaysShowCommands": { "alias": "alwaysShowCommands"; "required": false; "isSignal": true; }; "isTextSelectable": { "alias": "isTextSelectable"; "required": false; "isSignal": true; }; }, { "performCommand": "performCommand"; }, never, never, true, never>;
}
declare class HoloRelationshipListComponent extends HoloRelationshipComponentBase implements ControlValueAccessor, OnChanges {
    private cdr;
    readonly numLines: _angular_core.InputSignal<number | undefined>;
    readonly linesToBeShown: _angular_core.InputSignal<number | undefined>;
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly itemPlaceholder: _angular_core.InputSignal<string>;
    readonly commands: _angular_core.InputSignal<any[]>;
    readonly styledItemLabelsFunction: _angular_core.InputSignal<StyledItemLabelsFunction | undefined>;
    readonly itemLabelFunction: _angular_core.InputSignal<Function | undefined>;
    readonly additionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly endAdditionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly sort: _angular_core.InputSignal<Function | undefined>;
    readonly showTypeLabel: _angular_core.InputSignal<boolean>;
    readonly showClearIcon: _angular_core.InputSignal<boolean>;
    readonly selectedItemKey: _angular_core.InputSignal<string | undefined>;
    readonly selectionType: _angular_core.InputSignal<string | undefined>;
    readonly textWithIcon: _angular_core.InputSignal<TextWithIcon | undefined>;
    readonly errorMessage: _angular_core.InputSignal<string | undefined>;
    readonly isLinkable: _angular_core.InputSignal<Function | undefined>;
    readonly filterTypes: _angular_core.InputSignal<string[]>;
    readonly alwaysShowCommands: _angular_core.InputSignal<boolean>;
    readonly isTextSelectable: _angular_core.InputSignal<boolean>;
    readonly performCommand: _angular_core.OutputEmitterRef<any>;
    readonly selectedItemsEvent: _angular_core.OutputEmitterRef<any[]>;
    isModelArray: boolean | undefined;
    itemsToDisplay: any[];
    selectedItemIndexFlags: boolean[];
    selectedItems: any[];
    allItems: any[];
    commandGroups: any;
    commandGroupKeys: string[] | undefined;
    singleItemSelected: boolean;
    lastIndexClicked: number;
    freeLinesCounter: number[] | undefined;
    itemsLength: number | undefined;
    totalHeight: string | undefined;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onCommandClick(command: any): void;
    onClick(event: MouseEvent, index: number): void;
    emitChange(): void;
    onRemove(toRemoveItem: any): void;
    private getSelectedItems;
    getSelectedItemIndex(): any[];
    openSelectedItem(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipListComponent, "holo-relationship-list", never, { "numLines": { "alias": "numLines"; "required": false; "isSignal": true; }; "linesToBeShown": { "alias": "linesToBeShown"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "itemPlaceholder": { "alias": "itemPlaceholder"; "required": false; "isSignal": true; }; "commands": { "alias": "commands"; "required": false; "isSignal": true; }; "styledItemLabelsFunction": { "alias": "styledItemLabelsFunction"; "required": false; "isSignal": true; }; "itemLabelFunction": { "alias": "itemLabelFunction"; "required": false; "isSignal": true; }; "additionalTextsFunction": { "alias": "additionalTextsFunction"; "required": false; "isSignal": true; }; "endAdditionalTextsFunction": { "alias": "endAdditionalTextsFunction"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; "showTypeLabel": { "alias": "showTypeLabel"; "required": false; "isSignal": true; }; "showClearIcon": { "alias": "showClearIcon"; "required": false; "isSignal": true; }; "selectedItemKey": { "alias": "selectedItemKey"; "required": false; "isSignal": true; }; "selectionType": { "alias": "selectionType"; "required": false; "isSignal": true; }; "textWithIcon": { "alias": "textWithIcon"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "isLinkable": { "alias": "isLinkable"; "required": false; "isSignal": true; }; "filterTypes": { "alias": "filterTypes"; "required": false; "isSignal": true; }; "alwaysShowCommands": { "alias": "alwaysShowCommands"; "required": false; "isSignal": true; }; "isTextSelectable": { "alias": "isTextSelectable"; "required": false; "isSignal": true; }; }, { "performCommand": "performCommand"; "selectedItemsEvent": "selectedItemsEvent"; }, never, never, true, never>;
}
declare class HoloRelationshipListItemComponent implements OnChanges {
    private metamodelManager;
    readonly item: _angular_core.InputSignal<any>;
    readonly itemPlaceholder: _angular_core.InputSignal<string>;
    readonly styledItemLabelsFunction: _angular_core.InputSignal<StyledItemLabelsFunction | undefined>;
    readonly itemLabelFunction: _angular_core.InputSignal<Function | undefined>;
    readonly additionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly endAdditionalTextsFunction: _angular_core.InputSignal<Function | undefined>;
    readonly textWithIcon: _angular_core.InputSignal<TextWithIcon | undefined>;
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly showTypeLabel: _angular_core.InputSignal<boolean>;
    readonly showClearIcon: _angular_core.InputSignal<boolean>;
    readonly hideExternalIcon: _angular_core.InputSignal<boolean>;
    readonly isLinkable: _angular_core.InputSignal<Function | undefined>;
    readonly isTextSelectable: _angular_core.InputSignal<boolean>;
    readonly open: _angular_core.OutputEmitterRef<any>;
    readonly remove: _angular_core.OutputEmitterRef<any>;
    additionalTexts: TextWithClass[] | null;
    endAdditionalTexts: TextWithClass[] | null;
    itemLabels: StyledItemLabels;
    linkType: string;
    ngOnChanges(changes: SimpleChanges): void;
    onClick(event: MouseEvent, item: any): void;
    removeItem(item: any): void;
    onDoubleClick(event: MouseEvent, item: any): void;
    shouldLinkToItem(): boolean;
    getLinkType(): string;
    getItemLabels(): StyledItemLabels;
    shouldDisplayPlaceholder(): boolean;
    getAdditionalTexts(): TextWithClass[] | null;
    getEndAdditionalTexts(): TextWithClass[] | null;
    getTypeLabel(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipListItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipListItemComponent, "holo-relationship-list-item", never, { "item": { "alias": "item"; "required": false; "isSignal": true; }; "itemPlaceholder": { "alias": "itemPlaceholder"; "required": false; "isSignal": true; }; "styledItemLabelsFunction": { "alias": "styledItemLabelsFunction"; "required": false; "isSignal": true; }; "itemLabelFunction": { "alias": "itemLabelFunction"; "required": false; "isSignal": true; }; "additionalTextsFunction": { "alias": "additionalTextsFunction"; "required": false; "isSignal": true; }; "endAdditionalTextsFunction": { "alias": "endAdditionalTextsFunction"; "required": false; "isSignal": true; }; "textWithIcon": { "alias": "textWithIcon"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "showTypeLabel": { "alias": "showTypeLabel"; "required": false; "isSignal": true; }; "showClearIcon": { "alias": "showClearIcon"; "required": false; "isSignal": true; }; "hideExternalIcon": { "alias": "hideExternalIcon"; "required": false; "isSignal": true; }; "isLinkable": { "alias": "isLinkable"; "required": false; "isSignal": true; }; "isTextSelectable": { "alias": "isTextSelectable"; "required": false; "isSignal": true; }; }, { "open": "open"; "remove": "remove"; }, never, never, true, never>;
}
declare class HoloRelationshipNoItemComponent extends HoloRelationshipComponentBase {
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly isTextSelectable: _angular_core.InputSignal<boolean>;
    readonly clickWhenEmpty: _angular_core.OutputEmitterRef<Event>;
    onClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRelationshipNoItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRelationshipNoItemComponent, "holo-relationship-no-item", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "isTextSelectable": { "alias": "isTextSelectable"; "required": false; "isSignal": true; }; }, { "clickWhenEmpty": "clickWhenEmpty"; }, never, never, true, never>;
}

declare abstract class HoloFieldType<F extends FormlyFieldConfig = FormlyFieldConfig> extends FieldType<F> {
    hasErrorMessage(): boolean;
    getTextInputErrorMessage(name?: string): string | null;
    getGenericErrorMessage(name?: string): string | null;
    get fieldValue(): any;
    get keyAsString(): string;
}

declare class HoloUploaderField extends HoloFieldType {
    readonly readOnly: _angular_core.InputSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly commands: _angular_core.InputSignal<any[]>;
    readonly itemLabelFunction: _angular_core.InputSignal<Function | undefined>;
    item: any | undefined;
    getErrorMessage: (name?: string) => string | null;
    commandGroups: any;
    commandGroupKeys: string[] | undefined;
    setDisabledState(isDisabled: boolean): void;
    getSelectedItems(): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloUploaderField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloUploaderField, "holo-uploader", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "commands": { "alias": "commands"; "required": false; "isSignal": true; }; "itemLabelFunction": { "alias": "itemLabelFunction"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HoloFormlyFieldLabelPipe implements PipeTransform {
    transform(props: PropsWithAdditionalProperties): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloFormlyFieldLabelPipe, never>;
    static ɵpipe: _angular_core.ɵɵPipeDeclaration<HoloFormlyFieldLabelPipe, "formlyFieldLabel", true>;
}

declare class HoloButtonField extends HoloFieldType {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloButtonField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloButtonField, "formly-field-button", never, {}, {}, never, never, true, never>;
}

declare class HoloCategoryField extends HoloFieldType {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloCategoryField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloCategoryField, "formly-field-category", never, {}, {}, never, never, true, never>;
}

declare class HoloCheckboxField extends HoloFieldType {
    static transformToFormProperties({ data, key, field, }: {
        data: any;
        key: string;
        field: FormlyFieldConfig;
    }): boolean;
    static transformToItemProperties({ controlValue, key, field, }: {
        controlValue: boolean;
        key: string;
        field: FormlyFieldConfig;
    }): Record<string, boolean>;
    onChange(event: MatCheckboxChange): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloCheckboxField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloCheckboxField, "formly-field-checkbox", never, {}, {}, never, never, true, never>;
}

declare class HoloComboboxField extends HoloFieldType<FieldTypeConfig> implements OnInit, OnDestroy {
    readonly kendoDropdownList: _angular_core.Signal<DropDownListComponent | undefined>;
    kendoPopupSettings: PopupSettings$1;
    optionChanged: boolean;
    allowCustom: boolean;
    dropdownGuide: string;
    isDestroyed$: Subject<void>;
    inputFocused: boolean | undefined;
    getErrorMessage: (name?: string) => string | null;
    ngOnInit(): void;
    private checkValueAndReplaceWithDefault;
    ngOnDestroy(): void;
    focus(): void;
    blur(): void;
    onOptionClick(): void;
    onClose(event: any): void;
    addBlockedPopupClass(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloComboboxField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloComboboxField, "formly-field-combobox", never, {}, {}, never, never, true, never>;
}

declare class HoloCommandsComponent {
    readonly commands: _angular_core.InputSignal<any[]>;
    readonly data: _angular_core.InputSignal<any>;
    getCommandStyle(command: any): string;
    performCommand(command: any): any;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloCommandsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloCommandsComponent, "formly-commands", never, { "commands": { "alias": "commands"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class HoloDatePickerField extends HoloFieldType implements OnInit {
    min: Date | undefined;
    max: Date | undefined;
    placeholder: string;
    isDestroyed$: Subject<void>;
    getErrorMessage: (name?: string) => string | null;
    static transformToFormProperties({ data, key, field }: {
        data: any;
        key: string;
        field: FormlyFieldConfig;
    }): Date;
    static transformToItemProperties({ controlValue, key, }: {
        controlValue: string | Date;
        key: string;
    }): Record<string, string>;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloDatePickerField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloDatePickerField, "formly-field-datepicker", never, {}, {}, never, never, true, never>;
}

declare class HoloDateTimePickerField extends FieldType<FieldTypeConfig> implements AfterViewInit {
    private renderer;
    private element;
    ngAfterViewInit(): void;
    private updateInputClass;
    static transformToFormProperties({ data, key }: {
        data: any;
        key: string;
    }): Date;
    static transformToItemProperties({ controlValue, key, }: {
        controlValue: string | Date;
        key: string;
    }): Record<string, string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloDateTimePickerField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloDateTimePickerField, "formly-field-datetimepicker", never, {}, {}, never, never, true, never>;
}

declare class HoloHtmlTextField extends HoloFieldType {
    get modelValue(): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloHtmlTextField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloHtmlTextField, "formly-field-html-text", never, {}, {}, never, never, true, never>;
}

declare class HoloInputField extends HoloFieldType implements OnInit {
    private _trim;
    private trimOptions;
    isUrlClickable: boolean;
    set trim(value: string);
    get trim(): string;
    readonly inputBlur: _angular_core.OutputEmitterRef<Event>;
    readonly inputFocus: _angular_core.OutputEmitterRef<Event>;
    inputFocused: boolean | undefined;
    getErrorMessage: (name?: string) => string | null;
    ngOnInit(): void;
    get type(): string;
    onInput(event: InputEvent): void;
    onBlur($event: Event): void;
    onClick(): void;
    onFocus($event: Event): void;
    clearValue(): void;
    hasInputValue(): boolean;
    private trimValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloInputField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloInputField, "formly-field-input", never, {}, { "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; }, never, never, true, never>;
}

declare class HoloInputLeftCrossField extends HoloFieldType implements OnInit {
    readonly inputBlur: _angular_core.OutputEmitterRef<Event>;
    readonly inputFocus: _angular_core.OutputEmitterRef<Event>;
    inputFocused: boolean | undefined;
    getErrorMessage: (name?: string) => string | null;
    ngOnInit(): void;
    get type(): string;
    onInput(event: Event): void;
    onBlur($event: Event): void;
    onFocus($event: Event): void;
    clearValue(): void;
    hasInputValue(): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloInputLeftCrossField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloInputLeftCrossField, "formly-field-input-left-cross", never, {}, { "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; }, never, never, true, never>;
}

declare class HoloRadioGroupField extends HoloFieldType {
    readonly inputBlur: _angular_core.OutputEmitterRef<any>;
    datePickerFocused: boolean;
    getErrorMessage: (name?: string) => string | null;
    onDatePickerChange(event: any): void;
    onInput(event: any): void;
    clearValue(): void;
    focus(): void;
    blur(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRadioGroupField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRadioGroupField, "formly-field-radio-group", never, {}, { "inputBlur": "inputBlur"; }, never, never, true, never>;
}

interface RichTextProps extends PropsWithAdditionalProperties {
    imageService: RichTextImageService;
    onFetchImageError?: (error: any) => void;
    isLoading?: (bool: boolean) => void;
    onUploadImage: (file: File) => Observable<string>;
    isRichTextLoading$: BehaviorSubject<boolean>;
    init_instance_callback?: (editor: any) => void;
}
declare class HoloRichtextAreaField extends HoloFieldType implements OnInit, OnDestroy {
    formlyRichtextConfig: RawEditorOptions;
    private dialog;
    fullScreen: boolean;
    editor: Editor | null;
    richtextConfig: TinyMceConfig;
    isFullScreenIconVisible$: BehaviorSubject<boolean>;
    bookmark: Bookmark | undefined;
    private destroyRef;
    getErrorMessage: (name?: string) => string | null;
    static transformToFormProperties({ data, key, field, }: {
        data: any;
        key: string;
        field: FormlyFieldConfig;
    }): Observable<string>;
    static transformToItemProperties({ controlValue, key, }: {
        controlValue: string;
        key: string;
    }): Record<string, string>;
    ngOnInit(): void;
    get componentToolbarId(): string;
    get editorId(): string;
    get dialogHeading(): string;
    private initRichtextConfig;
    get init_instance_callback(): (editor: Editor) => void;
    blurActiveElement(): void;
    checkToExpand(): void;
    toggleFullScreen(isFullScreen?: boolean): void;
    onEnterFullScreen(): void;
    evaluateFullScreenIconVisibility(): void;
    getHeadingLabel(label: string | undefined): string;
    onLinkClick(item: PointerEvent): void;
    onUploadImage({ srcUrl, file }: {
        srcUrl: string;
        file: File;
    }): void;
    onEditorInit(editor: any): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRichtextAreaField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRichtextAreaField, "formly-field-richtext", never, {}, {}, never, never, true, never>;
}
declare function cleanHtmlForForm(content: string): string | null;
declare function fetchImages({ content, imageService, isLoading, onFetchImageError, }: {
    content: string;
    imageService: RichTextImageService;
    isLoading: (bool: boolean) => void;
    onFetchImageError?: (error: any) => void;
}): Observable<string>;

interface HoloRichtextDialogData {
    modalTitle: string;
    richtextConfig: RawEditorOptions;
    props: PropsWithAdditionalProperties;
    formControl: AbstractControl;
    componentToolbarId: string;
    editorId: string;
    charLimit?: number;
    errorMessage?: string;
}
interface Command {
    name: string;
    label: string;
    isVisible: Function;
    styles: string;
}
declare class HoloRichtextDialogComponent implements OnInit {
    private dialogRef;
    charCount: number;
    commands: Command[];
    data: HoloRichtextDialogData;
    isRichTextLoading$: BehaviorSubject<boolean>;
    private destroyRef;
    ngOnInit(): void;
    onPerformCommand(command: any): void;
    getRichtextCharCount(value: string): number;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloRichtextDialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloRichtextDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
}

declare class HoloTextAreaField extends HoloFieldType implements OnInit {
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloTextAreaField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloTextAreaField, "formly-field-textarea", never, {}, {}, never, never, true, never>;
}

declare class HoloTextField extends HoloFieldType implements OnInit {
    hideTextOverflow: boolean;
    icon: string | undefined;
    ngOnInit(): void;
    /**
     * Go through a chain of places props get the value for this control
     */
    get text(): string | undefined;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloTextField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloTextField, "formly-field-text", never, {}, {}, never, never, true, never>;
}

declare class HoloTimePickerField extends HoloFieldType {
    readonly timePicker: _angular_core.Signal<TimePickerComponent | undefined>;
    getErrorMessage: (name?: string) => string | null;
    popupSettings: PopupSettings;
    static transformToFormProperties({ data, key }: {
        data: any;
        key: string;
    }): Date;
    static transformToItemProperties({ controlValue, key, }: {
        controlValue: string | Date;
        key: string;
    }): Record<string, string>;
    toggleTimepicker(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloTimePickerField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloTimePickerField, "formly-field-timepicker", never, {}, {}, never, never, true, never>;
}

declare class HoloHeaderTextField extends HoloFieldType implements OnInit {
    headerText: string;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HoloHeaderTextField, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HoloHeaderTextField, "holo-header-text", never, {}, {}, never, never, true, never>;
}

declare const showRichTextSourceButtonFeature = "showRichTextSourceButton";
declare function mergeRichtextConfig(providedConfig: HoloFormlyConfig, featureToggleManager: FeatureToggleManager): TinyMceConfig;
declare class FormlyModule {
    static forConfig(config?: HoloFormlyConfig, fields?: FormlyFieldConfigFactoryMap): ModuleWithProviders<FormlyModule>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormlyModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<FormlyModule, never, [typeof i1.BrowserModule, typeof i2.BrowserAnimationsModule, typeof i3.CommonModule, typeof MaterialModule, typeof _ngx_formly_core.FormlyModule, typeof i4.ReactiveFormsModule, typeof i7.ComboBoxModule, typeof i7.DropDownListModule, typeof i5.DateInputsModule, typeof i9.EditorModule, typeof i10.RichTextModule, typeof i11.MetamodelModule, typeof i12.NgScrollbarModule, typeof DatepickerModule, typeof FileValueAccessorDirective, typeof HoloRelationshipField, typeof HoloUploaderField, typeof HoloFormlyFieldLabelPipe, typeof FormlyValueAccessorDirective, typeof HoloButtonField, typeof HoloCategoryField, typeof HoloCheckboxField, typeof HoloComboboxField, typeof HoloCommandsComponent, typeof HoloDatePickerField, typeof HoloDateTimePickerField, typeof HoloHtmlTextField, typeof HoloInputField, typeof HoloInputLeftCrossField, typeof HoloRadioGroupField, typeof HoloRelationshipListComponent, typeof HoloRelationshipListItemComponent, typeof HoloRelationshipNoItemComponent, typeof HoloRelationshipSingleComponent, typeof HoloRichtextAreaField, typeof HoloRichtextDialogComponent, typeof HoloTextAreaField, typeof HoloTextField, typeof HoloTimePickerField, typeof TextInputComponent, typeof HoloHeaderTextField], [typeof FileValueAccessorDirective, typeof HoloRelationshipField, typeof HoloUploaderField, typeof HoloFormlyFieldLabelPipe, typeof FormlyValueAccessorDirective, typeof HoloButtonField, typeof HoloCategoryField, typeof HoloCheckboxField, typeof HoloComboboxField, typeof HoloCommandsComponent, typeof HoloDatePickerField, typeof HoloDateTimePickerField, typeof HoloHtmlTextField, typeof HoloInputField, typeof HoloInputLeftCrossField, typeof HoloRadioGroupField, typeof HoloRelationshipListComponent, typeof HoloRelationshipListItemComponent, typeof HoloRelationshipNoItemComponent, typeof HoloRelationshipSingleComponent, typeof HoloRichtextAreaField, typeof HoloRichtextDialogComponent, typeof HoloTextAreaField, typeof HoloTextField, typeof HoloTimePickerField, typeof TextInputComponent, typeof HoloHeaderTextField]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<FormlyModule>;
}

declare function getFormlyFieldLabel(props: PropsWithAdditionalProperties): string;

declare class HoloValidators {
    static passwordValidator(control: AbstractControl): any;
    static notAllSpacesValidator(control: AbstractControl): any;
    static richTextEmptyValidator(control: AbstractControl): any;
    static emailValidator(control: AbstractControl): any;
    static alphanumericalValidator(control: AbstractControl): any;
    static noSpacesValidator(control: AbstractControl): any;
}

declare const TemplateDirectives: ConfigOption;

export { DatepickerModule, FORMLY_FIELD_CONFIG_FACTORIES_TOKEN, FORMLY_FIELD_RICHTEXT_CONFIG, FORMLY_HOLO_CONFIG_TOKEN, FileValueAccessorDirective, FormlyManager, FormlyModule, FormlyValueAccessorDirective, HoloButtonField, HoloCategoryField, HoloCheckboxField, HoloComboboxField, HoloCommandsComponent, HoloDatePickerControl, HoloDatePickerField, HoloDateTimePickerField, HoloFieldType, HoloFormlyFieldLabelPipe, HoloHeaderTextField, HoloHtmlTextField, HoloInputField, HoloInputLeftCrossField, HoloRadioGroupField, HoloRelationshipComponentBase, HoloRelationshipField, HoloRelationshipListComponent, HoloRelationshipListItemComponent, HoloRelationshipNoItemComponent, HoloRelationshipSingleComponent, HoloRichtextAreaField, HoloRichtextDialogComponent, HoloTextAreaField, HoloTextField, HoloTimePickerField, HoloUploaderField, HoloValidators, KendoDatePickerClearInputDirective, MaterialModule, TemplateDirectives, TextInputComponent, attemptTemplateOptionFunction, cleanHtmlForForm, defaultFormlyFieldConfigFactories, defaultRichtextConfig, fetchImages, getFieldLabel, getFormlyFieldLabel, insertMenuButtonName, makeBooleanFormlyFieldConfig, makeCategoryFormlyFieldConfig, makeComboboxFormlyFieldConfig, makeDateTimePickerFormlyFieldConfig, makeMultipleFormlyFieldConfig, makeRelationshipFormlyFieldConfig, makeStringFormlyFieldConfig, makeTextFormlyFieldConfig, mergeRichtextConfig, postprocessContentInElement, postprocessTinyMcePaste, removeUnsupportedStyles, showRichTextSourceButtonFeature, stripHtml, unfreezeProps };
export type { FormlyClassNameConfig, FormlyFieldConfigFactoryMap, HoloFormlyConfig, PropertyWithPropertyOption, PropsWithAdditionalProperties, RichTextProps, StyledItemLabels, StyledItemLabelsFunction, TextWithClass, TextWithIcon, TinyMceConfig };