import * as i0 from '@angular/core';
import { TemplateRef, AfterViewInit, OnDestroy, EventEmitter, QueryList, ElementRef, ChangeDetectorRef, OnInit, OnChanges, SimpleChanges } from '@angular/core';
import * as i2 from '@angular/common';
import * as i2$1 from '@bloomreach/brie/icon';
import { BrieIconSize as BrieIconSize$1, BrieIconType as BrieIconType$1, BrieIcon as BrieIcon$1 } from '@bloomreach/brie/icon';
import * as i6 from '@angular/material/button';
import * as i4 from '@angular/material/divider';
import * as i5 from '@angular/material/menu';
import { MatMenuTrigger } from '@angular/material/menu';
import * as i6$1 from '@angular/material/tooltip';
import { BrieFormValidationOptions as BrieFormValidationOptions$1, BrieFormValidationService as BrieFormValidationService$1 } from '@bloomreach/brie/form';
import * as i4$2 from '@angular/forms';
import { AbstractControl, ValidatorFn, UntypedFormGroup, FormGroup, AbstractControlOptions, UntypedFormArray, ControlValueAccessor, FormGroupDirective } from '@angular/forms';
import * as i5$1 from '@angular/material/dialog';
import { MatDialogConfig, MatDialogRef, MatDialog } from '@angular/material/dialog';
import { ComponentType } from '@angular/cdk/portal';
import * as i4$1 from '@angular/material/icon';
import * as i3 from '@angular/material/expansion';
import * as i1 from '@bloomreach/brie/expansion-panel';
import { BrieExpansionPanelIcon as BrieExpansionPanelIcon$1 } from '@bloomreach/brie/expansion-panel';
import * as i3$1 from '@angular/cdk/drag-drop';
import { CdkDragDrop, CdkDragMove, CdkDragStart } from '@angular/cdk/drag-drop';
import * as i5$2 from '@angular/material/autocomplete';
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 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 { Observable } from 'rxjs';
import { ErrorStateMatcher } from '@angular/material/core';
import * as i2$2 from '@bloomreach/brie/button-group';
import { BrieButtonGroupActions as BrieButtonGroupActions$1, BrieButtonType as BrieButtonType$1, BrieThemeColor as BrieThemeColor$1 } from '@bloomreach/brie/button-group';
import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
import * as i7$1 from '@angular/material/list';
import * as i5$3 from '@angular/material/snack-bar';
import { MatSnackBarHorizontalPosition, MatSnackBarVerticalPosition, MatSnackBarRef, MatSnackBar } from '@angular/material/snack-bar';
import { FlatTreeControl } from '@angular/cdk/tree';
import * as i8$1 from '@angular/material/tree';
import { MatTreeFlattener, MatTreeFlatDataSource } from '@angular/material/tree';
import { SelectionModel } from '@angular/cdk/collections';
import * as i4$3 from '@angular/material/card';

type BrieButtonGroupActions = BrieButton[][];
interface BrieButton {
    id: string;
    type: BrieButtonType;
    text?: string;
    action?: (event: MouseEvent) => void;
    icon?: {
        name: string;
        fontSet?: string;
    };
    color?: BrieThemeColor;
    isDisabled?: () => boolean;
    tooltip?: string;
    menu?: {
        id: string;
        text: string;
        action: () => void;
    }[];
    /** Form to validate. Static control or getter for lazy resolution. */
    validateForm?: AbstractControl | (() => AbstractControl | undefined);
    /** Options passed to BrieFormValidationService.showValidationErrors. */
    validateFormOptions?: BrieFormValidationOptions$1;
    /**
     * When true, run showValidationErrors before action.
     * action is called only if form.valid after validation.
     * Default: false (no validation — current behavior).
     */
    validateBeforeAction?: boolean;
}
declare enum BrieButtonType {
    Basic = "basic",
    Stroked = "stroked",
    Flat = "flat",
    Icon = "icon"
}
declare enum BrieThemeColor {
    Primary = "primary",
    Accent = "accent",
    Warn = "warn"
}

declare class BrieButtonGroupComponent {
    private readonly validationService;
    actions: BrieButtonGroupActions;
    constructor(validationService: BrieFormValidationService$1);
    get BrieIconSize(): typeof BrieIconSize$1;
    onButtonClick(button: BrieButton, event: MouseEvent, menuTrigger?: MatMenuTrigger): void;
    private resolveValidateForm;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieButtonGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieButtonGroupComponent, "brie-button-group", never, { "actions": { "alias": "actions"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieButtonGroupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieButtonGroupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieButtonGroupModule, never, [typeof i2.CommonModule, typeof i2$1.BrieIconModule, typeof i6.MatButtonModule, typeof i4.MatDividerModule, typeof i5.MatMenuModule, typeof i6$1.MatTooltipModule, typeof BrieButtonGroupComponent], [typeof BrieButtonGroupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieButtonGroupModule>;
}

declare class BrieDialogTitleComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieDialogTitleComponent, "brie-dialog-title", never, {}, {}, never, ["*"], true, never>;
}
declare class BrieDialogContentComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieDialogContentComponent, "brie-dialog-content", never, {}, {}, never, ["*"], true, never>;
}
declare class BrieDialogActionsComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogActionsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieDialogActionsComponent, "brie-dialog-actions", never, {}, {}, never, ["*"], true, never>;
}
declare class BrieDialogComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieDialogComponent, "brie-dialog", never, {}, {}, never, ["*"], true, never>;
}

declare enum BrieConfirmDialogAction {
    EXTRA = "EXTRA",
    PRIMARY = "PRIMARY",
    SECONDARY = "SECONDARY"
}
interface BrieConfirmDialogButtons {
    id: string;
    caption: string;
}
interface BrieConfirmDialogData {
    title: string;
    message: string;
    buttons: {
        primary: BrieConfirmDialogButtons;
        secondary?: BrieConfirmDialogButtons;
        extra?: BrieConfirmDialogButtons;
    };
}
type BrieDialogTemplate<T> = ComponentType<T> | TemplateRef<T>;
type BrieDialogConfig<D> = MatDialogConfig<D>;
type BrieDialogRef<T, R> = MatDialogRef<T, R>;
type BrieConfirmDialogConfig = BrieDialogConfig<BrieConfirmDialogData>;

declare class BrieConfirmDialogComponent {
    data: BrieConfirmDialogData;
    dialogRef: MatDialogRef<BrieConfirmDialogComponent>;
    constructor(data: BrieConfirmDialogData, dialogRef: MatDialogRef<BrieConfirmDialogComponent>);
    clickOnPrimary(): void;
    clickOnSecondary(): void;
    clickOnExtra(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieConfirmDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieConfirmDialogComponent, "brie-confirm-dialog", never, {}, {}, never, never, true, never>;
}
type BrieConfirmDialogRef = BrieDialogRef<BrieConfirmDialogComponent, BrieConfirmDialogAction>;

declare class BrieDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieDialogModule, never, [typeof BrieDialogComponent, typeof BrieDialogTitleComponent, typeof BrieDialogContentComponent, typeof BrieDialogActionsComponent, typeof BrieConfirmDialogComponent, typeof i2.CommonModule, typeof i4$1.MatIconModule, typeof i5$1.MatDialogModule, typeof i6.MatButtonModule], [typeof BrieDialogComponent, typeof BrieDialogTitleComponent, typeof BrieDialogContentComponent, typeof BrieDialogActionsComponent, typeof BrieConfirmDialogComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieDialogModule>;
}

declare const defaultDialogConfig: MatDialogConfig;
declare class BrieDialogService {
    private readonly dialog;
    constructor(dialog: MatDialog);
    open<T, D = any, R = any>(template: BrieDialogTemplate<T>, config?: BrieDialogConfig<D>): BrieDialogRef<T, R>;
    confirm(data: BrieConfirmDialogData, config?: BrieConfirmDialogConfig): BrieConfirmDialogRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrieDialogService>;
}

interface BrieExpansionPanelIcon {
    fontSet?: string;
    name: string;
    type: BrieIconType$1;
}

declare class BrieExpansionPanelComponent {
    icon?: BrieExpansionPanelIcon;
    title: string;
    iconSize: BrieIconSize$1;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieExpansionPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieExpansionPanelComponent, "brie-expansion-panel", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class BrieExpansionPanelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieExpansionPanelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieExpansionPanelModule, never, [typeof i2$1.BrieIconModule, typeof i2.CommonModule, typeof i3.MatExpansionModule, typeof BrieExpansionPanelComponent], [typeof BrieExpansionPanelComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieExpansionPanelModule>;
}

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$1;
    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$1;
}

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$1;
    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$1;
    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$1;
    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$1;
    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$1;
    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$1;
    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$1;
    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$1.DragDropModule, typeof i4$2.FormsModule, typeof i5$2.MatAutocompleteModule, typeof i6.MatButtonModule, typeof i7.MatCheckboxModule, typeof i8.MatSlideToggleModule, typeof i9.MatFormFieldModule, typeof i4$1.MatIconModule, typeof i11.MatInputModule, typeof i12.MatSelectModule, typeof i13.MatDatepickerModule, typeof i4$2.ReactiveFormsModule, typeof i14.MatRadioModule, typeof i6$1.MatTooltipModule, typeof i2$1.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>;
}

type BrieHeadingActions = BrieButtonGroupActions$1;
declare enum BrieHeadingSize {
    H1 = "h1",
    H2 = "h2",
    H3 = "h3"
}

declare class BrieHeadingComponent {
    actions: BrieHeadingActions;
    title: string;
    description?: string;
    size?: string;
    get headingSize(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieHeadingComponent, "brie-heading", never, { "actions": { "alias": "actions"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieHeadingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieHeadingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieHeadingModule, never, [typeof i2.CommonModule, typeof i2$2.BrieButtonGroupModule, typeof BrieHeadingComponent], [typeof BrieHeadingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieHeadingModule>;
}

declare enum BrieIconType {
    MATERIAL = "material",
    BASE64 = "base64"
}
declare enum BrieIconSize {
    XS = "xs",
    SM = "sm",
    MD = "md",
    LG = "lg",
    XL = "xl",
    XXL = "xxl"
}
interface BrieIcon {
    name: string;
    fontSet?: string;
    size?: BrieIconSize;
    type?: BrieIconType;
    tooltip?: string;
    style?: string;
}

declare class BrieIconComponent {
    private domSanitizer;
    private elementRef;
    fontSet?: string | undefined;
    name: string;
    size?: BrieIconSize | undefined;
    type?: BrieIconType | undefined;
    tooltip?: string | undefined;
    style?: string | undefined;
    private hostClasses;
    get hostCssClasses(): string;
    get BrieIconType(): typeof BrieIconType;
    constructor(domSanitizer: DomSanitizer, elementRef: ElementRef);
    getSafeIconValue(imageData: string | undefined): SafeUrl;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieIconComponent, "brie-icon", never, { "fontSet": { "alias": "fontSet"; "required": false; }; "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "type": { "alias": "type"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "style": { "alias": "style"; "required": false; }; }, {}, never, never, true, never>;
}

declare class BrieIconModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieIconModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieIconModule, never, [typeof BrieIconComponent, typeof i2.CommonModule, typeof i4$1.MatIconModule, typeof i6$1.MatTooltipModule], [typeof BrieIconComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieIconModule>;
}

interface BrieListElement<T extends string | number = string> extends BrieListDefault {
    id: T;
    title: string;
    subtitle?: string;
    children?: BrieListElement<T>[];
}
interface BrieListDefault {
    icon?: {
        name: string;
        fontSet?: string;
        type?: BrieIconType$1;
        size?: BrieIconSize$1;
    };
    draggable?: boolean;
    multiline?: boolean;
    actions?: BrieListAction[];
}
interface BrieListAction {
    id: string;
    type?: BrieButtonType$1;
    text?: string;
    color?: BrieThemeColor$1;
    tooltip?: string;
    icon?: {
        name: string;
        fontSet?: string;
    };
}
interface BrieListConfig {
    default: BrieListDefault;
}
interface BrieListClickEvent {
    event: MouseEvent;
    listElement: BrieListElement<any>;
    listAction?: BrieListAction;
}

declare class BrieListComponent implements OnChanges {
    dataSource: BrieListElement<string | number>[];
    config: BrieListConfig;
    selectedElement?: BrieListElement<string | number> | null;
    clickedAction: EventEmitter<BrieListClickEvent>;
    selectedElementChange: EventEmitter<BrieListElement<any>>;
    dropListDropped: EventEmitter<BrieListElement<any>[]>;
    actions: BrieButtonGroupActions$1[];
    ngOnChanges(changes: SimpleChanges): void;
    onElementClick(event: MouseEvent, listElement: BrieListElement<any>): void;
    drop($event: CdkDragDrop<BrieListElement<any>>): void;
    isMultiline(listElement: BrieListElement<string | number>): boolean;
    isSelected(listElement: BrieListElement<string | number>): boolean;
    isDragDisabled(listElement: BrieListElement<string | number>): boolean;
    getIconSize(listElement: BrieListElement<string | number>): BrieIconSize$1 | undefined;
    getActions(listElement: BrieListElement<string | number>): BrieButtonGroupActions$1;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieListComponent, "brie-list", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "config": { "alias": "config"; "required": false; }; "selectedElement": { "alias": "selectedElement"; "required": false; }; }, { "clickedAction": "clickedAction"; "selectedElementChange": "selectedElementChange"; "dropListDropped": "dropListDropped"; }, never, never, true, never>;
}

declare class BrieListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieListModule, never, [typeof BrieListComponent, typeof i2$2.BrieButtonGroupModule, typeof i2$1.BrieIconModule, typeof i2.CommonModule, typeof i3$1.DragDropModule, typeof i4.MatDividerModule, typeof i7$1.MatListModule], [typeof BrieListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieListModule>;
}

interface BrieSnackBar {
    dismiss?: boolean;
    message: string;
    warning?: boolean;
}
interface BrieSnackBarConfig {
    duration?: number;
    warning?: boolean;
    dismiss?: boolean;
    horizontalPosition?: MatSnackBarHorizontalPosition;
    verticalPosition?: MatSnackBarVerticalPosition;
}

declare class BrieSnackBarComponent {
    snackBarRef: MatSnackBarRef<BrieSnackBarComponent>;
    data: BrieSnackBar;
    warningClass: boolean;
    constructor(snackBarRef: MatSnackBarRef<BrieSnackBarComponent>, data: BrieSnackBar);
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieSnackBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieSnackBarComponent, "brie-snackbar", never, {}, {}, never, never, true, never>;
}

declare class BrieSnackBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieSnackBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieSnackBarModule, never, [typeof BrieSnackBarComponent, typeof i2.CommonModule, typeof i6.MatButtonModule, typeof i4$1.MatIconModule, typeof i5$3.MatSnackBarModule], [typeof BrieSnackBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieSnackBarModule>;
}

declare class BrieSnackBarService {
    private readonly snackBar;
    constructor(snackBar: MatSnackBar);
    open(message: string, config?: BrieSnackBarConfig): void;
    warning(message: string, config?: BrieSnackBarConfig): void;
    dismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieSnackBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<BrieSnackBarService>;
}

interface BrieTreeSubMenuItem {
    id: string;
    title: string;
}
interface BrieTreeDefaultConfig {
    draggable?: boolean;
    subMenu?: BrieTreeSubMenuItem[];
    actions?: BrieTreeAction[];
    expandAll?: boolean;
    dragAboveRoot?: boolean;
}
interface BrieTreeConfig {
    defaults: BrieTreeDefaultConfig;
}
interface BrieTreeNode<T = any> extends BrieTreeDefaultConfig {
    id?: string;
    title: string;
    subTitle?: string;
    children?: BrieTreeNode<T>[];
    data?: T;
}
interface BrieTreeAction {
    id: string;
    icon: {
        name: string;
        fontSet?: string;
    };
    tooltip?: string;
}
interface BrieTreeNodeClick {
    event: MouseEvent;
    treeNode: BrieTreeNode;
}
interface BrieTreeSubMenuClick extends BrieTreeNodeClick {
    subMenuItem: BrieTreeSubMenuItem;
}
interface BrieTreeActionClick extends BrieTreeNodeClick {
    actionItem: BrieTreeAction;
}
interface BrieTreeFlatNode {
    expandable: boolean;
    title: string;
    subTitle: string;
    level: number;
    subMenu: BrieTreeSubMenuItem[];
    id: string;
    draggable: boolean;
    actions: BrieTreeAction[];
}
interface BrieTreeUpdated {
    event: BrieTreeNodeEvent;
    nodes: BrieTreeNode[];
}
declare enum BrieTreeNodeEvent {
    MOVED = "MOVED",
    ADDED = "ADDED",
    EDITED = "EDITED",
    DELETED = "DELETED",
    PASTED = "PASTED"
}

declare class BrieTreeComponent implements OnChanges, OnInit, OnDestroy {
    private document;
    dataSource: BrieTreeNode[];
    config: BrieTreeConfig;
    selectedNode: BrieTreeNode | null;
    clickedSubMenu: EventEmitter<BrieTreeSubMenuClick>;
    clickedAction: EventEmitter<BrieTreeActionClick>;
    clickedNode: EventEmitter<BrieTreeNodeClick>;
    treeUpdated: EventEmitter<BrieTreeUpdated>;
    treeElRef: ElementRef<HTMLElement>;
    dropActionTodo: {
        targetId: string | null;
        action?: string;
    } | null;
    dragOverNode: BrieTreeFlatNode;
    dragOverArea: string;
    rootId: string | undefined;
    flatNodeMap: Map<string, BrieTreeNode<any>>;
    brieTreeNodeMap: Map<string, BrieTreeFlatNode>;
    draggedNodeExpanded: boolean;
    processDragging: boolean;
    treeControl: FlatTreeControl<BrieTreeFlatNode>;
    treeFlattener: MatTreeFlattener<BrieTreeNode, BrieTreeFlatNode>;
    flatDataSource: MatTreeFlatDataSource<BrieTreeNode, BrieTreeFlatNode>;
    expansionModel: SelectionModel<string>;
    private subject;
    private readonly unsubscribe;
    constructor(document: Document);
    generateId(node: BrieTreeNode): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    onDragMove(event: CdkDragMove): void;
    ngOnChanges(): void;
    isDraggable(overrideValue: boolean | undefined): boolean;
    private _transformer;
    onDragIconClick(event: MouseEvent): void;
    onMenuIconClick(event: MouseEvent): void;
    addNewNode(parent: BrieTreeNode, node: BrieTreeNode): void;
    editNode(node: BrieTreeNode): void;
    deleteNode(node: BrieTreeNode): void;
    pasteNode(parent: BrieTreeNode, node: BrieTreeNode): void;
    hasChild(_: number, node: BrieTreeFlatNode): boolean;
    onNodeClick(event: MouseEvent, node: BrieTreeFlatNode): void;
    onMenuItemClick(event: MouseEvent, node: BrieTreeFlatNode, subMenuItem: BrieTreeSubMenuItem): void;
    onActionItemClick(event: MouseEvent, node: BrieTreeFlatNode, actionItem: BrieTreeAction): void;
    dragMoved(event: CdkDragMove): void;
    dragStarted(event: CdkDragStart): void;
    processDrop(draggedNodeId: string): void;
    getParentNodeId(id: string, nodes: BrieTreeNode[], parentId: string): string;
    clearDragInfo(dropped?: boolean): void;
    showDragInfo(event: CdkDragMove, draggedNode: BrieTreeFlatNode): void;
    drop(event: CdkDragDrop<BrieTreeNode[]>): void;
    rebuildTreeForData(data: BrieTreeNode[]): void;
    getUniqueId(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieTreeComponent, "brie-tree", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "config": { "alias": "config"; "required": false; }; "selectedNode": { "alias": "selectedNode"; "required": false; }; }, { "clickedSubMenu": "clickedSubMenu"; "clickedAction": "clickedAction"; "clickedNode": "clickedNode"; "treeUpdated": "treeUpdated"; }, never, never, true, never>;
}

declare class BrieTreeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieTreeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieTreeModule, never, [typeof BrieTreeComponent, typeof i2.CommonModule, typeof i3$1.DragDropModule, typeof i6.MatButtonModule, typeof i4$1.MatIconModule, typeof i5.MatMenuModule, typeof i6$1.MatTooltipModule, typeof i8$1.MatTreeModule], [typeof BrieTreeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieTreeModule>;
}

declare enum BrieCardType {
    DEFAULT = "default",
    INFO = "info",
    WARNING = "warning",
    ERROR = "error"
}

declare class BrieCardHeaderDirective {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieCardHeaderDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BrieCardHeaderDirective, "[brieCardHeader]", never, {}, {}, never, never, true, never>;
}

declare class BrieCardComponent {
    title: i0.InputSignal<string | undefined>;
    subtitle: i0.InputSignal<string | undefined>;
    content: i0.InputSignal<string | undefined>;
    actions: i0.InputSignal<BrieButtonGroupActions$1 | undefined>;
    image: i0.InputSignal<string | undefined>;
    imageAlt: i0.InputSignal<string | undefined>;
    disabled: i0.InputSignal<boolean>;
    clickable: i0.InputSignal<boolean>;
    type: i0.InputSignal<BrieCardType>;
    cardClick: i0.OutputEmitterRef<void>;
    customHeader: i0.Signal<BrieCardHeaderDirective | undefined>;
    get hasCustomHeader(): boolean;
    readonly BrieCardType: typeof BrieCardType;
    onCardClick(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BrieCardComponent, "brie-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "actions": { "alias": "actions"; "required": false; "isSignal": true; }; "image": { "alias": "image"; "required": false; "isSignal": true; }; "imageAlt": { "alias": "imageAlt"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, { "cardClick": "cardClick"; }, ["customHeader"], ["[brieCardHeader]", "*"], true, never>;
}

declare class BrieCardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<BrieCardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<BrieCardModule, never, [typeof BrieCardComponent, typeof BrieCardHeaderDirective, typeof i2.CommonModule, typeof i4$3.MatCardModule, typeof i6.MatButtonModule], [typeof BrieCardComponent, typeof BrieCardHeaderDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<BrieCardModule>;
}

export { BrieButtonGroupComponent, BrieButtonGroupModule, BrieButtonType, BrieCardComponent, BrieCardHeaderDirective, BrieCardModule, BrieCardType, BrieConfirmDialogAction, BrieConfirmDialogComponent, BrieDialogActionsComponent, BrieDialogComponent, BrieDialogContentComponent, BrieDialogModule, BrieDialogService, BrieDialogTitleComponent, BrieExpansionPanelComponent, BrieExpansionPanelModule, BrieFormCheckboxComponent, BrieFormComponent, BrieFormControlComponent, BrieFormFieldType, BrieFormGroupRepeaterComponent, BrieFormHiddenComponent, BrieFormInputComponent, BrieFormInputIconPosition, BrieFormModule, BrieFormRadioComponent, BrieFormSelectComponent, BrieFormService, BrieFormToggleComponent, BrieFormValidationService, BrieHeadingComponent, BrieHeadingModule, BrieHeadingSize, BrieIconComponent, BrieIconModule, BrieIconSize, BrieIconType, BrieListComponent, BrieListModule, BrieShowErrorsOnSubmitDirective, BrieSnackBarComponent, BrieSnackBarModule, BrieSnackBarService, BrieThemeColor, BrieTreeComponent, BrieTreeModule, BrieTreeNodeEvent, defaultDialogConfig };
export type { BrieButton, BrieButtonGroupActions, BrieConfirmDialogButtons, BrieConfirmDialogConfig, BrieConfirmDialogData, BrieConfirmDialogRef, BrieDialogConfig, BrieDialogRef, BrieDialogTemplate, BrieExpansionPanelIcon, BrieFormCheckboxField, BrieFormControls, BrieFormDataSource, BrieFormDateField, BrieFormDateTimeField, BrieFormField, BrieFormFieldBase, BrieFormFieldError, BrieFormFieldsGroup, BrieFormGroupRepeaterField, BrieFormGroupRepeaterValues, BrieFormHiddenField, BrieFormInputField, BrieFormInputIcon, BrieFormLinkpickerField, BrieFormRadioButton, BrieFormRadioField, BrieFormSelectField, BrieFormSelectOption, BrieFormTextField, BrieFormToggleField, BrieFormValidationOptions, BrieFormValidationResult, BrieHeadingActions, BrieIcon, BrieListAction, BrieListClickEvent, BrieListConfig, BrieListDefault, BrieListElement, BrieSnackBar, BrieSnackBarConfig, BrieTreeAction, BrieTreeActionClick, BrieTreeConfig, BrieTreeDefaultConfig, BrieTreeFlatNode, BrieTreeNode, BrieTreeNodeClick, BrieTreeSubMenuClick, BrieTreeSubMenuItem, BrieTreeUpdated };