import { type ElementPart, type PropertyPart } from 'lit';
import { type PartInfo } from 'lit/directive.js';
import { type AbstractModel } from './Models.js';
export interface FieldBase<T> {
    required: boolean;
    invalid: boolean;
    errorMessage: string;
    value: T | undefined;
}
export type FieldConstraintValidation = Readonly<{
    validity: ValidityState;
    checkValidity(): boolean;
}>;
export type FieldElement<T = unknown> = FieldBase<T> & HTMLElement & Partial<FieldConstraintValidation>;
export declare function isFieldElement<T>(element: HTMLElement): element is FieldElement<T>;
interface FieldElementHolder<T> {
    get element(): FieldElement<T>;
    set element(element: FieldElement<T>);
}
interface Field<T> extends FieldBase<T> {
    readonly model?: AbstractModel<T>;
}
interface FieldState<T> extends Field<T>, FieldElementHolder<T> {
    name: string;
    validity: ValidityState;
    strategy: FieldStrategy<T>;
}
type EventHandler = (event: Event) => void;
export type FieldStrategy<T = any> = Field<T> & FieldConstraintValidation & {
    onChange?: EventHandler;
    onInput?: EventHandler;
    removeEventListeners(): void;
};
export declare abstract class AbstractFieldStrategy<T = any, E extends FieldElement<T> = FieldElement<T>> implements FieldStrategy<T> {
    #private;
    abstract required: boolean;
    abstract invalid: boolean;
    readonly model?: AbstractModel<T>;
    constructor(element: E, model?: AbstractModel<T>);
    get element(): E;
    set element(element: E);
    get value(): T | undefined;
    set value(value: T | undefined);
    set errorMessage(_: string);
    get validity(): ValidityState;
    get onChange(): EventHandler | undefined;
    set onChange(onChange: EventHandler | undefined);
    get onInput(): EventHandler | undefined;
    set onInput(onInput: EventHandler | undefined);
    checkValidity(): boolean;
    setAttribute(key: string, val: any): void;
    removeEventListeners(): void;
}
export declare class VaadinFieldStrategy<T = any, E extends FieldElement<T> = FieldElement<T>> extends AbstractFieldStrategy<T, E> {
    #private;
    constructor(element: E, model?: AbstractModel<T>);
    set required(value: boolean);
    set invalid(value: boolean);
    set errorMessage(value: string);
    removeEventListeners(): void;
    checkValidity(): boolean;
}
export declare class GenericFieldStrategy<T = any, E extends FieldElement<T> = FieldElement<T>> extends AbstractFieldStrategy<T, E> {
    set required(value: boolean);
    set invalid(value: boolean);
}
type CheckedFieldElement<T> = FieldElement<T> & {
    checked: boolean;
};
export declare class CheckedFieldStrategy<T = any, E extends CheckedFieldElement<T> = CheckedFieldElement<T>> extends GenericFieldStrategy<T, E> {
    get value(): T | undefined;
    set value(val: T | undefined);
}
export declare class CheckedGroupFieldStrategy<T = any, E extends FieldElement<T> = FieldElement<T>> extends GenericFieldStrategy<T, E> {
    get value(): T | undefined;
    set value(val: T | undefined);
}
type ComboBoxFieldElement<T> = FieldElement<T> & {
    value: string;
    selectedItem: T | null;
};
export declare class ComboBoxFieldStrategy<T, E extends ComboBoxFieldElement<T> = ComboBoxFieldElement<T>> extends VaadinFieldStrategy<T, E> {
    get value(): T | undefined;
    set value(val: T | undefined);
}
export declare class VaadinStringFieldStrategy extends VaadinFieldStrategy<string> {
    get value(): string | undefined;
    set value(val: string | undefined);
}
export declare class VaadinDateTimeFieldStrategy<T = string, E extends FieldElement<T> = FieldElement<T>> extends VaadinFieldStrategy<T, E> {
    get value(): T | undefined;
    set value(val: T | undefined);
}
type MultiSelectComboBoxFieldElement<T> = FieldElement<T> & {
    value: never;
    selectedItems: T;
};
export declare class MultiSelectComboBoxFieldStrategy<T, E extends MultiSelectComboBoxFieldElement<T> = MultiSelectComboBoxFieldElement<T>> extends VaadinFieldStrategy<T, E> {
    get value(): T;
    set value(val: any);
}
type SelectedFieldElement<T> = FieldElement<T> & {
    value: never;
    selected: T;
};
export declare class SelectedFieldStrategy<T, E extends SelectedFieldElement<T> = SelectedFieldElement<T>> extends GenericFieldStrategy<T, E> {
    get value(): T;
    set value(val: T);
}
export declare function getDefaultFieldStrategy<T>(elm: FieldElement<T>, model?: AbstractModel<T>): AbstractFieldStrategy<T>;
export declare const field: (_model: AbstractModel<any>, _effect?: ((element: Element) => void) | undefined) => import("lit-html/directive.js").DirectiveResult<{
    new (partInfo: PartInfo): {
        fieldState?: FieldState<any>;
        render(_model: AbstractModel<any>, _effect?: (element: Element) => void): symbol;
        update(part: ElementPart | PropertyPart, [model, effect]: [_model: AbstractModel<any>, _effect?: ((element: Element) => void) | undefined]): symbol;
        readonly _$isConnected: boolean;
    };
}>;
export {};