import * as _angular_core from '@angular/core';
import { OnDestroy, Signal, WritableSignal, AfterViewInit, ElementRef, InjectionToken, OnChanges, EventEmitter, OnInit } from '@angular/core';
import * as _angular_forms from '@angular/forms';
import { NgModel, FormControlDirective, FormControlName, ControlValueAccessor, ValidatorFn } from '@angular/forms';
import { FilterPillInputComponent, FilterPillLayout } from '@lucca-front/ng/filter-pills';
import * as _lucca_front_ng_form_field from '@lucca-front/ng/form-field';
import { FormFieldComponent } from '@lucca-front/ng/form-field';
import { ConnectionPositionPair } from '@angular/cdk/overlay';
import { NumberFormatStyle, NumberFormatCurrencyDisplay, NumberFormatUnit, NumberFormatUnitDisplay } from '@lucca-front/ng/number-format';
import { LuccaIcon } from '@lucca-front/icons';
import { LuTranslation, PortalContent } from '@lucca-front/ng/core';

declare class FormFieldIdDirective implements OnDestroy {
    #private;
    set suffix(suffix: string);
    labelledByStrategy: 'prepend' | 'append';
    get id(): string;
    constructor();
    private applyLabelledBy;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldIdDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormFieldIdDirective, "[luFormFieldId]", never, { "suffix": { "alias": "luFormFieldId"; "required": true; }; "labelledByStrategy": { "alias": "labelledByStrategy"; "required": false; }; }, {}, never, never, true, never>;
}

declare function injectNgControl(): NgModel | FormControlDirective | FormControlName;

declare class NoopValueAccessorDirective implements ControlValueAccessor {
    writeValue(): void;
    registerOnChange(): void;
    registerOnTouched(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NoopValueAccessorDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NoopValueAccessorDirective, "[luNoopValueAccessor]", never, {}, {}, never, never, true, never>;
}

declare class CheckboxInputComponent implements FilterPillInputComponent {
    formField: FormFieldComponent;
    isFilterPill: boolean;
    filterPillInputId: string;
    checklist: _angular_core.InputSignalWithTransform<boolean, unknown>;
    filterPillLayout: Signal<FilterPillLayout>;
    isFilterPillEmpty: Signal<boolean>;
    isFilterPillClearable: Signal<boolean>;
    hideCombobox: Signal<boolean>;
    showColon: Signal<boolean>;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    /**
     * Should set aria-checked='mixed' attribute ?
     */
    mixed: boolean;
    framed: boolean;
    constructor();
    clearFilterPillValue(): void;
    registerFilterPillClosePopover(_closeFn: () => void): void;
    enableFilterPillMode?(): void;
    onFilterPillClick(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxInputComponent, "lu-checkbox-input", never, { "checklist": { "alias": "checklist"; "required": false; "isSignal": true; }; "mixed": { "alias": "mixed"; "required": false; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_mixed: unknown;
}

interface MultilanguageTranslation {
    cultureCode: string;
    value: string;
}

interface LuMultilanguageInputTranslations {
    clear: string;
    toggleMultilanguage: string;
    translateTo: string;
}

declare class MultilanguageInputComponent implements ControlValueAccessor {
    #private;
    intl: LuMultilanguageInputTranslations;
    formFieldSize: _angular_core.InputSignal<_lucca_front_ng_form_field.FormFieldSize>;
    protected onTouched: () => void;
    protected onChange: (_value: MultilanguageTranslation[]) => void;
    placeholder: _angular_core.InputSignal<string>;
    disabledInternal: WritableSignal<boolean>;
    model: WritableSignal<MultilanguageTranslation[]>;
    invariant: _angular_core.Signal<MultilanguageTranslation | {
        value: string;
    }>;
    panelInputs: _angular_core.Signal<MultilanguageTranslation[]>;
    popoverPositions: ConnectionPositionPair[];
    getLocaleDisplayName(locale: string): string;
    writeValue(value: MultilanguageTranslation[]): void;
    registerOnChange(fn: (value: MultilanguageTranslation[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    valueChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultilanguageInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultilanguageInputComponent, "lu-multilanguage-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function areAllLanguagesFilled(model: MultilanguageTranslation[]): boolean;
declare const MultiLanguageInputValidators: Record<string, ValidatorFn>;

interface LuNumberFormatFieldLabel {
    clear: string;
}

type TextfieldIconAddon = {
    icon: LuccaIcon;
    ariaLabel: string;
};
type TextfieldTextAddon = {
    content: string;
    ariaLabel: string;
};
type TextInputAddon = TextfieldIconAddon | TextfieldTextAddon;

declare class NumberFormatInputComponent implements AfterViewInit {
    #private;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    ngAfterViewInit(): void;
    formatStyle: _angular_core.InputSignal<NumberFormatStyle>;
    useAutoPrefixSuffix: _angular_core.InputSignal<boolean>;
    prefix: _angular_core.InputSignal<TextInputAddon>;
    suffix: _angular_core.InputSignal<TextInputAddon>;
    currency: _angular_core.InputSignal<string>;
    currencyDisplay: _angular_core.InputSignal<NumberFormatCurrencyDisplay>;
    unit: _angular_core.InputSignal<NumberFormatUnit>;
    unitDisplay: _angular_core.InputSignal<NumberFormatUnitDisplay>;
    min: _angular_core.InputSignal<number>;
    max: _angular_core.InputSignal<number>;
    placeholder: _angular_core.InputSignal<string>;
    hasClearer: _angular_core.InputSignalWithTransform<boolean, unknown>;
    valueAlignRight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    inputElementRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    prefixAddon: _angular_core.Signal<TextInputAddon>;
    suffixAddon: _angular_core.Signal<TextInputAddon>;
    formatOptions: _angular_core.Signal<{
        locale: string;
        style: NumberFormatStyle;
        min: number;
        max: number;
        currency: string;
        currencyDisplay: NumberFormatCurrencyDisplay;
        unit: NumberFormatUnit;
        unitDisplay: NumberFormatUnitDisplay;
    }>;
    intl: LuNumberFormatFieldLabel;
    clearValue(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberFormatInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberFormatInputComponent, "lu-number-format-input", never, { "formatStyle": { "alias": "formatStyle"; "required": false; "isSignal": true; }; "useAutoPrefixSuffix": { "alias": "useAutoPrefixSuffix"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; "isSignal": true; }; "unit": { "alias": "unit"; "required": false; "isSignal": true; }; "unitDisplay": { "alias": "unitDisplay"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "hasClearer": { "alias": "hasClearer"; "required": false; "isSignal": true; }; "valueAlignRight": { "alias": "valueAlignRight"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare const LU_NUMBERFIELD_TRANSLATIONS: InjectionToken<LuTranslation<LuNumberFieldLabel>>;
interface LuNumberFieldLabel {
    clear: string;
}
declare const luNumberFieldTranslations: LuTranslation<LuNumberFieldLabel>;

declare class NumberInputComponent {
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    placeholder: _angular_core.InputSignal<string>;
    step: _angular_core.InputSignalWithTransform<number, number>;
    noSpinButtons: _angular_core.InputSignalWithTransform<boolean, unknown>;
    hasClearer: _angular_core.InputSignalWithTransform<boolean, unknown>;
    inputElementRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    prefix: _angular_core.InputSignal<TextInputAddon>;
    suffix: _angular_core.InputSignal<TextInputAddon>;
    min: _angular_core.InputSignal<number>;
    max: _angular_core.InputSignal<number>;
    valueAlignRight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    intl: LuNumberFieldLabel;
    clearValue(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "lu-number-input", never, { "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "noSpinButtons": { "alias": "noSpinButtons"; "required": false; "isSignal": true; }; "hasClearer": { "alias": "hasClearer"; "required": false; "isSignal": true; }; "prefix": { "alias": "prefix"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "valueAlignRight": { "alias": "valueAlignRight"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class RadioGroupInputComponent {
    formField: FormFieldComponent;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    size: 'S' | 'M';
    framed: _angular_core.InputSignalWithTransform<boolean, unknown>;
    name: string;
    arrow?: 'neutral' | 'default';
    get isFramed(): boolean;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupInputComponent, "lu-radio-group-input", never, { "size": { "alias": "size"; "required": false; }; "framed": { "alias": "framed"; "required": false; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": false; }; }, {}, never, ["*"], true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class RadioComponent<T = unknown> implements OnChanges {
    #private;
    value: T;
    disabled: boolean;
    inlineMessage: PortalContent;
    tag: string;
    framedPortal: PortalContent;
    get arrow(): "default" | "neutral";
    get framed(): boolean;
    get notFramed(): boolean;
    get formControl(): _angular_forms.FormControl<any>;
    get name(): string;
    id: string;
    ngOnChanges(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent<any>, "lu-radio", never, { "value": { "alias": "value"; "required": true; }; "disabled": { "alias": "disabled"; "required": false; }; "inlineMessage": { "alias": "inlineMessage"; "required": false; }; "tag": { "alias": "tag"; "required": false; }; "framedPortal": { "alias": "framedPortal"; "required": false; }; }, {}, never, ["*", "[illustration]", "[info]"], true, never>;
    static ngAcceptInputType_disabled: unknown;
}

declare class SwitchInputComponent {
    formField: FormFieldComponent;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchInputComponent, "lu-switch-input", never, {}, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare const LU_TEXTFIELD_TRANSLATIONS: InjectionToken<LuTranslation<LuTextfieldLabel>>;
interface LuTextfieldLabel {
    clear: string;
    togglePasswordVisibility: string;
}
declare const luTextfieldTranslations: LuTranslation<LuTextfieldLabel>;

type TextFieldType = 'text' | 'email' | 'password' | 'url';
declare class TextInputComponent {
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    placeholder: string;
    autocomplete: AutoFill;
    hasClearer: boolean;
    hasSearchIcon: boolean;
    valueAlignRight: boolean;
    inputElementRef: ElementRef<HTMLInputElement>;
    prefix: TextInputAddon;
    suffix: TextInputAddon;
    blur: EventEmitter<FocusEvent>;
    get type(): TextFieldType;
    set type(type: TextFieldType);
    /**
     * Search icon to use for when `hasSearchIcon` is true, defaults to 'search'
     */
    searchIcon: LuccaIcon;
    showPassword: boolean;
    private _type;
    protected hasTogglePasswordVisibilityIcon(): boolean;
    intl: LuTextfieldLabel;
    clearValue(): void;
    togglePasswordVisibility(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextInputComponent, "lu-text-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "hasClearer": { "alias": "hasClearer"; "required": false; }; "hasSearchIcon": { "alias": "hasSearchIcon"; "required": false; }; "valueAlignRight": { "alias": "valueAlignRight"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "type": { "alias": "type"; "required": false; }; "searchIcon": { "alias": "searchIcon"; "required": false; }; }, { "blur": "blur"; }, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_hasClearer: unknown;
    static ngAcceptInputType_hasSearchIcon: unknown;
    static ngAcceptInputType_valueAlignRight: unknown;
}

declare class TextareaInputComponent implements OnInit {
    #private;
    parent?: ElementRef<HTMLElement>;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    placeholder: string;
    rows?: number;
    autoResize: boolean;
    autoResizeScrollIntoView: boolean;
    disableSpeelcheck: _angular_core.InputSignalWithTransform<boolean, unknown>;
    cloneValue: string;
    updateScroll(value: string): void;
    ngOnInit(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaInputComponent, "lu-textarea-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "autoResize": { "alias": "autoResize"; "required": false; }; "autoResizeScrollIntoView": { "alias": "autoResizeScrollIntoView"; "required": false; }; "disableSpeelcheck": { "alias": "disableSpeelcheck"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
    static ngAcceptInputType_autoResize: unknown;
    static ngAcceptInputType_autoResizeScrollIntoView: unknown;
}

declare class FieldsetComponent {
    heading: _angular_core.InputSignal<PortalContent>;
    helper: _angular_core.InputSignal<PortalContent>;
    size: _angular_core.InputSignal<"S">;
    horizontal: _angular_core.InputSignalWithTransform<boolean, unknown>;
    expandable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    expanded: _angular_core.ModelSignal<boolean>;
    id: string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldsetComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldsetComponent, "lu-fieldset", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "helper": { "alias": "helper"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "horizontal": { "alias": "horizontal"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
}

export { CheckboxInputComponent, FieldsetComponent, FormFieldIdDirective, LU_NUMBERFIELD_TRANSLATIONS, LU_TEXTFIELD_TRANSLATIONS, MultiLanguageInputValidators, MultilanguageInputComponent, NoopValueAccessorDirective, NumberFormatInputComponent, NumberInputComponent, RadioComponent, RadioGroupInputComponent, SwitchInputComponent, TextInputComponent, TextareaInputComponent, areAllLanguagesFilled, injectNgControl, luNumberFieldTranslations, luTextfieldTranslations };
export type { LuNumberFieldLabel, LuTextfieldLabel, MultilanguageTranslation, TextInputAddon, TextfieldIconAddon, TextfieldTextAddon };