import * as _angular_forms from '@angular/forms';
import { ControlValueAccessor, FormControl, Validator, FormGroup, ValidationErrors, AbstractControl } from '@angular/forms';
import * as _angular_core from '@angular/core';
import { OnInit, OnDestroy, ElementRef, WritableSignal, AfterViewInit } from '@angular/core';
import { AbstractMatFormField } from '@yuuvis/client-framework/common';
import { TranslateService, Situation, ObjectFormControl, RangeValue, Operator, LocaleNumberPipe, FileSizePipe, OrganizationSetEntry, DateRange, FilesizeRange, FormattedMailTo } from '@yuuvis/client-core';
import { MetadataFormFieldContext } from '@yuuvis/client-framework/metadata-form';
import { DatepickerComponent, DatepickerLabels } from '@yuuvis/client-framework/datepicker';
import { AutocompleteItem } from '@yuuvis/client-framework/autocomplete';
import { MatChipInputEvent, MatChipEditedEvent } from '@angular/material/chips';

declare class CatalogComponent extends AbstractMatFormField<string | string[]> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    readonly: _angular_core.InputSignal<boolean>;
    multiple: _angular_core.InputSignal<boolean>;
    _options: _angular_core.WritableSignal<{
        label: string;
        value: string;
    }[]>;
    options: _angular_core.InputSignal<string[]>;
    /**
     * Additional semantics for the form element.
     */
    classifications: _angular_core.InputSignal<string[]>;
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation validation
     * of the form element will be turned off, so you are able to enter search terms that do not
     * meet the elements validators.
     */
    situation: _angular_core.InputSignal<string | undefined>;
    ngControl: _angular_forms.NgControl | null;
    readonly formCtrl: FormControl<string | string[] | null | undefined>;
    propagateChange: (_: any) => void;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CatalogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CatalogComponent, "yuv-catalog", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare enum DataGridSizeType {
    SMALL = "small",
    MEDIUM = "medium",
    LARGE = "large",
    XLARGE = "extra-large",
    AUTO = "auto"
}

declare class DataGridComponent implements ControlValueAccessor, Validator {
    #private;
    readonly translate: TranslateService;
    readonly el: ElementRef<any>;
    situation: _angular_core.InputSignal<Situation>;
    formElement: _angular_core.InputSignal<Record<string, any> | undefined>;
    mappedFormElement: _angular_core.WritableSignal<Record<string, any> | undefined>;
    formControl: _angular_core.InputSignal<any>;
    classifications: _angular_core.InputSignal<string[]>;
    readonly: _angular_core.InputSignal<boolean>;
    formFieldContext: _angular_core.InputSignal<MetadataFormFieldContext | undefined>;
    size: _angular_core.InputSignal<DataGridSizeType>;
    dataSource: _angular_core.WritableSignal<any[]>;
    tableLabel: _angular_core.Signal<string | undefined>;
    selectedRow: _angular_core.WritableSignal<unknown>;
    isRequired: boolean;
    isInvalid: boolean;
    initalTableUpdate: boolean;
    icons: {
        add: any;
        more: any;
    };
    displayedColumnsWithActions: _angular_core.WritableSignal<string[]>;
    displayedColumns: _angular_core.WritableSignal<any[]>;
    onMenuTrigger(element: unknown | null): void;
    editRow(element: unknown): void;
    addRow(): void;
    removeRow(element: any): void;
    propagateChange: (value: any) => void;
    onTouched: () => void;
    writeValue(obj: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onValueChange(e: any): void;
    validate(control: ObjectFormControl): null;
    onHostFocusOut(ev: FocusEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataGridComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataGridComponent, "yuv-data-grid", never, { "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "formElement": { "alias": "formElement"; "required": false; "isSignal": true; }; "formControl": { "alias": "formControl"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "formFieldContext": { "alias": "formFieldContext"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DatetimeRangeComponent extends AbstractMatFormField<RangeValue<Date | string>> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    /**
     * Enables setting time as well (default: false)
     */
    withTimeInput: _angular_core.InputSignal<boolean>;
    withTime: _angular_core.WritableSignal<boolean>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly: _angular_core.InputSignal<boolean>;
    operator: _angular_core.InputSignal<Operator>;
    situation: _angular_core.InputSignal<string | undefined>;
    private _isValid;
    ngControl: _angular_forms.NgControl | null;
    availableSearchOptions: {
        label: string;
        value: Operator;
    }[];
    rangeForm: FormGroup<{
        dateValue: FormControl<string | Date | undefined>;
        operator: FormControl<Operator>;
        dateValueFrom: FormControl<string | Date | undefined>;
    }>;
    propagateChange: (_: any) => void;
    writeValue(value?: RangeValue<Date | string>): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatetimeRangeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatetimeRangeComponent, "yuv-datetime-range", never, { "withTimeInput": { "alias": "withTime"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "operator": { "alias": "operator"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DatetimeComponent extends AbstractMatFormField<Date | string | null> implements ControlValueAccessor, OnInit {
    #private;
    private translate;
    pickerCmp: _angular_core.Signal<DatepickerComponent>;
    labels?: DatepickerLabels;
    ngControl: _angular_forms.NgControl | null;
    fc: FormControl<Date | null>;
    _locale: _angular_core.WritableSignal<string>;
    locale: _angular_core.InputSignal<string>;
    /**
     * Whether or not to allow only values in the future (default: false)
     */
    onlyFutureDates: _angular_core.InputSignal<boolean>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * Whether to show the calendar icon that opens the date picker calendar (default: true)
     */
    calendar: _angular_core.InputSignal<boolean>;
    /**
     * Enables setting time as well (default: false)
     */
    withTime: _angular_core.InputSignal<boolean>;
    openCalendar(): void;
    propagateChange: (_: any) => void;
    writeValue(value: string | Date): void;
    registerOnChange(fn: () => void): void;
    registerOnTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    onValueChange(e: any): void;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatetimeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatetimeComponent, "yuv-datetime", never, { "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "onlyFutureDates": { "alias": "onlyFutureDates"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "calendar": { "alias": "calendar"; "required": false; "isSignal": true; }; "withTime": { "alias": "withTime"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface DynamicCatalogOption {
    value: string;
    label: string;
    disabled: boolean;
    invalid?: boolean;
}
interface SelectedDisplay {
    value: string;
    label: string;
    invalid: boolean;
}
declare class DynamicCatalogComponent extends AbstractMatFormField<string | string[]> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    catalog: _angular_core.InputSignal<string>;
    readonly: _angular_core.InputSignal<boolean>;
    multiple: _angular_core.InputSignal<boolean>;
    options: WritableSignal<DynamicCatalogOption[]>;
    selectedDisplay: _angular_core.Signal<SelectedDisplay[]>;
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation
     * validation of the form element will be turned off, so you are able to enter
     * search terms that do not meet the elements validators.
     */
    situation: _angular_core.InputSignal<string | undefined>;
    ngControl: _angular_forms.NgControl | null;
    readonly ctrl: FormControl<string | string[] | null | undefined>;
    constructor();
    propagateChange: (fnc: any) => void;
    writeValue(value: string | string[]): void;
    registerOnChange(fnc: any): void;
    registerOnTouched(): void;
    setDisabledState(isDisabled: boolean): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicCatalogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicCatalogComponent, "yuv-dynamic-catalog", never, { "catalog": { "alias": "catalog"; "required": true; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Form element for selecting one or multiple i18n catalog values.
 * Having a classification of `i18n:catalog[one, two, three]` configured on the metadata field
 * will automatically populate the options from the catalog. The options will be translated
 * using the catalogs static values adding a prefix, the property name an the value itself.
 * E.g. for property name `status` and option value `open` the label key will be `catalog:status:open_label`.
 */
declare class I18nCatalogComponent extends AbstractMatFormField<string | string[]> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    private readonly translate;
    readonly: _angular_core.InputSignal<boolean>;
    multiple: _angular_core.InputSignal<boolean>;
    propertyName: _angular_core.InputSignal<string | undefined>;
    _options: _angular_core.WritableSignal<{
        label: string;
        value: string;
    }[]>;
    options: _angular_core.InputSignal<string[]>;
    /**
     * Additional semantics for the form element.
     */
    classifications: _angular_core.InputSignal<string[]>;
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation validation of the form element will be turned off, so you are able to enter search terms that do not meet the elements validators.
     */
    situation: _angular_core.InputSignal<string | undefined>;
    ngControl: _angular_forms.NgControl | null;
    readonly fc: FormControl<string | string[] | null | undefined>;
    constructor();
    propagateChange: (_: any) => void;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<I18nCatalogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<I18nCatalogComponent, "yuv-i18n-catalog", never, { "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "propertyName": { "alias": "propertyName"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Creates form input for ranges of numeric values.
 *
 * Implements `ControlValueAccessor` so it can be used within Angular forms.
 *
 * @example
 * <yuv-number-range [scale]="2"></yuv-number-range>
 *
 */
declare class NumberRangeComponent extends AbstractMatFormField<RangeValue> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    /**
     * Number of decimal places
     */
    readonly scale: _angular_core.InputSignal<number | undefined>;
    /**
     * Overall amount of digits allowed (including decimal places)
     */
    readonly precision: _angular_core.InputSignal<number | undefined>;
    /**
     *  Set to true to group number by pattern
     */
    readonly grouping: _angular_core.InputSignal<boolean>;
    /**
     * The pattern to group number value by
     */
    readonly pattern: _angular_core.InputSignal<string | undefined>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly readonly: _angular_core.InputSignal<boolean>;
    /**
     * classification property adds some semantics to the value of this component.
     * If you provide a value of `filesize` numbers typed into the control will be
     * handled like file sizes (calculates differnt units)
     */
    readonly classifications: _angular_core.InputSignal<string[]>;
    /**
     * set minimum input value
     */
    readonly minValue: _angular_core.InputSignal<number | undefined>;
    /**
     * set maximum input value
     *
     */
    readonly maxValue: _angular_core.InputSignal<number | undefined>;
    situation: _angular_core.InputSignal<string | null>;
    private isValid;
    ngControl: _angular_forms.NgControl | null;
    availableSearchOptions: {
        label: string;
        value: Operator;
    }[];
    rangeForm: FormGroup<{
        numberValue: FormControl<number | undefined>;
        operator: FormControl<Operator>;
        numberValueFrom: FormControl<number | undefined>;
    }>;
    propagateChange: (_: any) => void;
    writeValue(value: RangeValue): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    validate(): any;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberRangeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberRangeComponent, "yuv-number-range", never, { "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Creates form input for number values.
 *
 * Implements `ControlValueAccessor` so it can be used within Angular forms.
 *
 * @example
 * <yuv-number [scale]="2"></yuv-number>
 *
 */
declare class NumberComponent extends AbstractMatFormField<number> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    readonly translate: TranslateService;
    validationErrors: ValidationErrors[];
    transformPipe: LocaleNumberPipe | FileSizePipe;
    innerCtrl: FormControl<string | null>;
    ngControl: _angular_forms.NgControl | null;
    /**
     * Number of decimal places
     */
    scale: _angular_core.InputSignal<number | undefined>;
    /**
     * Overall amount of digits allowed (including decimal places)
     */
    precision: _angular_core.InputSignal<number | undefined>;
    /**
     *  Set to true to group number by pattern
     */
    grouping: _angular_core.InputSignal<boolean>;
    /**
     * The pattern to group number value by
     */
    groupPattern: _angular_core.InputSignal<string | undefined>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * set minimum input value
     */
    minValue: _angular_core.InputSignal<number | undefined>;
    /**
     * set maximum input value
     *
     */
    maxValue: _angular_core.InputSignal<number | undefined>;
    /**
     * classification property adds some semantics to the value of this component.
     * If you provide a value of `filesize` numbers typed into the control will be
     * handled like file sizes (calculates differnt units)
     */
    classifications: _angular_core.InputSignal<string[]>;
    static betweenTwoNumbers(val: number, minVal: number | undefined, maxVal: number | undefined): boolean;
    propagateChange: (_: any) => void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    format(): void;
    unformat(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberComponent, "yuv-number", never, { "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "precision": { "alias": "precision"; "required": false; "isSignal": true; }; "grouping": { "alias": "grouping"; "required": false; "isSignal": true; }; "groupPattern": { "alias": "groupPattern"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "minValue": { "alias": "minValue"; "required": false; "isSignal": true; }; "maxValue": { "alias": "maxValue"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Creates form input for organization set values. An organization set is
 * either a user or a role. This control will emit a stringified JSON object of
 * a OrganizationSetEntry object.
 *
 * ```json
 * {
 *   "id:organization:set": [
 *     "{\"id\":\"YUUVIS_AI_PREDICT\",\"title\":\"YUUVIS_AI_PREDICT\",\"type\":\"role\"}"
 *   ]
 * }
 * ```
 */
declare class OrganizationSetComponent extends AbstractMatFormField<string | string[] | undefined> implements ControlValueAccessor, OnDestroy, OnInit {
    #private;
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation validation of the form element will be turned off, so you are able to enter search terms that do not meet the elements validators.
     */
    situation: _angular_core.InputSignal<string | undefined>;
    /**
     * Indicator that multiple strings could be inserted, they will be rendered as chips (default: false).
     */
    multiselect: _angular_core.InputSignal<boolean>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * Whether or not the emitted value should be an object containing id and title
     * or, if set to false only the ID
     */
    withMetadata: _angular_core.InputSignal<boolean>;
    /**
     * Minimum length of the autocomplete input before a query is sent to the server.
     */
    autocompleteMinLength: _angular_core.InputSignal<number>;
    classifications: _angular_core.InputSignal<string[] | undefined>;
    types: _angular_core.InputSignal<string[] | undefined>;
    busy: _angular_core.WritableSignal<boolean>;
    acFormControl: FormControl<AutocompleteItem<unknown> | AutocompleteItem<unknown>[] | null | undefined>;
    ngControl: _angular_forms.NgControl | null;
    innerValue: OrganizationSetEntry[];
    autocompleteRes: AutocompleteItem[];
    propagateChange: (_: any) => void;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    private propagate;
    autocompleteFn(query: string): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationSetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationSetComponent, "yuv-organization-set", never, { "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "withMetadata": { "alias": "withMetadata"; "required": false; "isSignal": true; }; "autocompleteMinLength": { "alias": "autocompleteMinLength"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "types": { "alias": "types"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type OrganizationNode = OrganizationSetEntry & {
    notFound?: boolean;
};
type FormControlValue = string | {
    id: string;
    title: string;
};
/**
 * Creates form input for organization values.
 *
 * @example
 * <yuv-organization [multiselect]="true"></yuv-organization>
 */
declare class OrganizationComponent extends AbstractMatFormField<FormControlValue | FormControlValue[] | undefined> implements ControlValueAccessor, OnInit, OnDestroy {
    #private;
    readonly translate: TranslateService;
    minLength: number;
    busy: _angular_core.WritableSignal<boolean>;
    acFormControl: FormControl<AutocompleteItem<unknown> | AutocompleteItem<unknown>[] | null | undefined>;
    ngControl: _angular_forms.NgControl | null;
    _innerValue: OrganizationNode[];
    set innerValue(iv: OrganizationNode[]);
    get innerValue(): OrganizationNode[];
    autocompleteRes: AutocompleteItem[];
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation validation of the form element will be turned off, so you are able to enter search terms that do not meet the elements validators.
     */
    situation: _angular_core.InputSignal<string | undefined>;
    /**
     * Indicator that multiple strings could be inserted, they will be rendered as chips (default: false).
     */
    multiselect: _angular_core.InputSignal<boolean>;
    classifications: _angular_core.InputSignal<string[] | undefined>;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly: _angular_core.InputSignal<boolean>;
    /**
     * Whether or not to exclude the current user from autocomplete result
     */
    excludeMe: _angular_core.InputSignal<boolean>;
    /**
     * Whether or not the emitted value should be an object containing id and title
     * or, if set to false only the ID
     */
    withMetadata: _angular_core.InputSignal<boolean>;
    propagateChange: (_: any) => void;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    private propagate;
    setDisabledState?(isDisabled: boolean): void;
    resolveFn(value: string[]): void;
    autocompleteFn(query: string): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OrganizationComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OrganizationComponent, "yuv-organization", never, { "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "excludeMe": { "alias": "excludeMe"; "required": false; "isSignal": true; }; "withMetadata": { "alias": "withMetadata"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface RangeSelectDateValue {
    rangeValue: RangeValue;
    label?: string;
}

/**
 * Component for selecting a date range based on pre-defined ranges like
 * 'today', 'this week', 'this month', etc.
 * It also allows to pick a custom date range.
 */
declare class RangeSelectDateComponent extends AbstractMatFormField<RangeSelectDateValue> implements ControlValueAccessor, OnDestroy {
    #private;
    private translate;
    options: _angular_core.WritableSignal<{
        label: string;
        value: unknown;
    }[]>;
    readonly fc: FormControl<string>;
    ngControl: _angular_forms.NgControl | null;
    get shouldLabelFloat(): boolean;
    /**
     * Range values to be used in the dropdown.
     */
    ranges: _angular_core.InputSignal<DateRange[]>;
    /**
     * Whether to show the custom date range option.
     */
    customRange: _angular_core.InputSignal<boolean>;
    constructor();
    propagateChange: (_: any) => void;
    writeValue(value?: RangeSelectDateValue): void;
    registerOnChange(fn: () => void): void;
    registerOnTouched(fn: () => void): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RangeSelectDateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RangeSelectDateComponent, "yuv-range-select-date", never, { "ranges": { "alias": "ranges"; "required": false; "isSignal": true; }; "customRange": { "alias": "customRange"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

interface RangeSelectFilesizeValue {
    rangeValue: RangeValue;
    label?: string;
}

/**
 * Component for selecting a range of filesizes based on pre-defined ranges like
 * 'today', 'this week', 'this month', etc.
 */
declare class RangeSelectFilesizeComponent extends AbstractMatFormField<RangeSelectFilesizeValue> implements ControlValueAccessor, OnDestroy {
    #private;
    private translate;
    options: _angular_core.WritableSignal<{
        label: string;
        value: unknown;
    }[]>;
    readonly fc: FormControl<string>;
    ngControl: _angular_forms.NgControl | null;
    get shouldLabelFloat(): boolean;
    /**
     * Range values to be used in the dropdown.
     */
    ranges: _angular_core.InputSignal<FilesizeRange[]>;
    constructor();
    propagateChange: (_: any) => void;
    writeValue(value?: RangeSelectFilesizeValue): void;
    registerOnChange(fn: () => void): void;
    registerOnTouched(fn: () => void): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RangeSelectFilesizeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RangeSelectFilesizeComponent, "yuv-range-select-filesize", never, { "ranges": { "alias": "ranges"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Creates form input for strings. Based on the input values different kinds of inputs will be generated.
 *
 * Implements `ControlValueAccessor` so it can be used within Angular forms.
 *
 * @example
 * <!-- string input validating input to be between 5 and 10 characters -->
 * <yuv-string [minLength]="5" [maxLength]="10"></yuv-string>
 *
 * <!-- string input that only allow digits -->
 * <yuv-string  [regex]="[0-9]*"></yuv-string>
 *
 * <!-- string input rendering a large textarea -->
 * <yuv-string [rows]="10"></yuv-string>
 *
 */
declare class StringComponent extends AbstractMatFormField<string | string[] | undefined> implements ControlValueAccessor, AfterViewInit, OnInit, OnDestroy {
    #private;
    readonly fc: FormControl<string | string[] | null | undefined>;
    readonly separatorKeysCodes: readonly [13, 188];
    classifiytionIcons: {
        email: string;
        url: string;
        phone: string;
    };
    maxEntryCountIfInvalid?: number;
    /**
     * Indicator that multiple strings could be inserted, they will be rendered as chips (default: false).
     */
    readonly multiselect: _angular_core.InputSignal<boolean>;
    /**
     * Setting rows to more than 1 will generate a textarea instead of an input tag
     * and apply the rows property to it
     */
    rows?: number;
    /**
     * Will prevent the input from being changed (default: false)
     */
    readonly readonly: _angular_core.InputSignal<boolean>;
    /**
     * Enable autofucus for the input (default: false)
     */
    readonly autofocus: _angular_core.InputSignal<boolean>;
    /**
     * Additional semantics for the form element. Possible values are
     * `email` (validates and creates a link to send an email once there
     * is a valid email address) and `url` (validates and creates a link
     * to an URL typed into the form element).
     */
    set classifications(c: string[]);
    get classifications(): string[];
    /**
     * Possibles values are `EDIT` (default),`SEARCH`,`CREATE`. In search situation validation of the form element will be turned off, so you are able to enter search terms that do not meet the elements validators.
     */
    readonly situation: _angular_core.InputSignal<string | undefined>;
    /**
     * Regular expression to validate the input value against
     */
    readonly regex: _angular_core.InputSignal<string | undefined>;
    /**
     * Minimal number of characters
     */
    readonly minLength: _angular_core.InputSignal<number | undefined>;
    /**
     * Maximum number of characters
     */
    readonly maxLength: _angular_core.InputSignal<number | undefined>;
    formatedValue?: FormattedMailTo;
    valid: boolean;
    validationErrors: {
        [key: string]: any;
    }[];
    classify?: {
        hrefPrefix: string;
        icon: string | undefined;
    };
    ngControl: _angular_forms.NgControl | null;
    propagateChange: (_: any) => void;
    private propagate;
    writeValue(value: string | string[]): void;
    registerOnChange(fn: any): void;
    registerOnTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    onBlur(): void;
    chipsAdd(event: MatChipInputEvent): void;
    chipsRemove(v: string): void;
    chipsEdit(v: string, event: MatChipEditedEvent): void;
    private validateClassification;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StringComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StringComponent, "yuv-string", never, { "multiselect": { "alias": "multiselect"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "classifications": { "alias": "classifications"; "required": false; }; "situation": { "alias": "situation"; "required": false; "isSignal": true; }; "regex": { "alias": "regex"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Module for the forms library.
 */
declare class YuvFormsModule {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YuvFormsModule, never>;
    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<YuvFormsModule, never, [typeof StringComponent, typeof NumberComponent, typeof NumberRangeComponent, typeof DatetimeComponent, typeof DatetimeRangeComponent, typeof OrganizationComponent, typeof StringComponent, typeof CatalogComponent, typeof DynamicCatalogComponent, typeof I18nCatalogComponent], [typeof StringComponent, typeof NumberComponent, typeof NumberRangeComponent, typeof DatetimeComponent, typeof DatetimeRangeComponent, typeof OrganizationComponent, typeof StringComponent, typeof CatalogComponent, typeof DynamicCatalogComponent, typeof I18nCatalogComponent]>;
    static ɵinj: _angular_core.ɵɵInjectorDeclaration<YuvFormsModule>;
}

declare class FormUtils {
    static getErrorState(control: AbstractControl): boolean;
}

export { CatalogComponent, DataGridComponent, DatetimeComponent, DatetimeRangeComponent, DynamicCatalogComponent, FormUtils, I18nCatalogComponent, NumberComponent, NumberRangeComponent, OrganizationComponent, OrganizationSetComponent, RangeSelectDateComponent, RangeSelectFilesizeComponent, StringComponent, YuvFormsModule };
export type { RangeSelectDateValue, RangeSelectFilesizeValue };