import * as _angular_core from '@angular/core';
import { OnDestroy, Signal, WritableSignal, AfterViewInit, ElementRef, OnInit, InjectionToken } 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 * as _lucca_front_ng_forms from '@lucca-front/ng/forms';
import { PortalContent, LuTranslation } from '@lucca-front/ng/core';

declare class FormFieldIdDirective implements OnDestroy {
    #private;
    readonly suffix: _angular_core.InputSignal<string>;
    readonly labelledByStrategy: _angular_core.InputSignal<"prepend" | "append">;
    readonly id: _angular_core.Signal<string>;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldIdDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<FormFieldIdDirective, "[luFormFieldId]", never, { "suffix": { "alias": "luFormFieldId"; "required": false; "isSignal": true; }; "labelledByStrategy": { "alias": "labelledByStrategy"; "required": false; "isSignal": true; }; }, {}, 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>;
}

interface CheckboxInputTranslations {
    yes: string;
    no: string;
}

declare class CheckboxInputComponent implements FilterPillInputComponent {
    framed: boolean;
    parentInput: FilterPillInputComponent;
    formField: FormFieldComponent;
    intl: CheckboxInputTranslations;
    readonly checklist: _angular_core.InputSignalWithTransform<boolean, unknown>;
    /**
     * Should set aria-checked='mixed' attribute ?
     */
    readonly mixed: _angular_core.InputSignalWithTransform<boolean, unknown>;
    isFilterPill: _angular_core.WritableSignal<boolean>;
    filterPillInputId: string;
    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;
    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; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

interface MultilanguageTranslation {
    cultureCode: string;
    value: string;
}
declare const INVARIANT_CULTURE_CODE = "invariant";

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

declare class MultilanguageInputComponent implements ControlValueAccessor {
    #private;
    intl: _angular_core.InputSignalWithTransform<LuMultilanguageInputTranslations, Partial<LuMultilanguageInputTranslations>>;
    formFieldSize: _angular_core.InputSignal<_lucca_front_ng_form_field.FormFieldSize>;
    protected onTouched: () => void;
    protected onChange: (_value: MultilanguageTranslation[]) => void;
    placeholder: _angular_core.InputSignal<string>;
    openOnFocus: _angular_core.InputSignalWithTransform<boolean, unknown>;
    autocomplete: _angular_core.InputSignal<AutoFill>;
    disabledInternal: WritableSignal<boolean>;
    model: WritableSignal<MultilanguageTranslation[]>;
    invariant: _angular_core.Signal<MultilanguageTranslation | {
        value: string;
    }>;
    panelInputs: _angular_core.Signal<MultilanguageTranslation[]>;
    presentationValue: _angular_core.Signal<string>;
    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, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "openOnFocus": { "alias": "openOnFocus"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare function areAllLanguagesFilled(model: MultilanguageTranslation[]): boolean;
declare function isInvariantFilled(model: MultilanguageTranslation[]): boolean;
declare const MultiLanguageInputValidators: Record<'allLanguagesRequired' | 'invariantRequired', 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;
    readonly formatStyle: _angular_core.InputSignal<NumberFormatStyle>;
    readonly useAutoPrefixSuffix: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly prefix: _angular_core.InputSignal<TextInputAddon>;
    readonly suffix: _angular_core.InputSignal<TextInputAddon>;
    readonly currency: _angular_core.InputSignal<string>;
    readonly currencyDisplay: _angular_core.InputSignal<NumberFormatCurrencyDisplay>;
    readonly unit: _angular_core.InputSignal<NumberFormatUnit>;
    readonly unitDisplay: _angular_core.InputSignal<NumberFormatUnitDisplay>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly hasClearer: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly valueAlignRight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    inputElementRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    readonly prefixAddon: _angular_core.Signal<TextInputAddon>;
    readonly suffixAddon: _angular_core.Signal<TextInputAddon>;
    readonly formatOptions: _angular_core.Signal<{
        locale: string;
        style: NumberFormatStyle;
        min: number;
        max: number;
        currency: string;
        currencyDisplay: NumberFormatCurrencyDisplay;
        unit: NumberFormatUnit;
        unitDisplay: NumberFormatUnitDisplay;
    }>;
    formattedValue: _angular_core.Signal<string>;
    readonly intl: _angular_core.InputSignalWithTransform<LuNumberFormatFieldLabel, Partial<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; }; "intl": { "alias": "intl"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class NumberInputComponent {
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly step: _angular_core.InputSignalWithTransform<number, number>;
    readonly noSpinButtons: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly hasClearer: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly inputElementRef: _angular_core.Signal<ElementRef<HTMLInputElement>>;
    readonly prefix: _angular_core.InputSignal<TextInputAddon>;
    readonly suffix: _angular_core.InputSignal<TextInputAddon>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly valueAlignRight: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly intl: _angular_core.InputSignalWithTransform<_lucca_front_ng_forms.LuNumberFieldLabel, Partial<_lucca_front_ng_forms.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; }; "intl": { "alias": "intl"; "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;
    readonly size: _angular_core.InputSignal<"S" | "M">;
    readonly framed: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly framedCenter: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly framedSize: _angular_core.InputSignal<"L">;
    readonly arrow: _angular_core.InputSignal<"default" | "neutral">;
    name: string;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupInputComponent, "lu-radio-group-input", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "framed": { "alias": "framed"; "required": false; "isSignal": true; }; "framedCenter": { "alias": "framedCenter"; "required": false; "isSignal": true; }; "framedSize": { "alias": "framedSize"; "required": false; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class RadioComponent<T = unknown> {
    #private;
    readonly value: _angular_core.InputSignal<T>;
    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly inlineMessage: _angular_core.InputSignal<PortalContent>;
    readonly tag: _angular_core.InputSignal<string>;
    readonly framedPortal: _angular_core.InputSignal<PortalContent>;
    readonly arrow: _angular_core.Signal<"default" | "neutral">;
    readonly framed: _angular_core.Signal<boolean>;
    readonly framedCenter: _angular_core.Signal<boolean>;
    readonly framedSize: _angular_core.Signal<"L">;
    readonly size: _angular_core.Signal<"S" | "M">;
    get ngControl(): _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    get formControl(): _angular_forms.FormControl<any>;
    get name(): string;
    id: string;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent<any>, "lu-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "inlineMessage": { "alias": "inlineMessage"; "required": false; "isSignal": true; }; "tag": { "alias": "tag"; "required": false; "isSignal": true; }; "framedPortal": { "alias": "framedPortal"; "required": false; "isSignal": true; }; }, {}, never, ["[illustration]", "[info]", "*"], true, never>;
}

declare class SwitchInputComponent {
    formField: FormFieldComponent;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    intl: CheckboxInputTranslations;
    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: {}; }]>;
}

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

declare class TextareaInputComponent implements OnInit {
    #private;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    readonly parent: _angular_core.Signal<ElementRef<HTMLElement>>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly rows: _angular_core.InputSignal<number>;
    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly autoResizeScrollIntoView: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly disableSpellcheck: _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; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "autoResizeScrollIntoView": { "alias": "autoResizeScrollIntoView"; "required": false; "isSignal": true; }; "disableSpellcheck": { "alias": "disableSpellcheck"; "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 const LU_TEXTFIELD_TRANSLATIONS: InjectionToken<LuTranslation<LuTextfieldLabel>>;
interface LuTextfieldLabel {
    clear: string;
    togglePasswordVisibility: string;
}
declare const luTextfieldTranslations: LuTranslation<LuTextfieldLabel>;

declare class FieldsetComponent {
    readonly heading: _angular_core.InputSignal<PortalContent>;
    readonly helper: _angular_core.InputSignal<PortalContent>;
    readonly action: _angular_core.InputSignal<PortalContent>;
    readonly size: _angular_core.InputSignal<"S">;
    readonly horizontal: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly 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; }; "action": { "alias": "action"; "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>;
}

interface ColorOption {
    index: number;
    name: string;
    background: string;
    borderColor?: string;
}

interface LuColorLabel {
    color: string;
}

declare class ColorInputComponent {
    intl: _angular_core.InputSignalWithTransform<LuColorLabel, Partial<LuColorLabel>>;
    mouseHighlighted: _angular_core.WritableSignal<string>;
    keyboardHighlighted: _angular_core.WritableSignal<string>;
    highlighted: Signal<string>;
    clue: _angular_core.WritableSignal<string>;
    colors: _angular_core.InputSignal<ColorOption[]>;
    clearable: _angular_core.InputSignalWithTransform<boolean, unknown>;
    compact: _angular_core.InputSignalWithTransform<boolean, unknown>;
    ngControl: _angular_forms.NgModel | _angular_forms.FormControlDirective | _angular_forms.FormControlName;
    currentColorPresentation: Signal<ColorOption | null>;
    constructor();
    filteredColors: Signal<ColorOption[]>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorInputComponent, "lu-color-input", never, { "intl": { "alias": "intl"; "required": false; "isSignal": true; }; "colors": { "alias": "colors"; "required": true; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof NoopValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

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