import * as i0 from '@angular/core';
import { TemplateRef, AfterViewInit, OnDestroy, EventEmitter, QueryList, ElementRef, ChangeDetectorRef, OnInit } from '@angular/core';
import * as i1 from '@bloomreach/brie/expansion-panel';
import { BrieExpansionPanelIcon } from '@bloomreach/brie/expansion-panel';
import * as i2 from '@angular/common';
import * as i3 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import * as i4 from '@angular/forms';
import { ValidatorFn, AbstractControl, UntypedFormGroup, FormGroup, AbstractControlOptions, UntypedFormArray, ControlValueAccessor, FormGroupDirective } from '@angular/forms';
import * as i5 from '@angular/material/autocomplete';
import * as i6 from '@angular/material/button';
import * as i7 from '@angular/material/checkbox';
import * as i8 from '@angular/material/slide-toggle';
import * as i9 from '@angular/material/form-field';
import * as i10 from '@angular/material/icon';
import * as i11 from '@angular/material/input';
import * as i12 from '@angular/material/select';
import * as i13 from '@angular/material/datepicker';
import * as i14 from '@angular/material/radio';
import * as i15 from '@angular/material/tooltip';
import * as i16 from '@bloomreach/brie/icon';
import { BrieIcon, BrieIconSize } from '@bloomreach/brie/icon';
import { Observable } from 'rxjs';
import { ErrorStateMatcher } from '@angular/material/core';

type BrieFormField = BrieFormInputField | BrieFormCheckboxField | BrieFormToggleField | BrieFormSelectField | BrieFormTextField | BrieFormDateField | BrieFormDateTimeField | BrieFormLinkpickerField | BrieFormRadioField | BrieFormHiddenField;
type BrieFormDataSource = Array<BrieFormField | BrieFormGroupRepeaterField | BrieFormFieldsGroup>;
interface BrieFormFieldsGroup {
    id: string;
    name?: string;
    type: BrieFormFieldType.FIELDS_GROUP;
    label: string;
    collapsable?: boolean;
    hidden?: boolean;
    fields: Array<BrieFormField | BrieFormGroupRepeaterField>;
    panel?: {
        title: string;
        content: string;
    };
}
interface BrieFormGroupRepeaterField {
    id: string;
    name: string;
    type: BrieFormFieldType.GROUP_REPEATER;
    hidden?: boolean;
    fields: BrieFormField[];
    values?: BrieFormGroupRepeaterValues;
    draggable?: boolean;
    readOnly?: boolean;
}
type BrieFormGroupRepeaterValues = Record<string, string | number | boolean | BrieFormSelectOption>[];
interface BrieFormFieldBase {
    id: string;
    name: string;
    label?: string;
    tooltip?: string;
    validators?: ValidatorFn[];
    errors?: BrieFormFieldError[];
    disabled?: boolean;
    width?: string;
    hint?: string;
}
declare enum BrieFormInputIconPosition {
    SUFFIX = "suffix",
    PREFIX = "prefix",
    TRAILING_OUTSIDE = "trailing-outside",
    LEADING_OUTSIDE = "leading-outside"
}
interface BrieFormInputIcon {
    icon: BrieIcon;
    position: BrieFormInputIconPosition;
    onClick?: (control: AbstractControl, field: BrieFormInputField) => void;
    visible?: (control: AbstractControl | null) => boolean;
}
interface BrieFormInputField extends BrieFormFieldBase {
    type: BrieFormFieldType.INPUT;
    inputType?: string;
    placeholder?: string;
    value?: string | number;
    readOnly?: boolean;
    options?: string[];
    icons?: BrieFormInputIcon[];
}
interface BrieFormHiddenField extends BrieFormFieldBase {
    type: BrieFormFieldType.HIDDEN;
    value?: string | number;
}
interface BrieFormLinkpickerField extends BrieFormFieldBase {
    type: BrieFormFieldType.LINK_PICKER;
    placeholder?: string;
    value?: string;
    openPicker: (value: string, field: BrieFormLinkpickerField) => void;
    icons?: BrieFormInputIcon[];
}
interface BrieFormDateField extends BrieFormFieldBase {
    type: BrieFormFieldType.DATE;
    inputType?: string;
    placeholder?: string;
    value?: string | Date;
    readOnly?: boolean;
    options?: string[];
    icons?: BrieFormInputIcon[];
}
interface BrieFormDateTimeField extends BrieFormFieldBase {
    type: BrieFormFieldType.DATE_TIME;
    inputType?: string;
    placeholder?: string;
    value?: string | Date;
    readOnly?: boolean;
    options?: string[];
    icons?: BrieFormInputIcon[];
}
interface BrieFormCheckboxField extends BrieFormFieldBase {
    type: BrieFormFieldType.CHECKBOX;
    value?: boolean;
    labelTemplate?: TemplateRef<any>;
}
interface BrieFormToggleField extends BrieFormFieldBase {
    type: BrieFormFieldType.TOGGLE;
    value?: boolean;
}
interface BrieFormSelectField extends BrieFormFieldBase {
    type: BrieFormFieldType.SELECT;
    placeholder?: string;
    value?: BrieFormSelectOption['value'] | BrieFormSelectOption['value'][];
    readOnly?: boolean;
    multiple?: boolean;
    options?: BrieFormSelectOption[];
}
interface BrieFormSelectOption {
    disabled?: boolean;
    value: string | number;
    label: string;
}
interface BrieFormTextField extends BrieFormFieldBase {
    maxLength?: number;
    maxRows?: number;
    minLength?: number;
    minRows?: number;
    placeholder?: string;
    readOnly?: boolean;
    resizable?: boolean;
    type: BrieFormFieldType.TEXT;
    value?: string | number;
}
interface BrieFormFieldError {
    message: string;
    validate(control: AbstractControl | null): boolean;
}
declare enum BrieFormFieldType {
    INPUT = "input",
    CHECKBOX = "checkbox",
    TOGGLE = "toggle",
    RADIO = "radio",
    SELECT = "select",
    GROUP_REPEATER = "group-repeater",
    TEXT = "text",
    FIELDS_GROUP = "fields-group",
    DATE = "date",
    DATE_TIME = "date-time",
    LINK_PICKER = "link-picker",
    HIDDEN = "hidden"
}
interface BrieFormControls {
    [controlId: string]: AbstractControl;
}
interface BrieFormRadioField extends BrieFormFieldBase {
    buttons: BrieFormRadioButton[];
    required?: boolean;
    type: BrieFormFieldType.RADIO;
    value?: string | number;
}
interface BrieFormRadioButton {
    id?: string;
    disabled?: boolean;
    value: string | number;
    label: string;
    icon?: BrieIcon;
}

declare class BrieFormComponent implements AfterViewInit, OnDestroy {
    private readonly detectorRef;
    group: UntypedFormGroup;
    dataSource: BrieFormDataSource;
    autofocus: boolean;
    focusChanged: EventEmitter<void>;
    formControl: QueryList<ElementRef<HTMLInputElement | HTMLSelectElement>>;
    repeaterControl: QueryList<ElementRef<HTMLInputElement | HTMLSelectElement>>;
    private subscriptions;
    constructor(detectorRef: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    get FieldTypes(): typeof BrieFormFieldType;
    trackByFn(_index: number, field: BrieFormField | BrieFormGroupRepeaterField | BrieFormFieldsGroup): string;
    private focusForm;
    private focusFormControl;
    private focusRepeaterControl;
    private isFieldDisabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormComponent, "brie-form", never, { "group": { "alias": "group"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "focusChanged": { "alias": "focusChanged"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormInputComponent implements OnInit {
    group: UntypedFormGroup;
    field: BrieFormInputField;
    hasLabel?: boolean;
    filteredOptions?: Observable<string[]>;
    iconPositions: typeof BrieFormInputIconPosition;
    iconSizes: typeof BrieIconSize;
    get fieldId(): string;
    get inputId(): string;
    get control(): AbstractControl;
    ngOnInit(): void;
    isFieldDisabled(): boolean;
    isIconEnabled(inputIcon: BrieFormInputIcon): boolean;
    private filterOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormInputComponent, "brie-form-input", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormLinkpickerComponent {
    group: FormGroup;
    field: BrieFormLinkpickerField;
    hasLabel?: boolean;
    iconPositions: typeof BrieFormInputIconPosition;
    iconSizes: typeof BrieIconSize;
    icons: BrieFormInputIcon[];
    get fieldId(): string;
    get inputId(): string;
    get control(): AbstractControl;
    getIcons(): BrieFormInputIcon[];
    isFieldRequired(): boolean;
    isFieldDisabled(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormLinkpickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormLinkpickerComponent, "brie-form-linkpicker", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormControlComponent {
    group: UntypedFormGroup;
    field: BrieFormField;
    index: number;
    get FieldTypes(): typeof BrieFormFieldType;
    get hasLabel(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormControlComponent, "brie-form-control", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "index": { "alias": "index"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormSelectComponent {
    group: UntypedFormGroup;
    field: BrieFormSelectField;
    hasLabel?: boolean;
    iconSizes: typeof BrieIconSize;
    get fieldId(): string;
    get selectId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormSelectComponent, "brie-form-select", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormCheckboxComponent {
    group: UntypedFormGroup;
    field: BrieFormCheckboxField;
    iconSizes: typeof BrieIconSize;
    labelTemplate: TemplateRef<any>;
    get fieldId(): string;
    get checkboxId(): string;
    get effectiveLabelTemplate(): TemplateRef<any> | null;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormCheckboxComponent, "brie-form-checkbox", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, ["labelTemplate"], never, true, never>;
}

declare class BrieFormToggleComponent {
    group: FormGroup;
    field: BrieFormToggleField;
    get fieldId(): string;
    get toggleId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormToggleComponent, "brie-form-toggle", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormService {
    createFormGroup(fields: BrieFormDataSource, options?: AbstractControlOptions | null): UntypedFormGroup;
    createGroupRepeaterFormArray(field: BrieFormGroupRepeaterField, values?: BrieFormGroupRepeaterValues): UntypedFormArray;
    private buildBrieFormControls;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrieFormService>;
}

declare class BrieFormGroupRepeaterComponent {
    private readonly formService;
    group: UntypedFormGroup;
    field: BrieFormGroupRepeaterField;
    formGroupControl: QueryList<ElementRef<HTMLInputElement | HTMLSelectElement>>;
    constructor(formService: BrieFormService);
    get fieldsFormArray(): UntypedFormArray;
    get fields(): BrieFormField[];
    getFormGroup(id: number): UntypedFormGroup;
    add(event: Event): void;
    remove(event: Event, i: number): void;
    drop(event: CdkDragDrop<string[]>): void;
    isDragDisabled(): boolean;
    isReadOnly(): boolean;
    private focusFormControl;
    private isFieldDisabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormGroupRepeaterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormGroupRepeaterComponent, "brie-form-group-repeater", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormTextComponent {
    group: UntypedFormGroup;
    field: BrieFormTextField;
    hasLabel?: boolean;
    iconSizes: typeof BrieIconSize;
    get fieldId(): string;
    get textId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormTextComponent, "brie-form-text", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormFieldsGroupComponent {
    group: UntypedFormGroup;
    field: BrieFormFieldsGroup;
    isCollapsed: boolean;
    get groupId(): string;
    get FieldTypes(): typeof BrieFormFieldType;
    get fields(): BrieFormFieldsGroup['fields'];
    get panelIcon(): BrieExpansionPanelIcon;
    toggleCollapse(): void;
    trackByFn(_index: number, field: BrieFormFieldsGroup['fields'][0]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormFieldsGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormFieldsGroupComponent, "brie-form-fields-group", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormRadioComponent {
    group: UntypedFormGroup;
    field: BrieFormRadioField;
    get fieldId(): string;
    getFieldId(): string;
    getButtonId(button: BrieFormRadioButton, index: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormRadioComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormRadioComponent, "brie-form-radio", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DatetimeFieldComponent implements ControlValueAccessor, OnInit {
    field: BrieFormDateField | BrieFormDateTimeField;
    isDateAndTime: boolean;
    hasLabel?: boolean;
    group: UntypedFormGroup;
    dateField: ElementRef;
    iconSizes: typeof BrieIconSize;
    date: Date | null;
    formGroup: FormGroup;
    isDisabled: boolean;
    errorStateMatcher: ErrorStateMatcher;
    private _onChange;
    private _onTouched;
    setDisabledState(isDisabled: boolean): void;
    ngOnInit(): void;
    writeValue(value: Date | null): void;
    registerOnChange(fn: (value: Date | null) => void): void;
    registerOnTouched(fn: () => void): void;
    onDateEvent(value: Date): void;
    onTimeChange(): void;
    setDateToNow(): void;
    updateFormFields(): void;
    isFieldRequired(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatetimeFieldComponent, "brie-datetime-field", never, { "field": { "alias": "field"; "required": false; }; "isDateAndTime": { "alias": "isDateAndTime"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; "group": { "alias": "group"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormDateTimeComponent {
    group: UntypedFormGroup;
    field: BrieFormDateField | BrieFormDateTimeField;
    hasLabel?: boolean;
    type?: BrieFormFieldType.DATE_TIME | BrieFormFieldType.DATE;
    get fieldId(): string;
    get textId(): string;
    get isDateAndTime(): boolean;
    isFieldRequired(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormDateTimeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormDateTimeComponent, "brie-form-datetime", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; "hasLabel": { "alias": "hasLabel"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, never, true, never>;
}

interface BrieFormValidationOptions {
    /** Re-run updateValueAndValidity on the form tree. Default: true */
    updateValueAndValidity?: boolean;
    /** Focus the first invalid control after marking touched. Default: false */
    focusFirstError?: boolean;
    /** DOM scope for focus; directive passes the form element */
    focusRoot?: HTMLElement;
}
interface BrieFormValidationResult {
    valid: boolean;
    firstInvalidControl?: AbstractControl;
}

declare class BrieFormValidationService {
    showValidationErrors(form: AbstractControl, options?: BrieFormValidationOptions): BrieFormValidationResult;
    private findFirstInvalidControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormValidationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrieFormValidationService>;
}

declare class BrieShowErrorsOnSubmitDirective {
    private readonly host;
    private readonly validationService;
    private readonly formGroupDirective?;
    brieShowErrorsOnSubmit: boolean | '';
    brieFocusFirstError: boolean | '';
    constructor(host: ElementRef<HTMLElement>, validationService: BrieFormValidationService, formGroupDirective?: FormGroupDirective | undefined);
    onSubmit(): void;
    private isEnabled;
    private shouldFocusFirstError;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieShowErrorsOnSubmitDirective, [null, null, { optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BrieShowErrorsOnSubmitDirective, "form[brieShowErrorsOnSubmit]", never, { "brieShowErrorsOnSubmit": { "alias": "brieShowErrorsOnSubmit"; "required": false; }; "brieFocusFirstError": { "alias": "brieFocusFirstError"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormHiddenComponent {
    group: FormGroup;
    field: BrieFormHiddenField;
    get fieldId(): string;
    get inputId(): string;
    get control(): AbstractControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormHiddenComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieFormHiddenComponent, "brie-form-hidden", never, { "group": { "alias": "group"; "required": false; }; "field": { "alias": "field"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieFormModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieFormModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieFormModule, never, [typeof i1.BrieExpansionPanelModule, typeof i2.CommonModule, typeof i3.DragDropModule, typeof i4.FormsModule, typeof i5.MatAutocompleteModule, typeof i6.MatButtonModule, typeof i7.MatCheckboxModule, typeof i8.MatSlideToggleModule, typeof i9.MatFormFieldModule, typeof i10.MatIconModule, typeof i11.MatInputModule, typeof i12.MatSelectModule, typeof i13.MatDatepickerModule, typeof i4.ReactiveFormsModule, typeof i14.MatRadioModule, typeof i15.MatTooltipModule, typeof i16.BrieIconModule, typeof BrieFormComponent, typeof BrieFormInputComponent, typeof BrieFormLinkpickerComponent, typeof BrieFormControlComponent, typeof BrieFormSelectComponent, typeof BrieFormCheckboxComponent, typeof BrieFormToggleComponent, typeof BrieFormGroupRepeaterComponent, typeof BrieFormTextComponent, typeof BrieFormFieldsGroupComponent, typeof BrieFormRadioComponent, typeof DatetimeFieldComponent, typeof BrieFormDateTimeComponent, typeof BrieShowErrorsOnSubmitDirective, typeof BrieFormHiddenComponent], [typeof BrieFormComponent, typeof BrieShowErrorsOnSubmitDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieFormModule>;
}

export { BrieFormCheckboxComponent, BrieFormComponent, BrieFormControlComponent, BrieFormFieldType, BrieFormGroupRepeaterComponent, BrieFormHiddenComponent, BrieFormInputComponent, BrieFormInputIconPosition, BrieFormModule, BrieFormRadioComponent, BrieFormSelectComponent, BrieFormService, BrieFormToggleComponent, BrieFormValidationService, BrieShowErrorsOnSubmitDirective };
export type { BrieFormCheckboxField, BrieFormControls, BrieFormDataSource, BrieFormDateField, BrieFormDateTimeField, BrieFormField, BrieFormFieldBase, BrieFormFieldError, BrieFormFieldsGroup, BrieFormGroupRepeaterField, BrieFormGroupRepeaterValues, BrieFormHiddenField, BrieFormInputField, BrieFormInputIcon, BrieFormLinkpickerField, BrieFormRadioButton, BrieFormRadioField, BrieFormSelectField, BrieFormSelectOption, BrieFormTextField, BrieFormToggleField, BrieFormValidationOptions, BrieFormValidationResult };