import * as i0 from '@angular/core';
import { Type, Injector, QueryList, ChangeDetectorRef, AfterViewInit, TemplateRef, Provider, EventEmitter, OnDestroy, DestroyRef } from '@angular/core';
import { DialogService, DialogRef } from '@fundamental-ngx/core/dialog';
import { InputType, BaseDynamicFormGeneratorControl, FormGeneratorService, PreparedDynamicFormFieldItem, DynamicFormControl, FormGeneratorComponent, DynamicFormItem, FdpSelectionChangeEvent, DynamicFormFieldItem, DynamicFormItemGuiOptions } from '@fundamental-ngx/platform/form';
import { SelectItem, PresetManagedComponent } from '@fundamental-ngx/platform/shared';
import { FilterStrategy, FilterableColumnDataType, FilterAllStrategy, CollectionFilterGroup, FilterType, CollectionFilterGroupStrategy, CollectionFilterAndGroup, Resettable, Table, TableDataSource, TableRowSelectionChangeEvent, TableState, FILTER_STRATEGY } from '@fundamental-ngx/platform/table';
import { Observable, BehaviorSubject } from 'rxjs';
import { FdLanguage } from '@fundamental-ngx/i18n';
import { SearchInput } from '@fundamental-ngx/platform/search-field';
import { Nullable } from '@fundamental-ngx/cdk/utils';

interface SmartFilterBarConditionBuilder {
    /**
     * Header of the dialog window.
     */
    header: string;
    /**
     * Filter data type.
     */
    dataType: FilterableColumnDataType;
    /**
     * Applied conditions for the filter.
     */
    conditions: SmartFilterBarCondition[];
    /**
     * Filter type.
     */
    filterType: string;
    /**
     * Available options for filtering.
     */
    choices: SelectItem[];
    /**
     * Input type.
     */
    controlType: InputType;
}
interface SmartFilterBarCondition<T = any> {
    /**
     * Filter value.
     */
    value: T;
    /**
     * Range filter value.
     */
    value2?: T;
    /**
     * Condition type.
     */
    operator: FilterStrategy;
    /**
     * Human-readable value to be displayed in smart filter bar.
     */
    displayValue?: string;
}

interface SmartFilterBarCustomFilterConfig {
    /**
     * Component to be used to render the control in conditions dialog.
     */
    conditionComponent?: Type<BaseDynamicFormGeneratorControl>;
    /**
     * Component to be used to render the condition in smart filter bar.
     */
    rendererComponent?: Type<BaseDynamicFormGeneratorControl>;
    /**
     * Available filtering strategies.
     */
    filterStrategies?: FilterAllStrategy[];
    /**
     * Transforms raw filter item value.
     * @param value raw filter item value.
     * @returns updated filter item value to be used in the filters value hash.
     */
    valueTransformer?: (value: any) => SelectItem<SmartFilterBarCondition>[] | any[] | undefined;
    /**
     * Transforms filter raw value so it could be rendered in renderer component.
     * @param condition Generated condition rule.
     * @returns string which will be used in renderer component.
     */
    valueRenderer?: (condition: SmartFilterBarCondition) => string | Promise<string> | Observable<string>;
    /**
     * Filter type.
     */
    types: string[];
    /**
     * Additional data that can be used later in the component.
     */
    additionalData?: {
        [key: string]: any;
    };
}

declare class SmartFilterBarService {
    private _fgService;
    /** @hidden */
    private _customFilterConditions;
    /** @hidden */
    constructor(_fgService: FormGeneratorService);
    /**
     * Adds custom filter type to the smart filter bar.
     * @param options Configuration options.
     * @returns true if component was added successfully.
     */
    addCustomFilter(options: SmartFilterBarCustomFilterConfig): boolean;
    /**
     * Returns provided configuration object of the custom filter.
     * @param type Filter type.
     * @returns Configuration object.
     */
    getCustomFilterConfiguration(type: string): SmartFilterBarCustomFilterConfig | undefined;
    /**
     * Returns applicable condition options of the filter.
     * @param type Filter type.
     * @param dataType Filter data type.
     * @returns Array of applicable condition options.
     */
    getApplicableFilterConditions(type: string, dataType?: FilterableColumnDataType): FilterAllStrategy[];
    /** @hidden */
    getDisplayValue(condition: SmartFilterBarCondition, filterType: string): Promise<string>;
    /**
     * Method for normalizing generated conditions to display in human-readable format.
     * @returns Formatted array of conditions.
     * @param formItem
     * @param conditions
     */
    normalizeConditions(formItem: PreparedDynamicFormFieldItem, conditions: SmartFilterBarCondition[]): Promise<SmartFilterBarCondition[]>;
    /**
     * Returns formatted condition variants.
     */
    getConditionFieldSelectedVariants(formItem: PreparedDynamicFormFieldItem, conditions: SmartFilterBarCondition[]): Promise<SelectItem[]>;
    /**
     * Transforms collection filter into smart filter bar condition.
     */
    transformCollectionFilter(filterGroup: CollectionFilterGroup): SmartFilterBarCondition[];
    /**
     * @hidden
     * Normalizes condition value.
     * @param value
     * @returns
     */
    private _normalizeValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SmartFilterBarService>;
}

declare abstract class BaseSmartFilterBarConditionField extends BaseDynamicFormGeneratorControl {
    protected readonly _dialogService: DialogService;
    protected readonly _smartFilterBarService: SmartFilterBarService;
    protected readonly _injector: Injector;
    /**
     * Method for opening conditions configuration dialog.
     */
    openConditionsDialog: () => void;
    /**
     * Method for retrieving current form control of the generated form.
     * @returns Found form control.
     */
    getField(): DynamicFormControl;
    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSmartFilterBarConditionField, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseSmartFilterBarConditionField, never, never, {}, {}, never, never, true, never>;
}

declare class SmartFilterBarConditionFieldComponent extends BaseSmartFilterBarConditionField {
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarConditionFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SmartFilterBarConditionFieldComponent, "fdp-smart-filter-bar-condition-field", never, {}, {}, never, never, true, never>;
}

declare class SmartFilterBarConditionsDialogComponent {
    private _dialogRef;
    private readonly _cdr;
    private _smartFilterBarService;
    /**
     * Generated condition forms.
     */
    formGenerators: QueryList<FormGeneratorComponent>;
    /** Condition builder config. */
    config: SmartFilterBarConditionBuilder;
    /** Available condition operator options. */
    conditionOperatorOptions: SelectItem[];
    /** @hidden */
    _formItems: DynamicFormItem[][];
    /** @hidden */
    loaded: boolean;
    /** @hidden */
    private readonly _conditionLabelKeys;
    /** @hidden */
    private _submittedForms;
    /** @hidden */
    private resolveTranslation;
    /** @hidden */
    constructor(_dialogRef: DialogRef<SmartFilterBarConditionBuilder, SmartFilterBarCondition[]>, _cdr: ChangeDetectorRef, _smartFilterBarService: SmartFilterBarService);
    /**
     * Adds empty condition.
     */
    addCondition(): void;
    /**
     * Removes condition at defined index
     * @param index Index of the condition in the array.
     */
    removeCondition(index: number): void;
    /**
     * Submits all condition forms.
     */
    applyConditions(): void;
    /**
     * @hidden
     * Callback function when form generator form has been submitted.
     * Will close dialog in case if all forms are valid.
     * @param form Form generator form value.
     */
    _onFormSubmitted(form: SmartFilterBarCondition): void;
    /** @hidden */
    _cancel(): void;
    /** @hidden */
    private _init;
    /**
     * @hidden
     * Returns applicable condition options of the filter.
     * @returns Array of applicable condition options.
     */
    private _getApplicableConditionOperators;
    /**
     * Transforms filter conditions into form generator form items array.
     * @param conditions existing smart filter bar filter conditions.
     */
    private _addExistingConditions;
    /** @hidden */
    private _generateFormGeneratorItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarConditionsDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SmartFilterBarConditionsDialogComponent, "fdp-smart-filter-bar-conditions-dialog", never, {}, {}, never, never, true, never>;
}

interface FieldFilterItem {
    label: string;
    active: boolean;
    mandatory: boolean;
    visible: boolean;
    key: string;
    name: string;
}

interface SmartFilterBarFieldDefinition {
    key: string;
    name: string;
    label: string;
    filterType: FilterType;
    dataType: FilterableColumnDataType;
    filterable: boolean;
    required: boolean;
    customFilterType?: string;
    defaultSelected: boolean;
    hasOptions: boolean;
    conditionStrategy: CollectionFilterGroupStrategy;
}

interface SmartFilterSettingsDialogConfig {
    /**
     * Available fields.
     */
    fields: SmartFilterBarFieldDefinition[];
    /**
     * Applied filters.
     */
    filterBy: CollectionFilterAndGroup[];
    /**
     * Selected filters.
     */
    selectedFilters: string[];
}

declare class SmartFilterBarSettingsDialogComponent implements Resettable, AfterViewInit {
    private _dialogRef;
    private readonly _language$;
    private readonly _cdr;
    /**
     * Table instance
     */
    table: Table;
    /**
     * Table data source.
     */
    source: TableDataSource<FieldFilterItem>;
    /** @hidden */
    _availableFields: FieldFilterItem[];
    /** @hidden */
    _filterVisibilityOptions: SelectItem[];
    /** @hidden */
    loaded: boolean;
    /** Indicates when reset command is available */
    readonly isResetAvailable$: i0.WritableSignal<boolean>;
    /** @hidden */
    private readonly _categoryLabelKeys;
    /** @hidden */
    private _sourceSubscription;
    /** @hidden */
    private _selectedFilters;
    /**
     * @hidden
     * An RxJS Subject that will kill the data stream upon component’s destruction (for unsubscribing)
     */
    private readonly _destroyRef;
    /** @hidden */
    private readonly _translationResolver;
    /** @hidden */
    constructor(_dialogRef: DialogRef<SmartFilterSettingsDialogConfig, string[]>, _language$: Observable<FdLanguage>, _cdr: ChangeDetectorRef);
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * Checks the checkbox in the table row if the field is selected.
     */
    setSelectedFilters(): void;
    /**
     * Resets filters selection.
     */
    reset(): void;
    /**
     * Sets initial state of the table.
     */
    setInitialTableState(): void;
    /** @hidden */
    _cancel(): void;
    /** @hidden */
    _confirm(): void;
    /** @hidden */
    _onRowSelectionChange(event: TableRowSelectionChangeEvent<FieldFilterItem>): void;
    /** @hidden */
    _onFilterVisibilityChange(event: FdpSelectionChangeEvent): void;
    /** @hidden */
    private _init;
    /**
     * Transforms visibility options into appropriate select item object.
     */
    private _transformVisibilityLabels;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarSettingsDialogComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SmartFilterBarSettingsDialogComponent, "fdp-smart-filter-bar-settings-dialog", never, {}, {}, never, never, true, never>;
}

declare const SMART_FILTER_BAR_RENDERER_COMPONENT = "smart-filter-condition-renderer";

declare class SmartFilterBarFieldDefinitionDirective {
    /** Field data accessor key. */
    key: string;
    /** Unique field identifier. */
    name: string;
    /** Field label. */
    label: string;
    /** Field filter type */
    filterType: FilterType;
    /** Field data type */
    dataType: FilterableColumnDataType;
    /** Field custom filter type */
    customFilterType: string;
    /** Condition strategy */
    conditionStrategy: CollectionFilterGroupStrategy;
    /** Whether this field can be filtered. Default value is true. */
    smartFilterBarFilterable: boolean;
    /** Whether this field filter is mandatory. */
    required: boolean;
    /** Whether this field filter is selected by default. */
    defaultSelected: boolean;
    /** Whether this field has autocomplete options */
    hasOptions: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarFieldDefinitionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SmartFilterBarFieldDefinitionDirective, "[fdpSmartFilterBarFieldDefinition], [fdp-smart-filter-bar-field-definition]", never, { "key": { "alias": "key"; "required": false; }; "name": { "alias": "name"; "required": false; }; "label": { "alias": "label"; "required": false; }; "filterType": { "alias": "filterType"; "required": false; }; "dataType": { "alias": "dataType"; "required": false; }; "customFilterType": { "alias": "customFilterType"; "required": false; }; "conditionStrategy": { "alias": "conditionStrategy"; "required": false; }; "smartFilterBarFilterable": { "alias": "smartFilterBarFilterable"; "required": false; }; "required": { "alias": "required"; "required": false; }; "defaultSelected": { "alias": "defaultSelected"; "required": false; }; "hasOptions": { "alias": "hasOptions"; "required": false; }; }, {}, never, never, true, never>;
    static ngAcceptInputType_smartFilterBarFilterable: unknown;
    static ngAcceptInputType_required: unknown;
    static ngAcceptInputType_defaultSelected: unknown;
    static ngAcceptInputType_hasOptions: unknown;
}

declare class SmartFilterBarSubjectDirective implements AfterViewInit {
    private _subject;
    /** @hidden */
    _fieldDefinitions: QueryList<SmartFilterBarFieldDefinitionDirective>;
    /** @hidden */
    _fieldDefinitionsSubject: BehaviorSubject<SmartFilterBarFieldDefinition[]>;
    /**
     * Observable of available fields.
     */
    readonly fieldsStream: Observable<SmartFilterBarFieldDefinition[]>;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    constructor(_subject: Table);
    /** @hidden */
    ngAfterViewInit(): void;
    /**
     * Retrieves data source of the subject.
     * @returns Subject's data source.
     */
    getDataSource(): TableDataSource<any>;
    /**
     * Retrieves available fields of the subject.
     * @returns Available fields of the subject.
     */
    getSubjectFields(): SmartFilterBarFieldDefinition[];
    /** Get available field variants */
    getFieldVariants(field: string): Observable<SelectItem[]>;
    /** @hidden */
    getDefaultFields(): string[];
    /** Get subject state */
    getState(): TableState;
    /**
     * @returns Subject component.
     */
    getSubject(): Table;
    /** @hidden */
    private _transformSubjectField;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarSubjectDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SmartFilterBarSubjectDirective, "[fdpSmartFilterBarSubject], [fdp-smart-filter-bar-subject]", ["fdp-smart-filter-bar-subject"], {}, {}, ["_fieldDefinitions"], never, true, never>;
}

declare class SmartFilterBarToolbarItemDirective {
    templateRef: TemplateRef<any>;
    /** @hidden */
    constructor(templateRef: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarToolbarItemDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SmartFilterBarToolbarItemDirective, "[fdpSmartFilterBarToolbarItem]", never, {}, {}, never, never, true, never>;
}

interface SmartFilterBarManagedPreset {
    search?: SearchInput;
    filterBy?: CollectionFilterGroup[];
}
interface SmartFilterChangeObject extends SmartFilterBarManagedPreset {
    subject: SmartFilterBarSubjectDirective;
}

type SmartFilterBarVisibilityCategory = 'all' | 'visible' | 'active' | 'visibleAndActive' | 'mandatory';
type SmartFilterBarCategoryLabelI18nKey = {
    [Key in keyof FdLanguage['platformSmartFilterBar']]: Key extends `settingsCategory${Capitalize<SmartFilterBarVisibilityCategory>}` ? Key : never;
};
type SmartFilterBarVisibilityCategoryLabels = {
    [key in SmartFilterBarVisibilityCategory]: SmartFilterBarCategoryLabelI18nKey[`settingsCategory${Capitalize<key>}`];
};

type SmartFilterBarDynamicFormFieldItem = DynamicFormFieldItem<{
    guiOptions: SmartFilterBarDynamicFormFieldGuiOptions;
}>;
interface SmartFilterBarDynamicFormFieldGuiOptions extends DynamicFormItemGuiOptions {
    additionalData: {
        /** Additional config properties. */
        [key: string]: any;
        type: string;
        dataType: FilterableColumnDataType;
        filterType: FilterType;
        controlType: InputType;
        choices?: () => Observable<SelectItem[]> | SelectItem[];
    };
}

type SmartFilterBarStrategy = (typeof FILTER_STRATEGY)[keyof typeof FILTER_STRATEGY];
type SmartFilterBarStrategyLabelI18nKey = {
    [Key in keyof FdLanguage['platformSmartFilterBar']]: Key extends `filterCondition${Capitalize<SmartFilterBarStrategy>}` ? Key : never;
};
type SmartFilterBarStrategyLabels = {
    [key in SmartFilterBarStrategy]: SmartFilterBarStrategyLabelI18nKey[`filterCondition${Capitalize<key>}`];
};

declare const smartFilterBarProvider: Provider;

declare abstract class SmartFilterBar implements PresetManagedComponent<SmartFilterBarManagedPreset> {
    abstract search: SearchInput | undefined;
    /** @hidden */
    abstract getDisplayValue(condition: SmartFilterBarCondition, filterType: string): Promise<string>;
    /** Method for setting predefined configuration preset. */
    abstract setPreset(data: SmartFilterBarManagedPreset): void;
    /** Returns current preset configuration. */
    abstract getCurrentPreset(): SmartFilterBarManagedPreset;
    abstract getFormattedConditions(): Promise<CollectionFilterGroup[]>;
    /** Component name used in Preset managed component. */
    name: string;
    /** Event emitted when smart filter bar configuration has been changed. */
    presetChanged: EventEmitter<SmartFilterBarManagedPreset>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBar, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SmartFilterBar, never, never, { "name": { "alias": "name"; "required": false; }; }, { "presetChanged": "presetChanged"; }, never, never, true, never>;
}

declare class SmartFilterBarComponent extends SmartFilterBar implements AfterViewInit, OnDestroy {
    private _dialogService;
    private _fgService;
    private _injector;
    private readonly _destroyRef;
    /**
     * @hidden
     * Form generator component instance.
     */
    _formGenerator: FormGeneratorComponent;
    /**
     * Subject which will provide configuration data: data source, columns definitions, etc.
     */
    set subject(value: SmartFilterBarSubjectDirective);
    get subject(): SmartFilterBarSubjectDirective;
    /**
     * Whether smart filter bar background should be transparent.
     */
    transparent: boolean;
    /**
     * Columns layout.
     */
    filtersColumnLayout: Nullable<string>;
    /**
     * Whether to update filters when they are selected. Otherwise, filters will be applied only by pressing "Go" button.
     */
    liveUpdate: boolean;
    /**
     * Whether to hide Toolbar.
     */
    hideToolbar: boolean;
    /**
     * Event emitted when the selected filters have been changed.
     */
    smartFiltersChanged: EventEmitter<SmartFilterChangeObject>;
    /**
     * Event emitted when selected filters has been applied (User clicked on Go button).
     */
    smartFiltersApplied: EventEmitter<SmartFilterChangeObject>;
    /**
     * Event emitted when search input field value has been changed.
     */
    searchInputChanged: EventEmitter<SearchInput>;
    /** @hidden */
    private readonly _toolbarItemRefs;
    /**
     * Calculated array of filters to apply for the subject's data source.
     */
    filterBy: CollectionFilterGroup[];
    /** Whether the filters section should be shown. */
    showFilterBar$: i0.WritableSignal<boolean>;
    /**
     * Search field value to apply for the subject's data source.
     */
    search: SearchInput | undefined;
    /** @Hidden */
    _toolbarItems: TemplateRef<any>[];
    /** @hidden */
    _formItems: i0.WritableSignal<DynamicFormItem[] | null>;
    /** Selected filters. */
    selectedFilters$: i0.WritableSignal<string[]>;
    /** Selected filters count. */
    selectedFiltersCount$: i0.Signal<number>;
    /** Loading state. */
    get loading(): boolean;
    /** @hidden */
    private _subscriptions;
    /** @hidden */
    private _subjectSubscriptions;
    /** @hidden */
    private readonly _formGeneratorReady;
    /** @hidden */
    private _ignorePresetChange;
    /** @hidden */
    private _subject;
    /** @hidden */
    private _refresh$;
    /**
     * @hidden
     * Smart filter bar service may be provided by parent component that adds custom configuration, so we need to check if it's provided.
     */
    private readonly _smartFilterBarService;
    /** @hidden */
    constructor(_dialogService: DialogService, _fgService: FormGeneratorService, _injector: Injector, _destroyRef: DestroyRef);
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden */
    ngOnDestroy(): void;
    /**
     * Transforms condition value into human-readable text.
     * @param condition Smart filter bar condition.
     * @param filterType Condition filter type.
     */
    getDisplayValue(condition: SmartFilterBarCondition, filterType: string): Promise<string>;
    /** Open Filtering Settings Dialog */
    showFilteringSettings(): void;
    /** Callback function when search query changed. */
    onSearchInputChange(event: SearchInput): void;
    /** Clear search query. */
    cancelSearch(): void;
    /**
     * Submits filters and search form.
     */
    submitForm(): void;
    /** Method for setting predefined configuration. */
    setPreset(data: SmartFilterBarManagedPreset): Promise<void>;
    /** Returns current preset configuration. */
    getCurrentPreset(): SmartFilterBarManagedPreset;
    /**
     * @hidden
     * Callback function when form generator form has been successfully validated and submitted.
     */
    _onFormSubmitted(event: any): void;
    /**
     * @hidden
     * Callback method when form has been created.
     * Populates selected filters array with user-defined default filters.
     */
    _onFormCreated(): void;
    /**
     * Toggles Smart Filter Bar filters section.
     */
    toggleFilterBar(): void;
    /**
     * Formats raw filters object into array of grouped filters.
     * @returns Array of grouped filters.
     */
    getFormattedConditions(): Promise<CollectionFilterGroup[]>;
    /** @hidden */
    private _generateCollectionFilterGroups;
    /** @hidden */
    private _setSubject;
    /** @hidden */
    private unsubscribeFromSubject;
    /** @hidden */
    private _listenToSubjectColumns;
    /**
     * @hidden
     * Generates form items to be consumed by form generator component.
     * @param columns columns definition
     */
    private _generateForm;
    /** @hidden */
    private _generateCustomFilterFieldItem;
    /**
     * @hidden
     * Generates form item based on data type.
     * @param column
     * @param item
     * @returns
     */
    private _generateInputFieldItem;
    /**
     * @hidden
     * Generates base form item object to be consumed by form generator component.
     * @param column column definition
     * @returns base form item object.
     */
    private _generateBaseFieldItem;
    /**
     * @hidden
     * Retrieves available options for particular column by using data source method.
     * @param column property name of the data source items.
     * @returns {Observable<SelectItem[]>} Observable with the array of available options.
     */
    private _getFilterAvailableOptions;
    /** @hidden */
    private _getFilterDefaultOptions;
    /** @hidden */
    private _getFieldVariants;
    /** @hidden */
    private _getSubjectDefinitions;
    /**
     * @hidden
     * Sets provided filters directly to the data source.
     * @param filters array of filters.
     */
    private _applyFiltering;
    /** @hidden */
    private _unsubscribeFromSubject;
    /** @hidden */
    private _setSelectedFilters;
    static ɵfac: i0.ɵɵFactoryDeclaration<SmartFilterBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SmartFilterBarComponent, "fdp-smart-filter-bar", never, { "subject": { "alias": "subject"; "required": false; }; "transparent": { "alias": "transparent"; "required": false; }; "filtersColumnLayout": { "alias": "filtersColumnLayout"; "required": false; }; "liveUpdate": { "alias": "liveUpdate"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; }, { "smartFiltersChanged": "smartFiltersChanged"; "smartFiltersApplied": "smartFiltersApplied"; "searchInputChanged": "searchInputChanged"; }, ["_toolbarItemRefs"], never, true, never>;
    static ngAcceptInputType_transparent: unknown;
    static ngAcceptInputType_liveUpdate: unknown;
    static ngAcceptInputType_hideToolbar: unknown;
}

declare class PlatformSmartFilterBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformSmartFilterBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformSmartFilterBarModule, never, [typeof SmartFilterBarComponent, typeof SmartFilterBarSettingsDialogComponent, typeof SmartFilterBarFieldDefinitionDirective, typeof SmartFilterBarSubjectDirective, typeof SmartFilterBarConditionsDialogComponent, typeof SmartFilterBarConditionFieldComponent, typeof SmartFilterBarToolbarItemDirective], [typeof SmartFilterBarComponent, typeof SmartFilterBarSettingsDialogComponent, typeof SmartFilterBarFieldDefinitionDirective, typeof SmartFilterBarSubjectDirective, typeof SmartFilterBarConditionsDialogComponent, typeof SmartFilterBarConditionFieldComponent, typeof SmartFilterBarToolbarItemDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformSmartFilterBarModule>;
}

export { BaseSmartFilterBarConditionField, PlatformSmartFilterBarModule, SMART_FILTER_BAR_RENDERER_COMPONENT, SmartFilterBar, SmartFilterBarComponent, SmartFilterBarConditionFieldComponent, SmartFilterBarConditionsDialogComponent, SmartFilterBarFieldDefinitionDirective, SmartFilterBarService, SmartFilterBarSettingsDialogComponent, SmartFilterBarSubjectDirective, SmartFilterBarToolbarItemDirective, smartFilterBarProvider };
export type { SmartFilterBarCondition, SmartFilterBarConditionBuilder, SmartFilterBarCustomFilterConfig, SmartFilterBarDynamicFormFieldGuiOptions, SmartFilterBarDynamicFormFieldItem, SmartFilterBarFieldDefinition, SmartFilterBarManagedPreset, SmartFilterBarStrategy, SmartFilterBarStrategyLabels, SmartFilterBarVisibilityCategory, SmartFilterBarVisibilityCategoryLabels, SmartFilterChangeObject, SmartFilterSettingsDialogConfig };
