import * as i0 from '@angular/core';
import { OnInit, OnDestroy, Type, PipeTransform, ViewContainerRef, Provider, StaticProvider, Signal, OnChanges, EventEmitter, ChangeDetectorRef, SimpleChanges, ComponentRef, Injector, ApplicationRef, AfterViewInit, InjectionToken } from '@angular/core';
import * as _angular_forms from '@angular/forms';
import { UntypedFormGroup, ValidatorFn, AsyncValidatorFn, UntypedFormBuilder, FormGroup, ControlValueAccessor, AbstractControl, FormArray, UntypedFormArray, FormControl, UntypedFormControl, FormGroupDirective, NgForm } from '@angular/forms';
import { Subject, Observable } from 'rxjs';
import * as i30 from '@angular/material/core';
import { ThemePalette, DateAdapter, MatDateFormats, ErrorStateMatcher } from '@angular/material/core';
import * as i10 from '@angular/material/form-field';
import { SubscriptSizing } from '@angular/material/form-field';
import * as i3 from '@angular/material/button';
import { MatButtonAppearance } from '@angular/material/button';
import * as _3kles_kles_material_color_picker from '@3kles/kles-material-color-picker';
import { ColorPickerPosition, ColorOutputFormat, ColorCommitMode } from '@3kles/kles-material-color-picker';
import * as _3kles_kles_material_dynamicforms from '@3kles/kles-material-dynamicforms';
import * as i1 from '@angular/common';
import * as i2 from '@angular/material/slider';
import * as i4 from '@angular/material/toolbar';
import * as i5 from '@angular/material/icon';
import * as i6 from '@angular/material/sidenav';
import * as i7 from '@angular/material/badge';
import * as i8 from '@angular/material/list';
import { MatSelectionListChange } from '@angular/material/list';
import * as i9 from '@angular/material/grid-list';
import * as i11 from '@angular/material/input';
import * as i12 from '@angular/material/select';
import * as i13 from '@angular/material/radio';
import * as i14 from '@angular/material/datepicker';
import * as i15 from '@angular/material/chips';
import { MatChipInputEvent, MatChipInput } from '@angular/material/chips';
import * as i16 from '@angular/material/tooltip';
import * as i17 from '@angular/material/table';
import * as i18 from '@angular/material/paginator';
import * as i19 from '@angular/material/card';
import * as i20 from '@angular/material/menu';
import * as i21 from '@angular/material/tabs';
import * as i22 from '@angular/cdk/table';
import * as i23 from '@angular/material/progress-spinner';
import * as i24 from '@angular/material/checkbox';
import { MatCheckboxChange } from '@angular/material/checkbox';
import * as i25 from '@angular/material/dialog';
import * as i26 from '@angular/material/autocomplete';
import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
import * as i27 from '@angular/material/progress-bar';
import * as i28 from '@angular/material/sort';
import * as i29 from '@angular/material/expansion';
import * as i31 from '@angular/material/snack-bar';
import * as i32 from '@angular/material/tree';
import * as i33 from '@angular/material/slide-toggle';
import * as i34 from '@angular/material/button-toggle';
import * as i35 from '@angular/cdk/portal';
import * as i36 from '@angular/cdk/scrolling';

type Exclusive<T, U> = (T & {
    [K in keyof U]?: never;
}) | (U & {
    [K in keyof T]?: never;
});
type KlesValidationKey = {
    name: string;
    message?: string;
    messageKey?: string;
};
type KlesValidatorMultiple = {
    keys: KlesValidationKey[];
};
type IKlesValidator<T> = {
    validator: T;
} & Exclusive<KlesValidationKey, KlesValidatorMultiple>;

declare enum EnumType {
    input = "input",
    select = "select",
    text = "text",
    file = "file",
    imageUpload = "imageUpload",
    button = "button",
    checkbox = "checkbox",
    number = "number",
    time = "time",
    date = "date",
    color = "color",
    list = "list",
    multi = "multi",
    array = "array",
    group = "group",
    lineBreak = "lineBreak",
    badge = "badge",
    range = "range",
    currency = "currency",
    status = "status"
}

interface IKlesField {
    field: IKlesFieldConfig;
    group: UntypedFormGroup;
    siblingFields: IKlesFieldConfig[];
}

interface IKlesDirective extends OnInit, OnDestroy {
}

/** Contract implemented by components used to render an option or a select trigger. */
interface IKlesComponent<TValue = unknown> {
    value: TValue;
}
/** Angular component type compatible with the dynamic option renderer. */
type KlesComponentType<TValue = unknown> = Type<IKlesComponent<TValue>>;

interface IKlesElementLayoutBreakpoint {
    colSpan?: number;
    rowSpan?: number;
    colStart?: number;
    rowStart?: number;
}
interface IKlesElementLayout extends IKlesElementLayoutBreakpoint {
    class?: string | string[];
    responsive?: {
        xs?: IKlesElementLayoutBreakpoint;
        sm?: IKlesElementLayoutBreakpoint;
        md?: IKlesElementLayoutBreakpoint;
        lg?: IKlesElementLayoutBreakpoint;
        xl?: IKlesElementLayoutBreakpoint;
    };
}
interface IKlesLayoutConfig {
    /** Number of columns in the grid. Defaults to 12. */
    columns?: number;
    /** CSS gap between grid cells. Defaults to 0. */
    gap?: string;
}
interface IKlesStructuralElement {
    layout?: IKlesElementLayout;
}
interface IKlesFormSection extends IKlesStructuralElement {
    type: 'section';
    title: string;
    description?: string;
    /** Material icon displayed before the section title. */
    icon?: string;
    /** Registered Material SVG icon displayed before the section title. */
    iconSvg?: string;
    fields: KlesFormElement[];
    layoutConfig?: IKlesLayoutConfig;
}
/** A visual layout group. Unlike an EnumType.group field, it creates no FormGroup. */
interface IKlesFormLayoutGroup extends IKlesStructuralElement {
    type: 'layoutGroup';
    fields: KlesFormElement[];
    layoutConfig?: IKlesLayoutConfig;
}
interface IKlesFormDivider extends IKlesStructuralElement {
    type: 'divider';
}
interface IKlesFormSpacer extends IKlesStructuralElement {
    type: 'spacer';
    size?: string | number;
}
type KlesFormStructuralElement = IKlesFormSection | IKlesFormLayoutGroup | IKlesFormDivider | IKlesFormSpacer;
type KlesFormElement = IKlesFieldConfig | KlesFormStructuralElement;
declare function isKlesStructuralElement(element: KlesFormElement): element is KlesFormStructuralElement;
declare function flattenKlesFields(elements: readonly KlesFormElement[]): IKlesFieldConfig[];

interface IKlesFieldActionEvent<TContext = unknown, TValue = unknown> {
    actionId: string;
    value?: TValue;
    context: TContext | null;
    field: IKlesFieldConfig;
    group: UntypedFormGroup;
    originalEvent: Event;
}
interface IKlesCurrencyOptions {
    /**
     * Code ISO 4217 : EUR, USD, GBP...
     * DEFAULT_CURRENCY_CODE sera utilisé par défaut.
     */
    code?: string;
    /**
     * Locale Intl : fr-FR, en-US...
     * LOCALE_ID sera utilisé par défaut.
     */
    locale?: string;
    display?: 'symbol' | 'narrowSymbol' | 'code' | 'name';
    minimumFractionDigits?: number;
    maximumFractionDigits?: number;
    useGrouping?: boolean;
    allowNegative?: boolean;
}
interface IKlesImageUploadOptions {
    /** Taille maximale autorisée, en octets. 2 Mio par défaut. */
    maxFileSize?: number;
    changeLabel?: string;
    deleteLabel?: string;
    emptyIcon?: string;
    uploadIcon?: string;
    invalidTypeMessage?: string;
    maxFileSizeMessage?: string;
}
type KlesStatusTone = 'neutral' | 'info' | 'success' | 'warning' | 'error';
type KlesStatusAppearance = 'chip' | 'badge' | 'text';
interface IKlesStatusDefinition {
    label: string;
    tone?: KlesStatusTone;
    icon?: string;
    iconSvg?: string;
    tooltip?: string;
    ariaLabel?: string;
    ngClass?: any;
}
interface IKlesStatusOptions {
    values?: Record<string, IKlesStatusDefinition>;
    appearance?: KlesStatusAppearance;
    /**
     * Affiche un point coloré lorsque le statut
     * ne possède pas d'icône.
     */
    showDot?: boolean;
    fallback?: IKlesStatusDefinition;
    /**
     * Permet de gérer des valeurs plus complexes,
     * notamment des objets.
     */
    resolve?: (value: any, context: unknown | null, field: IKlesFieldConfig, group: UntypedFormGroup) => IKlesStatusDefinition | null;
}
interface IKlesFieldUiResolveEvent<TContext = unknown> {
    context: TContext | null;
    field: IKlesFieldConfig;
    group: UntypedFormGroup;
    siblingFields: IKlesFieldConfig[];
}
type IKlesFieldUiResolver<TContext = unknown> = (event: IKlesFieldUiResolveEvent<TContext>) => Partial<Omit<IKlesFieldUi, 'resolveUi'>>;
interface IKlesFieldUi {
    inputType?: 'text' | 'button' | 'checkbox' | 'color' | 'date' | 'datetime-local' | 'email' | 'file' | 'hidden' | 'image' | 'month' | 'number' | 'password' | 'radio' | 'range' | 'reset' | 'search' | 'submit' | 'tel' | 'time' | 'url' | 'week';
    min?: number | Date;
    max?: number | Date;
    maxLength?: number;
    step?: number;
    hostClass?: string | string[] | Set<string> | {
        [klass: string]: any;
    };
    ngClass?: any;
    ngStyle?: any;
    indeterminate?: boolean;
    color?: ThemePalette;
    icon?: string;
    iconSvg?: string;
    appearance?: 'fill' | 'outline';
    buttonAppearance?: MatButtonAppearance;
    visible?: boolean;
    colorOption?: {
        disable?: boolean;
        position?: ColorPickerPosition;
        positionOffset?: number;
        format?: ColorOutputFormat;
        commitMode?: ColorCommitMode;
        alpha?: boolean;
        eyeDropper?: boolean;
        saveOnOutside?: boolean;
        fallbackColor?: string;
        presets?: readonly string[];
    };
    direction?: 'column' | 'row' | 'grid' | 'inline-grid';
    wrap?: boolean;
    textareaAutoSize?: {
        minRows?: number;
        maxRows?: number;
    };
    virtualScroll?: boolean;
    itemSize?: number;
    hint?: string;
    label?: string;
    placeholder?: any;
    tooltip?: string;
    imageUrl?: string;
    imageAlt?: string;
    currencyOptions?: IKlesCurrencyOptions;
    resolveUi?: IKlesFieldUiResolver;
}
interface IKlesSelectSearchOptions {
    mode?: 'local' | 'remote';
    keys?: string[];
    debounceTime?: number;
    minLength?: number;
    clearOnClose?: boolean;
    placeholder?: string;
    ariaLabel?: string;
}
interface IKlesFormField {
    type?: EnumType;
    name: string;
    component?: Type<any>;
    id?: string;
    options?: any[] | Subject<any[]> | Observable<any[]> | ((value?: string, group?: {
        [key: string]: any;
    }) => Observable<any[]>);
    search?: boolean | IKlesSelectSearchOptions;
    property?: string;
    collections?: IKlesFieldConfig[];
    value?: any;
    asyncValue?: Observable<any>;
    multiple?: boolean;
    disabled?: boolean;
    autocomplete?: boolean;
    autocompleteComponent?: KlesComponentType<any>;
    displayWith?: ((value: any) => string) | null;
    panelWidth?: string | number;
    pending?: boolean;
    validations?: IKlesValidator<ValidatorFn>[];
    asyncValidations?: IKlesValidator<AsyncValidatorFn>[];
    pipeTransform?: {
        pipe: PipeTransform;
        options?: any[];
    }[];
    valueChanges?: (field: IKlesFieldConfig, group: UntypedFormGroup, siblingField?: IKlesFieldConfig[], valueChanged?: any) => void;
    triggerComponent?: KlesComponentType<any>;
    searchKeys?: string[];
    updateOn?: 'change' | 'blur' | 'submit';
    debounceTime?: number;
    directive?: new (ref: ViewContainerRef, field: IKlesField) => IKlesDirective;
    lazy?: boolean;
    buttonType?: 'submit' | 'button' | 'reset';
    accept?: string;
    imageUploadOptions?: IKlesImageUploadOptions;
    dateOptions?: {
        adapter?: {
            class: Type<DateAdapter<any>>;
            deps?: any[];
        };
        language: string;
        dateFormat: MatDateFormats;
    };
    clearable?: boolean;
    clearableComponent?: Type<any>;
    subComponents?: Type<any>[];
    autofocus?: boolean;
    subscriptSizing?: SubscriptSizing;
    nonNullable?: boolean;
    onFocus?: (field: IKlesFieldConfig, group: UntypedFormGroup) => void;
    onBlur?: (field: IKlesFieldConfig, group: UntypedFormGroup) => void;
    providers?: Array<Provider | StaticProvider>;
    onAction?: (event: IKlesFieldActionEvent<any, any>) => void;
    statusOptions?: IKlesStatusOptions;
    /** Position of this field in an advanced CSS Grid container. */
    layout?: IKlesElementLayout;
}
type IKlesFieldConfig = IKlesFormField & IKlesFieldUi;

/** Selects the untyped result when T is `any`, otherwise the typed result. */
type KlesTypedOrUntyped<T, TTyped, TUntyped> = 0 extends 1 & T ? TUntyped : TTyped;
type KlesPathSegment = string | number;
type KlesTokenize<TPath extends string> = TPath extends `${infer THead}.${infer TTail}` ? [THead, ...KlesTokenize<TTail>] : [TPath];
type KlesCoercePathSegment<TSegment> = TSegment extends `${infer TIndex extends number}` ? TIndex : TSegment;
type KlesProperty<TValue, TKey> = TValue extends unknown ? KlesCoercePathSegment<TKey> extends keyof TValue ? TValue[KlesCoercePathSegment<TKey>] : never : never;
type KlesNavigate<TValue, TPath extends readonly KlesPathSegment[]> = number extends TPath['length'] ? any : TPath extends readonly [infer THead extends KlesPathSegment, ...infer TTail extends KlesPathSegment[]] ? KlesNavigate<KlesProperty<TValue, THead>, TTail> : TValue;
/** Resolves the value located at a dot-separated path or an array of path segments. */
type KlesGetProperty<TValue, TPath> = KlesTypedOrUntyped<TValue, TPath extends string ? string extends TPath ? any : KlesNavigate<TValue, KlesTokenize<TPath>> : TPath extends readonly KlesPathSegment[] ? KlesNavigate<TValue, TPath> : never, any>;

declare abstract class AbstractUiState<TValue = any, TRawValue extends TValue = TValue> {
    protected _value: i0.WritableSignal<TValue | undefined>;
    private _parent;
    private _parentKey;
    get<P extends string | readonly (string | number)[]>(path: P): AbstractUiState<KlesGetProperty<TRawValue, P>> | null;
    get<P extends string | Array<string | number>>(path: P): AbstractUiState<KlesGetProperty<TRawValue, P>> | null;
    _find(name: string | number): AbstractUiState | null;
    abstract setValue(value: TRawValue): void;
    abstract patchValue(value: Partial<TValue>): void;
    get value(): Signal<TValue | undefined>;
    setParent(parent: AbstractUiState<any>, key: string | number): void;
    protected notifyParent(): void;
    childValueChanged(key: string | number, value: any): void;
}

declare class GroupUiState<TUiState extends {
    [K in keyof TUiState]: AbstractUiState<any>;
} = any> extends AbstractUiState<any, any> {
    states: KlesTypedOrUntyped<TUiState, TUiState, {
        [key: string]: AbstractUiState<any>;
    }>;
    constructor(states?: TUiState);
    setValue(value: any): void;
    patchValue(value: any): void;
    childValueChanged(key: string | number, value: any): void;
    _find(name: string | number): AbstractUiState | null;
    addUiState(name: string, uiState: AbstractUiState<any>): void;
    private buildInitialValue;
}

declare class KlesDynamicFormComponent implements OnInit, OnChanges {
    private fb;
    private ref;
    context: Signal<unknown | null> | null;
    fields: KlesFormElement[];
    validators: IKlesValidator<ValidatorFn>[];
    asyncValidators: IKlesValidator<AsyncValidatorFn>[];
    submit: EventEmitter<any>;
    _onLoaded: EventEmitter<any>;
    direction: 'column' | 'row' | 'grid' | 'inline-grid';
    wrap: boolean;
    /** Configuration of the advanced grid container. */
    layout: IKlesLayoutConfig;
    formClass: string | string[] | Set<string> | {
        [klass: string]: any;
    };
    form: UntypedFormGroup;
    ui: GroupUiState;
    private flattenedSource;
    private flattenedFields;
    private readonly layoutWarnings;
    get orientationClass(): 'dynamic-form-column' | 'dynamic-form-row' | 'dynamic-form-grid' | 'dynamic-form-inline-grid';
    get value(): any;
    get legacyFields(): IKlesFieldConfig[];
    get usesAdvancedLayout(): boolean;
    get gridStyles(): Record<string, string | number> | null;
    private get hasRootElementLayout();
    constructor(fb: UntypedFormBuilder, ref: ChangeDetectorRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onSubmit(event: Event): void;
    private updateForm;
    private updateControl;
    private createControl;
    private createUiState;
    private createForm;
    private validateAllFormFields;
    private createUi;
    private normalizeColumns;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesDynamicFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesDynamicFormComponent, "app-kles-dynamic-form", ["klesDynamicForm"], { "context": { "alias": "context"; "required": false; }; "fields": { "alias": "fields"; "required": false; }; "validators": { "alias": "validators"; "required": false; }; "asyncValidators": { "alias": "asyncValidators"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "wrap": { "alias": "wrap"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "formClass": { "alias": "formClass"; "required": false; }; }, { "submit": "submit"; "_onLoaded": "_onLoaded"; }, never, never, true, never>;
}

declare class KlesComponentDirective<TValue = unknown> implements OnInit, OnChanges, OnDestroy {
    private container;
    component: KlesComponentType<TValue>;
    value: TValue;
    field: IKlesFieldConfig;
    componentRef?: ComponentRef<IKlesComponent<TValue>>;
    constructor(container: ViewContainerRef);
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private buildComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesComponentDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KlesComponentDirective<any>, "[klesComponent]", never, { "component": { "alias": "component"; "required": true; }; "value": { "alias": "value"; "required": true; }; "field": { "alias": "field"; "required": true; }; }, {}, never, never, true, never>;
}

declare class KlesDynamicFieldDirective<T extends IKlesFieldConfig = IKlesFieldConfig> implements OnInit, OnChanges, OnDestroy {
    protected container: ViewContainerRef;
    protected injector: Injector;
    private applicationRef;
    field: T;
    group: UntypedFormGroup;
    ui: GroupUiState;
    siblingFields: T[];
    context: Signal<unknown | null> | null;
    componentRef: ComponentRef<any> | undefined;
    subComponents: ComponentRef<any>[];
    private subComponentViews;
    constructor(container: ViewContainerRef, injector: Injector, applicationRef: ApplicationRef);
    ngOnDestroy(): void;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    buildComponent(): void;
    protected createComponentRef(injector: Injector): ComponentRef<any> | undefined;
    protected findComponent(): Type<any> | undefined;
    private createSubComponent;
    private destroyComponents;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesDynamicFieldDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KlesDynamicFieldDirective<any>, "[klesDynamicField]", never, { "field": { "alias": "field"; "required": false; }; "group": { "alias": "group"; "required": false; }; "ui": { "alias": "ui"; "required": false; }; "siblingFields": { "alias": "siblingFields"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
}

declare class KlesFocusTargetDirective {
    private readonly element;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFocusTargetDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KlesFocusTargetDirective, "[klesFocusTarget]", never, {}, {}, never, never, true, never>;
}

declare abstract class KlesFieldAbstract<TContext = unknown> implements IKlesField, OnInit, AfterViewInit, OnDestroy {
    readonly field: IKlesFieldConfig;
    readonly group: FormGroup<any>;
    readonly siblingFields: IKlesFieldConfig[];
    readonly ui: GroupUiState<any> | null;
    readonly context: Signal<TContext | null> | null;
    protected readonly fieldUi: Signal<any>;
    protected readonly resolvedFieldUi: Signal<IKlesFieldUi>;
    readonly appearance: Signal<"fill" | "outline">;
    readonly inputType: Signal<"number" | "text" | "image" | "url" | "search" | "date" | "email" | "submit" | "reset" | "file" | "button" | "checkbox" | "time" | "color" | "range" | "datetime-local" | "hidden" | "month" | "password" | "radio" | "tel" | "week">;
    readonly min: Signal<number | Date | undefined>;
    readonly max: Signal<number | Date | undefined>;
    readonly maxLength: Signal<number>;
    readonly step: Signal<number | undefined>;
    readonly ngClass: Signal<any>;
    readonly ngStyle: Signal<any>;
    readonly indeterminate: Signal<boolean>;
    readonly color: Signal<"primary" | "accent" | "warn">;
    readonly icon: Signal<string>;
    readonly iconSvg: Signal<string>;
    readonly buttonAppearance: Signal<i3.MatButtonAppearance>;
    readonly label: Signal<string>;
    readonly hint: Signal<string | undefined>;
    readonly placeholder: Signal<any>;
    readonly tooltip: Signal<string | undefined>;
    readonly imageUrl: Signal<string | undefined>;
    readonly imageAlt: Signal<string>;
    protected readonly viewRef: ViewContainerRef;
    protected readonly focusTarget: Signal<KlesFocusTargetDirective | undefined>;
    directive: any;
    protected _onDestroy: Subject<void>;
    constructor();
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    applyPipeTransform(): void;
    isPending(): boolean | undefined;
    onFocus(): void;
    onBlur(): void;
    protected focus(): void;
    triggerAction(actionId: string, originalEvent: Event, value?: unknown): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFieldAbstract<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KlesFieldAbstract<any>, never, never, {}, {}, never, never, true, never>;
}

declare class KlesFormLabelComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    constructor();
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormLabelComponent, "kles-form-label", never, {}, {}, never, never, true, never>;
}

interface IButton {
    event?: string;
    uiButton?: IUIButton;
}
interface IUIButton {
    label?: string;
    color?: string;
    icon?: string;
    iconSvg?: string;
    disabled?: boolean;
    class?: string;
    type?: string;
    accept?: string;
    buttonAppearance?: MatButtonAppearance;
}
declare abstract class KlesButtonBase<TButton extends IButton = IButton> implements OnInit, ControlValueAccessor {
    readonly name: i0.InputSignal<string>;
    readonly label: i0.InputSignal<string>;
    readonly color: i0.InputSignal<string>;
    readonly icon: i0.InputSignal<string>;
    readonly iconSvg: i0.InputSignal<string>;
    readonly disabled: i0.InputSignal<boolean>;
    readonly type: i0.InputSignal<string | undefined>;
    readonly classButton: i0.InputSignal<string>;
    readonly value: i0.InputSignal<TButton>;
    readonly tooltip: i0.InputSignal<string | undefined>;
    readonly buttonAppearance: i0.InputSignal<MatButtonAppearance>;
    protected readonly uiButtonState: i0.WritableSignal<IUIButton | undefined>;
    private readonly formDisabledState;
    private readonly writtenValueState;
    readonly effectiveLabel: i0.Signal<string>;
    readonly effectiveColor: i0.Signal<string>;
    readonly effectiveIcon: i0.Signal<string>;
    readonly effectiveIconSvg: i0.Signal<string>;
    readonly effectiveDisabled: i0.Signal<boolean>;
    readonly effectiveType: i0.Signal<string>;
    readonly effectiveClassButton: i0.Signal<string>;
    readonly effectiveButtonAppearance: i0.Signal<MatButtonAppearance>;
    readonly effectiveValue: i0.Signal<TButton>;
    action: EventEmitter<MouseEvent>;
    protected onChange: (value: TButton) => void;
    protected onTouched: () => void;
    ngOnInit(): void;
    click(event: MouseEvent): void;
    writeValue(value: TButton | null | undefined): void;
    registerOnChange(fn: (value: TButton) => void): void;
    registerOnTouched(fn: () => void): void;
    protected markAsTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesButtonBase<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesButtonBase<any>, "ng-component", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "iconSvg": { "alias": "iconSvg"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "classButton": { "alias": "classButton"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "buttonAppearance": { "alias": "buttonAppearance"; "required": false; "isSignal": true; }; }, { "action": "action"; }, never, never, true, never>;
}

declare class KlesButtonComponent extends KlesButtonBase implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesButtonComponent, "kles-button", never, {}, {}, never, never, true, never>;
}

interface IButtonChecker extends IButton {
    busy: boolean;
    error?: any[];
    message?: string;
}
declare class KlesButtonCheckerComponent extends KlesButtonBase<IButtonChecker> implements ControlValueAccessor {
    countError(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesButtonCheckerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesButtonCheckerComponent, "kles-button-checker", never, {}, {}, never, never, true, never>;
}

interface IButtonFile extends IButton {
    fileContent?: string | ArrayBuffer | (string | ArrayBuffer)[] | null;
}
declare class KlesButtonFileComponent extends KlesButtonBase<IButtonFile> {
    private readonly file;
    readonly accept: i0.InputSignal<string>;
    readonly effectiveAccept: i0.Signal<string>;
    click(_event: MouseEvent): void;
    writeValue(value: IButtonFile | null | undefined): void;
    onFileSelect(input: HTMLInputElement): Promise<void>;
    readUploadedFile(inputFile: File): Promise<string | ArrayBuffer | null>;
    private resetNativeFileInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesButtonFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesButtonFileComponent, "kles-button-file", never, { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KlesTransformPipe implements PipeTransform {
    transform(value: any, pipes?: {
        pipe: PipeTransform;
        options?: any[];
    }[]): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesTransformPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<KlesTransformPipe, "klesTransform", true>;
}

declare class ArrayFormatPipe implements PipeTransform {
    transform(values: any[], property?: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArrayFormatPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<ArrayFormatPipe, "arrayFormat", true>;
}

interface IKlesClearControl extends IKlesField {
    clear(event: any): void;
}

declare class KlesFormClearComponent implements IKlesClearControl {
    readonly field: IKlesFieldConfig;
    readonly group: FormGroup<any>;
    readonly siblingFields: IKlesFieldConfig[];
    disabled: Signal<boolean>;
    constructor();
    clear(event: MouseEvent): void;
    private isPresent;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormClearComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormClearComponent, "kles-form-clear", never, {}, {}, never, never, true, never>;
}

declare class MatErrorMessageDirective implements AfterViewInit {
    readonly validations: i0.InputSignal<IKlesValidator<ValidatorFn>[] | undefined>;
    readonly asyncValidations: i0.InputSignal<IKlesValidator<AsyncValidatorFn>[] | undefined>;
    readonly validationsKeys: i0.Signal<_3kles_kles_material_dynamicforms.KlesValidationKey[]>;
    readonly asyncValidationsKeys: i0.Signal<_3kles_kles_material_dynamicforms.KlesValidationKey[]>;
    private readonly formField;
    private readonly inputRef;
    private readonly controlStatus;
    readonly errors: i0.Signal<_angular_forms.ValidationErrors | null>;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatErrorMessageDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatErrorMessageDirective, "[matErrorMessage]", never, { "validations": { "alias": "validations"; "required": false; "isSignal": true; }; "asyncValidations": { "alias": "asyncValidations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MatErrorFormDirective {
    readonly form: i0.InputSignal<AbstractControl<any, any, any>>;
    readonly validations: i0.InputSignal<IKlesValidator<ValidatorFn>[] | undefined>;
    readonly asyncValidations: i0.InputSignal<IKlesValidator<AsyncValidatorFn>[] | undefined>;
    readonly validationsKeys: i0.Signal<_3kles_kles_material_dynamicforms.KlesValidationKey[]>;
    readonly asyncValidationsKeys: i0.Signal<_3kles_kles_material_dynamicforms.KlesValidationKey[]>;
    readonly formErrors: i0.Signal<_angular_forms.ValidationErrors | null>;
    static ɵfac: i0.ɵɵFactoryDeclaration<MatErrorFormDirective, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MatErrorFormDirective, "[matErrorForm]", never, { "form": { "alias": "form"; "required": true; "isSignal": true; }; "validations": { "alias": "validations"; "required": false; "isSignal": true; }; "asyncValidations": { "alias": "asyncValidations"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KlesFileControlComponent implements ControlValueAccessor {
    private readonly fileInput;
    private readonly disabledState;
    get disabled(): boolean;
    set disabled(value: boolean);
    accept: string;
    multiple: boolean;
    value: KlesFileControlValue;
    private onChange;
    private onTouched;
    writeValue(value: KlesFileControlValue | undefined): void;
    onFileSelected(input: HTMLInputElement): Promise<void>;
    registerOnChange(fn: (value: KlesFileControlValue) => void): void;
    registerOnTouched(fn: () => void): void;
    markAsTouched(): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFileControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFileControlComponent, "kles-file-control", never, { "disabled": { "alias": "disabled"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; }, {}, never, never, true, never>;
}
interface KlesFileValue {
    name: string;
    content: ArrayBuffer;
    type?: string;
    size?: number;
}
type KlesFileControlValue = KlesFileValue[] | null;

declare class KlesDynamicFormIntl {
    loading: string;
    selectAll: string;
    clearSearch: string;
    search: string;
    add: string;
    delete: string;
    copy: string;
    empty: string;
    imageUploadChange: string;
    imageUploadDelete: string;
    imageUploadInvalidType: string;
    imageUploadMaxSize: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesDynamicFormIntl, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KlesDynamicFormIntl>;
}

declare class KlesFormCopyComponent implements IKlesField {
    private readonly tooltip;
    readonly field: IKlesFieldConfig;
    readonly group: FormGroup<any>;
    readonly siblingFields: IKlesFieldConfig[];
    readonly intl: KlesDynamicFormIntl;
    private readonly clipboard;
    readonly tooltipText: string;
    copy(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormCopyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormCopyComponent, "kles-form-copy", never, {}, {}, never, never, true, never>;
}

declare class MaterialModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<MaterialModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<MaterialModule, never, [typeof i1.CommonModule, typeof i2.MatSliderModule, typeof i3.MatButtonModule, typeof i4.MatToolbarModule, typeof i5.MatIconModule, typeof i6.MatSidenavModule, typeof i7.MatBadgeModule, typeof i8.MatListModule, typeof i9.MatGridListModule, typeof i10.MatFormFieldModule, typeof i11.MatInputModule, typeof i12.MatSelectModule, typeof i13.MatRadioModule, typeof i14.MatDatepickerModule, typeof i15.MatChipsModule, typeof i16.MatTooltipModule, typeof i17.MatTableModule, typeof i18.MatPaginatorModule, typeof i19.MatCardModule, typeof i20.MatMenuModule, typeof i21.MatTabsModule, typeof i22.CdkTableModule, typeof i23.MatProgressSpinnerModule, typeof i24.MatCheckboxModule, typeof i25.MatDialogModule, typeof i26.MatAutocompleteModule, typeof i27.MatProgressBarModule, typeof i28.MatSortModule, typeof i29.MatExpansionModule, typeof i30.MatNativeDateModule, typeof i31.MatSnackBarModule, typeof i32.MatTreeModule, typeof i2.MatSliderModule, typeof i33.MatSlideToggleModule, typeof i34.MatButtonToggleModule, typeof i35.PortalModule], [typeof i3.MatButtonModule, typeof i4.MatToolbarModule, typeof i5.MatIconModule, typeof i6.MatSidenavModule, typeof i7.MatBadgeModule, typeof i8.MatListModule, typeof i9.MatGridListModule, typeof i11.MatInputModule, typeof i10.MatFormFieldModule, typeof i12.MatSelectModule, typeof i13.MatRadioModule, typeof i14.MatDatepickerModule, typeof i15.MatChipsModule, typeof i16.MatTooltipModule, typeof i17.MatTableModule, typeof i18.MatPaginatorModule, typeof i19.MatCardModule, typeof i20.MatMenuModule, typeof i21.MatTabsModule, typeof i22.CdkTableModule, typeof i23.MatProgressSpinnerModule, typeof i24.MatCheckboxModule, typeof i25.MatDialogModule, typeof i26.MatAutocompleteModule, typeof i27.MatProgressBarModule, typeof i28.MatSortModule, typeof i29.MatExpansionModule, typeof i30.MatNativeDateModule, typeof i31.MatSnackBarModule, typeof i32.MatTreeModule, typeof i2.MatSliderModule, typeof i33.MatSlideToggleModule, typeof i36.ScrollingModule, typeof i36.CdkScrollable, typeof i34.MatButtonToggleModule, typeof i35.PortalModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<MaterialModule>;
}

declare class KlesFormInputComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    filteredOption$: Observable<{
        loading: boolean;
        options: any[];
    }>;
    options$: Observable<{
        loading: boolean;
        options: any[];
    }>;
    private isFocused;
    isLoading: i0.WritableSignal<boolean>;
    intl: KlesDynamicFormIntl;
    constructor();
    ngOnInit(): void;
    onFocus(): void;
    private filterData;
    displayFn(value: any): any;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormInputComponent, "kles-form-input", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormInputClearableComponent extends KlesFormInputComponent implements OnInit, OnDestroy {
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormInputClearableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormInputClearableComponent, "kles-form-input-clearable", never, {}, {}, never, never, true, never>;
}

declare class KlesFormBadgeComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormBadgeComponent, "kles-form-badge", never, {}, {}, never, never, true, never>;
}

declare class KlesFormFileComponent extends KlesFieldAbstract {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormFileComponent, "kles-form-file", never, {}, {}, never, never, true, never>;
}

declare class KlesFormButtonComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormButtonComponent, "kles-form-button", never, {}, {}, never, never, true, never>;
}

declare class KlesFormButtonCheckerComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormButtonCheckerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormButtonCheckerComponent, "kles-form-button-checker", never, {}, {}, never, never, true, never>;
}

declare class KlesFormButtonFileComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormButtonFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormButtonFileComponent, "kles-form-button-file", never, {}, {}, never, never, true, never>;
}

declare class KlesFormDateComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormDateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormDateComponent, "kles-form-datepicker", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormDateTimeComponent extends KlesFieldAbstract {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormDateTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormDateTimeComponent, "kles-form-datetimepicker", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormRadioComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    private readonly radioButtons;
    protected focus(): void;
    options$: Observable<any[]>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormRadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormRadioComponent, "kles-form-radiobutton", never, {}, {}, never, never, true, never>;
}

declare class KlesFormCheckboxComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    private readonly checkbox;
    protected focus(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onChange(e: MatCheckboxChange): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormCheckboxComponent, "kles-form-checkbox", never, {}, {}, never, never, true, never>;
}

declare class ArrayUiState<TItem extends AbstractUiState<any, any> = AbstractUiState<any, any>, TValue extends any[] = any[], TRawValue extends TValue = TValue> extends AbstractUiState<TValue, TRawValue> {
    states: TItem[];
    constructor(states?: TItem[]);
    setValue(value: TRawValue): void;
    patchValue(value: Partial<TRawValue>): void;
    childValueChanged(key: string | number, value: any): void;
    at(index: number): AbstractUiState;
    _find(name: string | number): AbstractUiState | null;
    push(control: TItem | TItem[]): void;
    insert(index: number, state: TItem | TItem[]): void;
    removeAt(index: number): void;
    clear(): void;
}

declare class KlesFormListFieldComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    readonly intl: KlesDynamicFormIntl;
    formArray: FormArray<FormGroup<Record<string, AbstractControl>>>;
    subUi: ArrayUiState;
    readonly collections: i0.WritableSignal<IKlesFieldConfig[][]>;
    constructor();
    ngOnInit(): void;
    getRowUi(index: number): GroupUiState;
    get hasLayout(): boolean;
    get fieldsDirection(): 'column' | 'row' | 'grid' | 'inline-grid';
    deleteField(index: number): void;
    addField(): void;
    ngOnDestroy(): void;
    getGridColumn(field: IKlesFieldConfig): string;
    getGridRow(field: IKlesFieldConfig): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormListFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormListFieldComponent, "kles-form-listfield", never, {}, {}, never, never, true, never>;
}

declare class KlesFormColorComponent extends KlesFieldAbstract {
    private readonly formControl;
    private readonly controlValue;
    private readonly controlStatus;
    readonly colorOption: i0.Signal<any>;
    readonly parsedColor: i0.Signal<_3kles_kles_material_color_picker.RgbaColor | null>;
    readonly currentColor: i0.Signal<any>;
    readonly backgroundColor: i0.Signal<string>;
    readonly foregroundColor: i0.Signal<"#000000" | "#ffffff">;
    readonly pickerDisabled: i0.Signal<boolean>;
    setColor(value: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormColorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormColorComponent, "kles-form-color", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormTextareaComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormTextareaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormTextareaComponent, "kles-form-textarea", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormTextComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormTextComponent, "kles-form-text", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormChipComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormChipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormChipComponent, "kles-form-chip", never, {}, {}, never, never, true, never>;
}

declare class KlesFormGroupComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    private readonly orientationClass;
    get className(): string;
    subGroup: UntypedFormGroup;
    subUi: GroupUiState;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormGroupComponent, "kles-group", never, {}, {}, never, never, true, never>;
}

declare class KlesFormIconComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormIconComponent, "kles-form-icon", never, {}, {}, never, never, true, never>;
}

declare class KlesFormLineBreakComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormLineBreakComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormLineBreakComponent, "kles-form-line-break", never, {}, {}, never, never, true, never>;
}

declare class KlesFormLinkComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormLinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormLinkComponent, "kles-form-link", never, {}, {}, never, never, true, never>;
}

declare class KlesFormSlideToggleComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    private readonly slideToggle;
    protected focus(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormSlideToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormSlideToggleComponent, "kles-form-slide-toggle", never, {}, {}, never, never, true, never>;
}

/**
 * Copy and past from https://github.com/angular/components/blob/17.0.x/src/cdk/collections/selection-model.ts
 * (They put everything in private, thanks to angular team)
 */
declare class KlesSelectionModel<T> {
    private _multiple;
    private _emitChanges;
    compareWith?: ((o1: T, o2: T) => boolean) | undefined;
    private readonly _revision;
    /** Currently-selected values. */
    private _selection;
    /** Keeps track of the deselected options that haven't been emitted by the change event. */
    private _deselectedToEmit;
    /** Keeps track of the selected options that haven't been emitted by the change event. */
    private _selectedToEmit;
    /** Cache for the array value of the selected items. */
    private _selected;
    /** Selected values. */
    get selected(): T[];
    /** Event emitted when the value has changed. */
    readonly changed: Subject<any>;
    constructor(_multiple?: boolean, initiallySelectedValues?: T[], _emitChanges?: boolean, compareWith?: ((o1: T, o2: T) => boolean) | undefined);
    /**
     * Selects a value or an array of values.
     * @param values The values to select
     * @return Whether the selection changed as a result of this call
     * @breaking-change 16.0.0 make return type boolean
     */
    select(values: T[], option?: {
        emitEvent: boolean;
    }): boolean | void;
    /**
     * Deselects a value or an array of values.
     * @param values The values to deselect
     * @return Whether the selection changed as a result of this call
     * @breaking-change 16.0.0 make return type boolean
     */
    deselect(values: T[], option?: {
        emitEvent: boolean;
    }): boolean | void;
    /**
     * Sets the selected values
     * @param values The new selected values
     * @return Whether the selection changed as a result of this call
     * @breaking-change 16.0.0 make return type boolean
     */
    setSelection(values: T[], option?: {
        emitEvent: boolean;
    }): boolean | void;
    /**
     * Toggles a value between selected and deselected.
     * @param value The value to toggle
     * @return Whether the selection changed as a result of this call
     * @breaking-change 16.0.0 make return type boolean
     */
    toggle(value: T): boolean | void;
    /**
     * Clears all of the selected values.
     * @param flushEvent Whether to flush the changes in an event.
     *   If false, the changes to the selection will be flushed along with the next event.
     * @return Whether the selection changed as a result of this call
     * @breaking-change 16.0.0 make return type boolean
     */
    clear(flushEvent?: boolean): boolean | void;
    /**
     * Determines whether a value is selected.
     */
    isSelected(value: T): boolean;
    /**
     * Determines whether the model does not have a value.
     */
    isEmpty(): boolean;
    /**
     * Determines whether the model has a value.
     */
    hasValue(): boolean;
    /**
     * Sorts the selected values based on a predicate function.
     */
    sort(predicate?: (a: T, b: T) => number): void;
    /**
     * Gets whether multiple values can be selected.
     */
    isMultipleSelection(): boolean;
    /** Emits a change event and clears the records of selected and deselected values. */
    private _emitChangeEvent;
    /** Selects a value. */
    private _markSelected;
    /** Deselects a value. */
    private _unmarkSelected;
    /** Clears out the selected values. */
    private _unmarkAll;
    /**
     * Verifies the value assignment and throws an error if the specified value array is
     * including multiple values while the selection model is not supporting multiple values.
     */
    private _verifyValueAssignment;
    /** Whether there are queued up change to be emitted. */
    private _hasQueuedChanges;
    /** Returns a value that is comparable to inputValue by applying compareWith function, returns the same inputValue otherwise. */
    private _getConcreteValue;
}

declare class KlesFormSelectionListComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    selection: KlesSelectionModel<any>;
    options$: Observable<any[]>;
    private readonly control;
    private readonly controlStatus;
    readonly disabled: i0.Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSelectionChange(selection: MatSelectionListChange): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormSelectionListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormSelectionListComponent, "kles-form-selection-list", never, {}, {}, never, never, true, never>;
}

declare class KlesFormButtonToogleGroupComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    private readonly buttonToggles;
    protected focus(): void;
    options$: Observable<any[]>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormButtonToogleGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormButtonToogleGroupComponent, "kles-form-button-toogle-group", never, {}, {}, never, never, true, never>;
}

declare class KlesFormArrayComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    formArray: UntypedFormArray;
    subUi: ArrayUiState;
    constructor();
    ngOnInit(): void;
    asFormGroup(control: AbstractControl): UntypedFormGroup;
    uiAt(index: number): GroupUiState;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormArrayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormArrayComponent, "kles-array", never, {}, {}, never, never, true, never>;
}

declare class KlesFormRangeComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormRangeComponent, "kles-form-rangepicker", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormFabComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormFabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormFabComponent, "kles-form-fab", never, {}, {}, never, never, true, never>;
}

declare class KlesFabComponent extends KlesButtonBase implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFabComponent, "kles-fab", never, {}, {}, never, never, true, never>;
}

declare class KlesMiniFabComponent extends KlesButtonBase implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesMiniFabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesMiniFabComponent, "kles-mini-fab", never, {}, {}, never, never, true, never>;
}

declare class KlesFormMiniFabComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormMiniFabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormMiniFabComponent, "kles-form-mini-fab", never, {}, {}, never, never, true, never>;
}

declare class KlesIconButtonComponent extends KlesButtonBase implements OnInit {
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesIconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesIconButtonComponent, "kles-icon-button", never, {}, {}, never, never, true, never>;
}

declare class KlesFormIconButtonComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormIconButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormIconButtonComponent, "kles-form-icon-button", never, {}, {}, never, never, true, never>;
}

declare class KlesFormSelectionListSearchComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    selection: KlesSelectionModel<any>;
    options$: Observable<any[]>;
    searchControl: FormControl<string | null>;
    optionFiltered$: Observable<any[]>;
    private readonly control;
    private readonly controlStatus;
    readonly disabled: i0.Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onSelectionChange(selection: MatSelectionListChange): void;
    private syncSearchDisabledState;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormSelectionListSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormSelectionListSearchComponent, "kles-form-selection-list-search", never, {}, {}, never, never, true, never>;
}

declare class KlesFormTileComponent extends KlesFieldAbstract {
    private readonly control;
    private readonly controlValue;
    readonly formattedValue: i0.Signal<string>;
    readonly displayValue: i0.Signal<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormTileComponent, "app-kles-form-tile", never, {}, {}, never, never, true, never>;
}

/**
 * Condition statique ou calculée à partir du contexte du field.
 */
type KlesActionMenuCondition<TContext = unknown> = boolean | ((context: TContext | null, field: IKlesFieldConfig, group: UntypedFormGroup) => boolean);
/**
 * Configuration d'une entrée du menu.
 *
 * Le callback n'est pas placé ici :
 * toutes les actions sont gérées par field.onAction.
 */
interface KlesActionMenuItem<TContext = unknown> {
    id: string;
    label: string;
    icon?: string;
    iconSvg?: string;
    visible?: KlesActionMenuCondition<TContext>;
    disabled?: KlesActionMenuCondition<TContext>;
    dividerBefore?: boolean;
    color?: 'default' | 'warn';
}
/**
 * Configuration spécialisée du field action-menu.
 */
interface KlesActionMenuFieldConfig<TContext = unknown> extends IKlesFieldConfig {
    options?: KlesActionMenuItem<TContext>[] | Observable<KlesActionMenuItem<TContext>[]> | ((value?: string, group?: {
        [key: string]: any;
    }) => Observable<KlesActionMenuItem<TContext>[]>);
    menuXPosition?: 'before' | 'after';
    menuYPosition?: 'above' | 'below';
}
declare class KlesFormActionMenuComponent<TContext = unknown> extends KlesFieldAbstract<TContext> {
    /**
     * Configuration du field avec le typage spécialisé.
     */
    readonly actionField: KlesActionMenuFieldConfig<TContext>;
    private readonly control;
    private readonly controlStatus;
    /**
     * Options statiques ou asynchrones.
     */
    private readonly actionsSource$;
    readonly actions: i0.Signal<KlesActionMenuItem<TContext>[]>;
    readonly disabled: i0.Signal<boolean>;
    readonly visibleActions: i0.Signal<KlesActionMenuItem<TContext>[]>;
    readonly ariaLabel: i0.Signal<string>;
    onTriggerClick(event: MouseEvent): void;
    isDisabled(action: KlesActionMenuItem<TContext>): boolean;
    execute(action: KlesActionMenuItem<TContext>, event: MouseEvent): void;
    private resolveCondition;
    private resolveOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormActionMenuComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormActionMenuComponent<any>, "kles-form-action-menu", never, {}, {}, never, never, true, never>;
}

/**
 * ValueAccessor monétaire.
 *
 * La valeur du FormControl reste un number | null.
 * Seule la valeur affichée dans l'input est formatée.
 */
declare class KlesCurrencyValueAccessorDirective implements ControlValueAccessor, OnChanges {
    private readonly elementRef;
    private readonly renderer;
    currency: string;
    locale: string;
    currencyDisplay: 'symbol' | 'narrowSymbol' | 'code' | 'name';
    minimumFractionDigits?: number;
    maximumFractionDigits?: number;
    useGrouping: boolean;
    allowNegative: boolean;
    private currentValue;
    private focused;
    private onChange;
    private onTouched;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: unknown): void;
    registerOnChange(callback: (value: number | null) => void): void;
    registerOnTouched(callback: () => void): void;
    setDisabledState(disabled: boolean): void;
    handleFocus(): void;
    handleInput(event: Event): void;
    handleBlur(): void;
    private normalizeModelValue;
    private renderFormattedValue;
    private setInputValue;
    private formatCurrency;
    /**
     * Pendant l'édition, on retire le symbole et
     * les séparateurs de milliers.
     */
    private formatEditableValue;
    private createCurrencyFormatOptions;
    private parseLocalizedNumber;
    /**
     * Convertit également les chiffres localisés
     * vers 0-9.
     */
    private normalizeLocalizedDigits;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesCurrencyValueAccessorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<KlesCurrencyValueAccessorDirective, "input[klesCurrency]", never, { "currency": { "alias": "currency"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "currencyDisplay": { "alias": "currencyDisplay"; "required": false; }; "minimumFractionDigits": { "alias": "minimumFractionDigits"; "required": false; }; "maximumFractionDigits": { "alias": "maximumFractionDigits"; "required": false; }; "useGrouping": { "alias": "useGrouping"; "required": false; }; "allowNegative": { "alias": "allowNegative"; "required": false; }; }, {}, never, never, true, never>;
}
declare class KlesFormCurrencyComponent extends KlesFieldAbstract {
    readonly localeId: string;
    readonly currencyOptions: i0.Signal<_3kles_kles_material_dynamicforms.IKlesCurrencyOptions | undefined>;
    readonly defaultCurrencyCode: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormCurrencyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormCurrencyComponent, "kles-form-currency", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormStatusComponent<TContext = unknown> extends KlesFieldAbstract<TContext> {
    private readonly control;
    private readonly controlValue;
    private readonly controlStatus;
    readonly statusAppearance: i0.Signal<_3kles_kles_material_dynamicforms.KlesStatusAppearance>;
    readonly showDot: i0.Signal<boolean>;
    readonly disabled: i0.Signal<boolean>;
    readonly pending: i0.Signal<boolean>;
    readonly resolvedStatus: i0.Signal<IKlesStatusDefinition | null>;
    private resolveStatusKey;
    private resolveDefaultLabel;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormStatusComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormStatusComponent<any>, "kles-form-status", never, {}, {}, never, never, true, never>;
}

interface ChipOptionsState {
    loading: boolean;
    options: any[];
}
declare class KlesFormChipGridComponent extends KlesFieldAbstract implements OnInit {
    readonly control: FormControl<any[]>;
    readonly intl: KlesDynamicFormIntl;
    readonly separatorKeysCodes: number[];
    readonly searchControl: FormControl<any>;
    filteredOption$: Observable<ChipOptionsState>;
    private options$;
    private readonly loadOptions$;
    ngOnInit(): void;
    onFocus(): void;
    onTokenEnd(event: MatChipInputEvent): void;
    addChip(value: unknown): void;
    removeChip(value: unknown): void;
    selected(event: MatAutocompleteSelectedEvent, chipInput: MatChipInput): void;
    displayValue(value: any): any;
    private createOptionsStream;
    private resolveOptions;
    private filterData;
    private isSameOption;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormChipGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormChipGridComponent, "kles-form-chip-grid", never, {}, {}, never, never, true, never>;
}

declare class KlesFormImageUploadComponent extends KlesFieldAbstract implements OnInit, OnDestroy {
    readonly intl: KlesDynamicFormIntl;
    private readonly fileInput;
    private readonly control;
    private readonly localPreviewUrl;
    private readonly imageRemoved;
    private readonly controlValue;
    private controlSubscription?;
    readonly options: i0.Signal<_3kles_kles_material_dynamicforms.IKlesImageUploadOptions>;
    readonly accept: i0.Signal<string>;
    readonly disabled: i0.Signal<boolean>;
    readonly errorMessage: i0.WritableSignal<string | null>;
    readonly previewUrl: i0.Signal<string | null>;
    readonly hasImage: i0.Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    openFilePicker(): void;
    selectFile(event: Event): Promise<void>;
    deleteImage(): void;
    private previewFromValue;
    private isAccepted;
    private rejectFile;
    private clearImageErrors;
    private clearLocalPreview;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormImageUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormImageUploadComponent, "kles-form-image-upload", never, {}, {}, never, never, true, never>;
}

declare class KlesMaterialDynamicformsModule {
    static declarations: ((typeof KlesFormClearComponent | typeof KlesDynamicFormComponent | typeof KlesFormLabelComponent | typeof KlesButtonComponent | typeof KlesButtonCheckerComponent | typeof KlesButtonFileComponent | typeof KlesFileControlComponent | typeof KlesFormCopyComponent)[] | (typeof KlesDynamicFieldDirective | typeof MatErrorFormDirective | typeof KlesComponentDirective | typeof MatErrorMessageDirective)[] | (typeof KlesTransformPipe | typeof ArrayFormatPipe)[])[];
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesMaterialDynamicformsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<KlesMaterialDynamicformsModule, never, [typeof i1.CommonModule, typeof _angular_forms.ReactiveFormsModule, typeof _angular_forms.FormsModule, typeof MaterialModule, typeof KlesDynamicFormComponent, typeof KlesFormLabelComponent, typeof KlesFormInputComponent, typeof KlesFormInputClearableComponent, typeof KlesFormBadgeComponent, typeof KlesFormFileComponent, typeof KlesFileControlComponent, typeof KlesButtonComponent, typeof KlesFormButtonComponent, typeof KlesButtonCheckerComponent, typeof KlesFormButtonCheckerComponent, typeof KlesButtonFileComponent, typeof KlesFormButtonFileComponent, typeof KlesFormDateComponent, typeof KlesFormDateTimeComponent, typeof KlesFormRadioComponent, typeof KlesFormCheckboxComponent, typeof KlesFormListFieldComponent, typeof KlesFormColorComponent, typeof KlesFormTextareaComponent, typeof KlesFormTextComponent, typeof KlesFormChipComponent, typeof KlesFormGroupComponent, typeof KlesFormIconComponent, typeof KlesFormLineBreakComponent, typeof KlesFormLinkComponent, typeof KlesFormSlideToggleComponent, typeof KlesFormSelectionListComponent, typeof KlesFormButtonToogleGroupComponent, typeof KlesFormArrayComponent, typeof KlesFormRangeComponent, typeof KlesFormClearComponent, typeof KlesFormFabComponent, typeof KlesFabComponent, typeof KlesMiniFabComponent, typeof KlesFormMiniFabComponent, typeof KlesIconButtonComponent, typeof KlesFormIconButtonComponent, typeof KlesFormSelectionListSearchComponent, typeof KlesFormCopyComponent, typeof KlesFormTileComponent, typeof KlesFormActionMenuComponent, typeof KlesFormCurrencyComponent, typeof KlesFormStatusComponent, typeof KlesFormChipGridComponent, typeof KlesFormImageUploadComponent, typeof KlesDynamicFieldDirective, typeof KlesComponentDirective, typeof MatErrorMessageDirective, typeof MatErrorFormDirective, typeof KlesTransformPipe, typeof ArrayFormatPipe], [typeof KlesDynamicFormComponent, typeof KlesFormLabelComponent, typeof KlesFormInputComponent, typeof KlesFormInputClearableComponent, typeof KlesFormBadgeComponent, typeof KlesFormFileComponent, typeof KlesFileControlComponent, typeof KlesButtonComponent, typeof KlesFormButtonComponent, typeof KlesButtonCheckerComponent, typeof KlesFormButtonCheckerComponent, typeof KlesButtonFileComponent, typeof KlesFormButtonFileComponent, typeof KlesFormDateComponent, typeof KlesFormDateTimeComponent, typeof KlesFormRadioComponent, typeof KlesFormCheckboxComponent, typeof KlesFormListFieldComponent, typeof KlesFormColorComponent, typeof KlesFormTextareaComponent, typeof KlesFormTextComponent, typeof KlesFormChipComponent, typeof KlesFormGroupComponent, typeof KlesFormIconComponent, typeof KlesFormLineBreakComponent, typeof KlesFormLinkComponent, typeof KlesFormSlideToggleComponent, typeof KlesFormSelectionListComponent, typeof KlesFormButtonToogleGroupComponent, typeof KlesFormArrayComponent, typeof KlesFormRangeComponent, typeof KlesFormClearComponent, typeof KlesFormFabComponent, typeof KlesFabComponent, typeof KlesMiniFabComponent, typeof KlesFormMiniFabComponent, typeof KlesIconButtonComponent, typeof KlesFormIconButtonComponent, typeof KlesFormSelectionListSearchComponent, typeof KlesFormCopyComponent, typeof KlesFormTileComponent, typeof KlesFormActionMenuComponent, typeof KlesFormCurrencyComponent, typeof KlesFormStatusComponent, typeof KlesFormChipGridComponent, typeof KlesFormImageUploadComponent, typeof KlesTransformPipe, typeof ArrayFormatPipe, typeof KlesDynamicFieldDirective, typeof KlesComponentDirective, typeof MatErrorMessageDirective, typeof MatErrorFormDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<KlesMaterialDynamicformsModule>;
}

declare class KlesFormPasswordVisibilityComponent implements IKlesField {
    readonly field: IKlesFieldConfig;
    readonly group: FormGroup<any>;
    readonly siblingFields: IKlesFieldConfig[];
    readonly ui: GroupUiState<any> | null;
    private readonly control;
    readonly disabled: i0.Signal<boolean>;
    readonly hide: i0.Signal<boolean>;
    toggleVisibility(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormPasswordVisibilityComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormPasswordVisibilityComponent, "kles-form-password-visibility", never, {}, {}, never, never, true, never>;
}

declare class KlesFormSelectComponent extends KlesFieldAbstract implements OnInit, AfterViewInit, OnDestroy {
    readonly searchControl: FormControl<string | null>;
    readonly selectAllControl: FormControl<boolean>;
    readonly selectAllIndeterminate: i0.WritableSignal<boolean>;
    readonly isLoading: i0.WritableSignal<boolean>;
    readonly filteredOptions: i0.WritableSignal<any[]>;
    readonly intl: KlesDynamicFormIntl;
    protected readonly changeDetectorRef: ChangeDetectorRef;
    private readonly matSelect;
    private readonly virtualViewport;
    protected focus(): void;
    searchOptions: IKlesSelectSearchOptions;
    private readonly deferredQuery$;
    private sourceOptions;
    private visibleOptions;
    private isPanelOpen;
    private isDeferredSourceLoaded;
    private deferredOptionsRequest$?;
    private restoreMatSelectScroll?;
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    isSearchEnabled(): boolean;
    panelClasses(): string[];
    onOpenedChange(opened: boolean): void;
    toggleVisibleOptions(state: {
        checked: boolean;
    }): void;
    getHiddenSelectedOptions(): any[];
    compareFn: (first: any, second: any) => boolean;
    private normalizeSearchOptions;
    private usesDeferredSource;
    private loadInitialOptions;
    private initializeDeferredQueries;
    private resolveOptions;
    private applyLocalFilter;
    private setVisibleOptions;
    private filterOptions;
    private normalizeSearchValue;
    private installMatSelectScrollCorrection;
    private keepOptionVisible;
    private selectedValues;
    private updateSelectAllState;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<KlesFormSelectComponent, "kles-form-select", never, {}, {}, never, ["*"], true, never>;
}

declare class KlesFormErrorStateMatcher implements ErrorStateMatcher {
    constructor();
    isErrorState(control: UntypedFormControl | null, form: FormGroupDirective | NgForm | null): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<KlesFormErrorStateMatcher, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<KlesFormErrorStateMatcher>;
}

declare function autocompleteObjectValidator(optional?: boolean): ValidatorFn;
declare function autocompleteStringValidator(validOptions: Array<string>, optional?: boolean): ValidatorFn;

declare const componentMapper: {
    component: Type<any>;
    type: string;
    factory: (field: IKlesFieldConfig, ref?: ChangeDetectorRef) => AbstractControl<any, any> | null;
    ui: (field: IKlesFieldConfig) => AbstractUiState<any, any>;
}[];
declare function FieldMapper(config: {
    type: string;
    factory?: (field: IKlesFieldConfig) => AbstractControl<any, any> | null;
    ui?: (field: IKlesFieldConfig) => AbstractUiState<any, any>;
}): (target: Type<any>) => void;

declare const klesFieldControlFactory: (field: IKlesFieldConfig, ref?: ChangeDetectorRef) => AbstractControl;
declare const klesFieldUiFactory: (field: IKlesFieldConfig) => AbstractUiState;

interface IKlesControl {
    create(): AbstractControl;
    bindValidations(validations: IKlesValidator<ValidatorFn>[]): ValidatorFn | null;
    bindAsyncValidations(validations: IKlesValidator<AsyncValidatorFn>[]): AsyncValidatorFn | null;
}

declare abstract class KlesAbstractFormControl implements IKlesControl {
    protected field: IKlesFieldConfig;
    protected ref?: ChangeDetectorRef | undefined;
    constructor(field: IKlesFieldConfig, ref?: ChangeDetectorRef | undefined);
    abstract create(): AbstractControl;
    bindValidations(validations: IKlesValidator<ValidatorFn>[]): ValidatorFn | null;
    bindAsyncValidations(validations: IKlesValidator<AsyncValidatorFn>[]): AsyncValidatorFn | null;
}

declare class KlesFormControl extends KlesAbstractFormControl {
    create(): AbstractControl;
}

declare class KlesFormArray extends KlesFormControl {
    create(): AbstractControl<any, any>;
}

declare class KlesFormGroup extends KlesFormControl {
    create(): AbstractControl<any, any>;
}

declare class KlesFormRange extends KlesFormControl {
    create(): AbstractControl<any, any>;
}

interface Destroyable {
    destroy(): void;
}
declare function isDestroyable(value: unknown): value is Destroyable;

interface IKlesUi {
    create(): AbstractUiState;
}

declare abstract class KlesAbstractFormUiControl implements IKlesUi {
    protected field: IKlesFieldConfig;
    constructor(field: IKlesFieldConfig);
    abstract create(): AbstractUiState;
}

declare class KlesFormUiControl extends KlesAbstractFormUiControl {
    create(): AbstractUiState;
}

declare class KlesFormUiArray extends KlesFormUiControl {
    create(): AbstractUiState<any, any>;
}

declare class KlesFormUiGroup extends KlesFormUiControl {
    create(): AbstractUiState<any, any>;
}

declare class ControlUiState<TValue extends IKlesFieldUi> extends AbstractUiState<TValue, TValue> {
    constructor(value?: TValue);
    get value(): Signal<TValue | undefined>;
    setValue(value: TValue): void;
    patchValue(value: Partial<TValue> | TValue): void;
}

declare const FIELD_NAME: InjectionToken<string>;
declare const GROUP: InjectionToken<FormGroup<any>>;
declare const SIBLING_FIELDS: InjectionToken<IKlesFieldConfig[]>;
declare const GROUP_UI: InjectionToken<GroupUiState<any>>;
declare const FIELD: InjectionToken<IKlesFieldConfig>;
declare const FIELD_CONTEXT: InjectionToken<Signal<unknown>>;

export { AbstractUiState, ArrayFormatPipe, ArrayUiState, ControlUiState, EnumType, FIELD, FIELD_CONTEXT, FIELD_NAME, FieldMapper, GROUP, GROUP_UI, GroupUiState, KlesAbstractFormControl, KlesAbstractFormUiControl, KlesButtonBase, KlesButtonCheckerComponent, KlesButtonComponent, KlesButtonFileComponent, KlesComponentDirective, KlesCurrencyValueAccessorDirective, KlesDynamicFieldDirective, KlesDynamicFormComponent, KlesDynamicFormIntl, KlesFabComponent, KlesFieldAbstract, KlesFileControlComponent, KlesFocusTargetDirective, KlesFormActionMenuComponent, KlesFormArray, KlesFormArrayComponent, KlesFormBadgeComponent, KlesFormButtonCheckerComponent, KlesFormButtonComponent, KlesFormButtonFileComponent, KlesFormButtonToogleGroupComponent, KlesFormCheckboxComponent, KlesFormChipComponent, KlesFormChipGridComponent, KlesFormClearComponent, KlesFormColorComponent, KlesFormControl, KlesFormCopyComponent, KlesFormCurrencyComponent, KlesFormDateComponent, KlesFormDateTimeComponent, KlesFormErrorStateMatcher, KlesFormFabComponent, KlesFormFileComponent, KlesFormGroup, KlesFormGroupComponent, KlesFormIconButtonComponent, KlesFormIconComponent, KlesFormImageUploadComponent, KlesFormInputClearableComponent, KlesFormInputComponent, KlesFormLabelComponent, KlesFormLineBreakComponent, KlesFormLinkComponent, KlesFormListFieldComponent, KlesFormMiniFabComponent, KlesFormPasswordVisibilityComponent, KlesFormRadioComponent, KlesFormRange, KlesFormRangeComponent, KlesFormSelectComponent, KlesFormSelectionListComponent, KlesFormSelectionListSearchComponent, KlesFormSlideToggleComponent, KlesFormStatusComponent, KlesFormTextComponent, KlesFormTextareaComponent, KlesFormTileComponent, KlesFormUiArray, KlesFormUiControl, KlesFormUiGroup, KlesIconButtonComponent, KlesMaterialDynamicformsModule, KlesMiniFabComponent, KlesSelectionModel, KlesTransformPipe, MatErrorFormDirective, MatErrorMessageDirective, SIBLING_FIELDS, autocompleteObjectValidator, autocompleteStringValidator, componentMapper, flattenKlesFields, isDestroyable, isKlesStructuralElement, klesFieldControlFactory, klesFieldUiFactory };
export type { Destroyable, IButton, IButtonChecker, IButtonFile, IKlesClearControl, IKlesComponent, IKlesControl, IKlesCurrencyOptions, IKlesDirective, IKlesElementLayout, IKlesElementLayoutBreakpoint, IKlesField, IKlesFieldActionEvent, IKlesFieldConfig, IKlesFieldUi, IKlesFieldUiResolveEvent, IKlesFieldUiResolver, IKlesFormDivider, IKlesFormField, IKlesFormLayoutGroup, IKlesFormSection, IKlesFormSpacer, IKlesImageUploadOptions, IKlesLayoutConfig, IKlesSelectSearchOptions, IKlesStatusDefinition, IKlesStatusOptions, IKlesUi, IKlesValidator, IUIButton, KlesActionMenuCondition, KlesActionMenuFieldConfig, KlesActionMenuItem, KlesComponentType, KlesFileControlValue, KlesFileValue, KlesFormElement, KlesFormStructuralElement, KlesGetProperty, KlesStatusAppearance, KlesStatusTone, KlesTypedOrUntyped, KlesValidationKey };