import * as i0 from '@angular/core';
import { ElementRef, AfterViewInit, OnChanges, Renderer2, SimpleChanges, OnInit, EventEmitter, OnDestroy, ChangeDetectorRef, AfterContentChecked, AfterContentInit, QueryList } from '@angular/core';
import { PlatformService } from '@kirbydesign/designsystem/helpers';
import { TranslationService, ResizeObserverService } from '@kirbydesign/designsystem/shared';
import { FormFieldControl, WindowRef } from '@kirbydesign/designsystem/types';
import { DropdownComponent } from '@kirbydesign/designsystem/dropdown';
import { ControlValueAccessor } from '@angular/forms';
import * as i1 from '@angular/common';
import * as i3 from '@kirbydesign/designsystem/icon';

declare class AffixDirective {
    el: ElementRef;
    type: 'prefix' | 'suffix';
    constructor(el: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<AffixDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AffixDirective, "[kirby-affix]", never, { "type": { "alias": "kirby-affix"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DateInputDirective implements AfterViewInit, OnChanges {
    private elementRef;
    private renderer;
    private locale;
    onInput(): void;
    prefillYear: boolean;
    useNativeDatePicker: boolean;
    dateValue: string;
    private maskingElement;
    private inputmask;
    /**
     * `isDateInput` is used to avoid removing the type attribute on the input element and calling updateMask()
     * when the directive is not used on a date input.
     * This is needed for the standalone component 'InputComponent', which includes the directive
     * using the `hostDirectives` component decorator prop. Angular ignores the selector of directives
     * applied in the `hostDirectives` property which effectively applies the directive to all kirby-inputs, not only date inputs.
     * This check prevents the directive from executing it's masking on non-date inputs.
     * See: https://angular.io/guide/directive-composition-api
     */
    private isDateInput;
    /**
     * Inputmask should be enabled exclusively when _not_ using the platform
     * native date picker.
     *
     * `enableInputMask` should be ignored if the type attribute of the `<input>`
     * element is different from 'date' and/or the platform native date picker is
     * explicitly enabled.
     *
     * @private
     * @memberof DateInputDirective
     */
    private enableInputMask;
    constructor(elementRef: ElementRef, renderer: Renderer2, locale: string, valueAccessors: ControlValueAccessor[]);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    private initMask;
    private getInputFormat;
    private getPlaceholder;
    private appendMaskingElement;
    private wrapElement;
    private updateMask;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateInputDirective, [null, null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DateInputDirective, never, never, { "prefillYear": { "alias": "prefillYear"; "required": false; }; "useNativeDatePicker": { "alias": "useNativeDatePicker"; "required": false; }; "dateValue": { "alias": "dateValue"; "required": false; }; }, {}, never, never, true, never>;
}

declare enum InputSize {
    medium = "md",
    large = "lg"
}
declare class InputComponent implements OnChanges, OnInit, FormFieldControl {
    private elementRef;
    kirbyChange: EventEmitter<string>;
    private _hasError;
    set type(value: string);
    size: InputSize | `${InputSize}`;
    /**
     * Removes padding, width, rounded borders and drop-shadow when set to `true`.
     */
    borderless: boolean;
    get hasError(): boolean;
    set hasError(value: boolean);
    autocomplete: 'on' | 'off';
    autocorrect: 'on' | 'off';
    value: string;
    maxlength: number;
    inputmode: string;
    get nativeValue(): string;
    hasErrorChange: EventEmitter<boolean>;
    constructor(elementRef: ElementRef<HTMLInputElement>, builtInValueAccessors: ControlValueAccessor[]);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    private static typeToInputmodeMap;
    _onKeyUp(value: string): void;
    _onCutPaste(target: HTMLInputElement): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "input[kirby-input]", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autocorrect": { "alias": "autocorrect"; "required": false; }; "value": { "alias": "value"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; "inputmode": { "alias": "inputmode"; "required": false; }; }, { "hasErrorChange": "hasErrorChange"; }, never, never, true, [{ directive: typeof DateInputDirective; inputs: { "prefillYear": "prefillYear"; "useNativeDatePicker": "useNativeDatePicker"; "dateValue": "value"; }; outputs: {}; }]>;
}

declare class TextareaComponent implements OnChanges, FormFieldControl, OnInit {
    private elementRef;
    kirbyChange: EventEmitter<string>;
    private _hasError;
    value: string;
    /**
     * Removes padding, width, rounded borders and drop-shadow when set to `true`.
     */
    borderless: boolean;
    get hasError(): boolean;
    set hasError(value: boolean);
    autocomplete: 'on' | 'off';
    autocorrect: 'on' | 'off';
    maxlength: number;
    get nativeValue(): string;
    hasErrorChange: EventEmitter<boolean>;
    constructor(elementRef: ElementRef<HTMLTextAreaElement>, builtInValueAccessors: ControlValueAccessor[]);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    _onKeyUp(value: string): void;
    _onCutPaste(target: HTMLInputElement): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TextareaComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TextareaComponent, "textarea[kirby-textarea]", never, { "value": { "alias": "value"; "required": false; }; "borderless": { "alias": "borderless"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "autocorrect": { "alias": "autocorrect"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; }, { "hasErrorChange": "hasErrorChange"; }, never, ["*"], true, never>;
}

declare class InputCounterComponent implements AfterViewInit, OnDestroy {
    private translations;
    private cdr;
    listenTo: InputComponent | TextareaComponent;
    length: number;
    maxlength: number | undefined;
    private _inputChangeSubscription;
    textToAnnounce: string;
    lastAnnouncedLength: number;
    skipNextAnnouncement: boolean;
    get text(): string;
    constructor(translations: TranslationService, cdr: ChangeDetectorRef);
    ngAfterViewInit(): void;
    private skipAnnouncement;
    ngOnDestroy(): void;
    announceText(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputCounterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputCounterComponent, "kirby-input-counter", never, { "listenTo": { "alias": "listenTo"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormFieldComponent implements AfterContentChecked, AfterContentInit, OnInit, OnDestroy {
    private platform;
    private renderer;
    private windowRef;
    private resizeObserverService;
    private cdr;
    private isRegistered;
    private element;
    private isTouch;
    private nestedInteractiveElement;
    private nestedInteractiveErrorSubscription;
    private _message;
    private _label;
    showDefaultCalendarIcon: boolean;
    _nestedInteractiveHasError: boolean;
    _labelId: string;
    _errorMessageId: string;
    _messageId: string;
    get label(): string | undefined;
    set label(value: string | undefined);
    get message(): string | null | undefined;
    set message(value: string | null | undefined);
    affixElements: QueryList<AffixDirective>;
    counter: InputCounterComponent;
    private radioGroupComponent;
    inputComponent: InputComponent;
    dropdownComponent: DropdownComponent;
    textareaComponent: TextareaComponent;
    private radioGroupElement;
    input: ElementRef<HTMLInputElement>;
    dropdown: ElementRef<HTMLElement>;
    textarea: ElementRef<HTMLTextAreaElement>;
    dateInput: DateInputDirective;
    constructor(elementRef: ElementRef<HTMLElement>, platform: PlatformService, renderer: Renderer2, windowRef: WindowRef, resizeObserverService: ResizeObserverService, cdr: ChangeDetectorRef);
    get _wrapContentInLabel(): boolean;
    private dispatchLoadEvent;
    _onRegisterFormField(): void;
    onLabelClick(): void;
    focus(): void;
    ngOnInit(): void;
    ngAfterContentInit(): void;
    ngAfterContentChecked(): void;
    ngOnDestroy(): void;
    private registerNestedInteractive;
    private getNestedInteractiveElement;
    private setNestedInteractiveMessageAttributes;
    private setNestedInteractiveLabelAttributes;
    private subscribeToNestedInteractiveError;
    private shouldShowDefaultCalendarIcon;
    private handleAffixOffset;
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldComponent, "kirby-form-field", never, { "label": { "alias": "label"; "required": false; }; "message": { "alias": "message"; "required": false; }; }, {}, ["counter", "radioGroupComponent", "inputComponent", "dropdownComponent", "textareaComponent", "radioGroupElement", "input", "dropdown", "textarea", "dateInput", "affixElements"], ["kirby-input-counter", "[kirby-affix='prefix']", "input[kirby-input]", "textarea[kirby-textarea]", "kirby-radio-group", "kirby-dropdown", "[kirby-affix='suffix']"], true, never>;
}

declare class FormFieldMessageComponent {
    text: string;
    position: 'left' | 'right';
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldMessageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FormFieldMessageComponent, "kirby-form-field-message", never, { "text": { "alias": "text"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface InputMask {
    unmaskedvalue: () => string;
    setValue: (val: string) => void;
}
declare class DecimalMaskDirective implements OnInit {
    private elementRef;
    private locale;
    private valueAccessors;
    min: number;
    max: number;
    precision: number;
    setMaxOnOverflow: boolean;
    alignment: 'left' | 'right';
    padPrecisionDigits: boolean;
    set allowMinus(allowMinus: boolean);
    set disableGroupSeperator(disabled: string);
    set maxlength(maxlength: number);
    groupSeparator: string;
    radixPoint: string;
    inputmask: InputMask;
    _allowMinus: boolean;
    _maxlength: number;
    _groupSeperatorDisabled: boolean;
    constructor(elementRef: ElementRef, locale: string, valueAccessors: ControlValueAccessor[]);
    ngOnInit(): void;
    private initMask;
    private getMax;
    private getMin;
    private extendBuiltinValueAccessor;
    static ɵfac: i0.ɵɵFactoryDeclaration<DecimalMaskDirective, [null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DecimalMaskDirective, "[kirby-decimal-mask]", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "precision": { "alias": "precision"; "required": false; }; "setMaxOnOverflow": { "alias": "setMaxOnOverflow"; "required": false; }; "alignment": { "alias": "alignment"; "required": false; }; "padPrecisionDigits": { "alias": "padPrecisionDigits"; "required": false; }; "allowMinus": { "alias": "allowMinus"; "required": false; }; "disableGroupSeperator": { "alias": "disableGroupSeperator"; "required": false; }; "maxlength": { "alias": "maxlength"; "required": false; }; }, {}, never, never, true, never>;
}

declare class FormFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FormFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FormFieldModule, never, [typeof i1.CommonModule, typeof DecimalMaskDirective, typeof i3.IconModule, typeof AffixDirective, typeof FormFieldComponent, typeof FormFieldMessageComponent, typeof InputCounterComponent], [typeof FormFieldComponent, typeof FormFieldMessageComponent, typeof InputCounterComponent, typeof DecimalMaskDirective, typeof AffixDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FormFieldModule>;
}

export { AffixDirective, DateInputDirective, DecimalMaskDirective, FormFieldComponent, FormFieldMessageComponent, FormFieldModule, InputComponent, InputCounterComponent, InputSize, TextareaComponent };
//# sourceMappingURL=kirbydesign-designsystem-form-field.d.ts.map