import * as i0 from '@angular/core';
import { TemplateRef, ChangeDetectorRef, OnChanges, AfterViewInit, EventEmitter, SimpleChanges, QueryList, OnDestroy, ElementRef } from '@angular/core';
import { InfiniteScrollDirective } from '@fundamental-ngx/core/infinite-scroll';
import { Nullable } from '@fundamental-ngx/cdk/utils';
import { FormControl, ValidationErrors } from '@angular/forms';
import { BehaviorSubject, Subject, Observable } from 'rxjs';
import { DataSource, DataProvider } from '@fundamental-ngx/platform/shared';
import * as _fundamental_ngx_platform_value_help_dialog from '@fundamental-ngx/platform/value-help-dialog';
import { Direction } from '@angular/cdk/bidi';
import { DialogConfig, DialogRef, DialogService } from '@fundamental-ngx/core/dialog';
import { HeadingLevel } from '@fundamental-ngx/core/shared';
import * as i3 from '@fundamental-ngx/core/content-density';

declare class ValueHelpDialogDataSource<T> implements DataSource<T> {
    dataProvider: DataProvider<T>;
    /** @hidden */
    protected _dataChanges: BehaviorSubject<T[]>;
    /** @hidden */
    protected _onDataRequested$: Subject<void>;
    /** @hidden */
    protected _onDataReceived$: Subject<void>;
    /** @hidden */
    protected _dataLoading: boolean;
    /** @hidden */
    get isDataLoading(): boolean;
    /** @hidden */
    constructor(dataProvider: DataProvider<T>);
    /** @hidden */
    match(predicate?: string | Map<string, string>): void;
    /** @hidden */
    open(): Observable<T[]>;
    /** @hidden */
    onDataRequested(): Observable<void>;
    /** @hidden */
    onDataReceived(): Observable<void>;
    /** @hidden */
    close(): void;
}
declare class ArrayValueHelpDialogDataSource<T> extends ValueHelpDialogDataSource<T> {
    /** @hidden */
    constructor(data: T[]);
}
declare class ObservableValueHelpDialogDataSource<T> extends ValueHelpDialogDataSource<T> {
    /** @hidden */
    constructor(data: Observable<T[]>);
}
declare class VhdDataProvider<R extends object> extends DataProvider<R> {
    values: R[];
    /** @hidden */
    constructor(values: R[]);
    /** @hidden */
    fetch(params: Map<string, string>): Observable<R[]>;
}

declare enum VhdDefineIncludeStrategy {
    contains = "contains",
    equalTo = "equalTo",
    between = "between",
    startsWith = "startsWith",
    endsWith = "endsWith",
    lessThan = "lessThan",
    lessThanEqual = "lessThanEqual",
    greaterThan = "greaterThan",
    greaterThanEqual = "greaterThanEqual",
    empty = "empty"
}
declare enum VhdDefineExcludeStrategy {
    not_equalTo = "not_equalTo",
    not_empty = "not_empty"
}

declare enum VhdDefineType {
    include = "include",
    exclude = "exclude"
}

interface VhdDefineEntityRule {
    type: VhdDefineType;
    key: string;
    strategy: VhdDefineIncludeStrategy | VhdDefineExcludeStrategy;
    value: string;
    valueTo: string;
}
declare class BaseEntity implements VhdDefineEntityRule {
    /** @hidden */
    type: VhdDefineType;
    /** @hidden */
    key: string;
    /** @hidden */
    label?: string;
    /** @hidden */
    strategy: VhdDefineIncludeStrategy | VhdDefineExcludeStrategy;
    /** @hidden */
    value: string;
    /** @hidden */
    valueTo: string;
    /** @hidden */
    valid: boolean;
    /** @hidden */
    constructor(strategy?: VhdDefineIncludeStrategy | VhdDefineExcludeStrategy, key?: string);
}
declare class VhdIncludedEntity extends BaseEntity {
    /** @hidden */
    type: VhdDefineType;
}
declare class VhdExcludedEntity extends BaseEntity {
    /** @hidden */
    type: VhdDefineType;
}

interface ValueHelpFilterDefContext {
    $implicit: VhdFilter;
}
interface ValueHelpFilterDef {
    templateRef: TemplateRef<ValueHelpFilterDefContext>;
}
interface VhdFilter {
    key: string;
    label: string;
    main?: boolean;
    value?: string;
    advanced?: boolean;
    include?: boolean;
    exclude?: boolean;
    filterDef: Nullable<ValueHelpFilterDef>;
}

declare enum VhdTab {
    selectFromList = 0,
    defineConditions = 1,
    advancedSearch = 2
}

type VdhTableSelection = 'single' | 'multi' | 'once';

interface VhdValue<S = any> {
    selected?: S[];
    conditions?: BaseEntity[];
}
interface VhdValueChangeEvent<S = any> {
    selected: S[];
    conditions: BaseEntity[];
}

declare class VhdBaseTab {
    readonly _changeDetectorRef: ChangeDetectorRef;
    /** Tab Title */
    uid: string;
    /** Tab Title */
    tabTitle: string;
    /** Mobile view */
    mobile: boolean;
    /** @hidden */
    get type(): VhdTab;
    /** @hidden */
    constructor(_changeDetectorRef: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<VhdBaseTab, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VhdBaseTab, "ng-component", never, { "uid": { "alias": "uid"; "required": false; }; "tabTitle": { "alias": "tabTitle"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ExtendedBaseEntity extends BaseEntity {
    id?: number;
}
declare class ExtendedIncludedEntity extends VhdIncludedEntity {
    id?: number;
}
declare class ExtendedExcludedEntity extends VhdExcludedEntity {
    id?: number;
}
declare class DefineTabComponent extends VhdBaseTab implements OnChanges, AfterViewInit {
    /** @hidden */
    protected defaultId: string;
    /** @hidden */
    protected defaultSelectId: string;
    /** title id for the table  */
    titleId: string;
    /** seelcted value id for the table  */
    selectedId: string;
    /** @hidden */
    conditions: ExtendedBaseEntity[];
    /** @hidden */
    strategyLabels: {
        [key in keyof (typeof VhdDefineIncludeStrategy | typeof VhdDefineExcludeStrategy)]?: string;
    };
    /** @hidden */
    includeChange: EventEmitter<ExtendedIncludedEntity[]>;
    /** @hidden */
    excludeChange: EventEmitter<ExtendedExcludedEntity[]>;
    /** @hidden */
    conditionChange: EventEmitter<BaseEntity[]>;
    /** @hidden */
    _conditions: ExtendedBaseEntity[];
    /** @hidden */
    _definePanelState: {
        included: boolean;
        excluded: boolean;
    };
    /** @hidden */
    _rules: {
        maxCharactersHintCount: number;
    };
    /** @hidden */
    _strategyIncludeValues: typeof VhdDefineIncludeStrategy;
    /** @hidden */
    _strategyExcludeValues: typeof VhdDefineExcludeStrategy;
    /** @hidden */
    _defineTypes: typeof VhdDefineType;
    /** @hidden */
    _includeStrategy: StategyItem[];
    /** @hidden */
    _excludeStrategy: StategyItem[];
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden Track function for main data */
    _trackByKeyAndType(_index: number, item: ExtendedIncludedEntity | ExtendedExcludedEntity): number | string | undefined;
    /** @hidden */
    _onSelectStrategy(): void;
    /** @hidden */
    _filterChanged(): void;
    /** @hidden */
    addEmptyCondition(): void;
    /** @hidden */
    removeCondition(index: number): void;
    /** @hidden */
    _validateConditionValue(item: ExtendedIncludedEntity | ExtendedExcludedEntity, valid: boolean | boolean[]): void;
    /** @hidden */
    private _refreshStrategies;
    /** @hidden */
    private _initializeConditions;
    static ɵfac: i0.ɵɵFactoryDeclaration<DefineTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DefineTabComponent, "fdp-define-tab", never, { "titleId": { "alias": "titleId"; "required": false; }; "selectedId": { "alias": "selectedId"; "required": false; }; "conditions": { "alias": "conditions"; "required": false; }; "strategyLabels": { "alias": "strategyLabels"; "required": false; }; }, { "includeChange": "includeChange"; "excludeChange": "excludeChange"; "conditionChange": "conditionChange"; }, never, never, true, never>;
}
interface StategyItem {
    key: string;
    type: VhdDefineType;
}

interface ValueHelpColumnDefContext<T> {
    $implicit: T;
    key: string;
    value: any;
}
declare class ValueHelpColumnDefDirective<T = any> {
    /** Type support. */
    as: T;
    /** Column key to render custom template. */
    column: string;
    /** Template reference */
    readonly templateRef: TemplateRef<ValueHelpColumnDefContext<T>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueHelpColumnDefDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ValueHelpColumnDefDirective<any>, "[fdpValueHelpColumnDef]", never, { "as": { "alias": "fdpValueHelpColumnDefAs"; "required": false; }; "column": { "alias": "fdpValueHelpColumnDefColumn"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SelectTabComponent<T> extends VhdBaseTab implements OnChanges, AfterViewInit {
    /** @hidden */
    readonly loadingRange: number[];
    protected defaultTitleId: string;
    /** @hidden */
    protected defaultCountId: string;
    /** Select tab title element ID */
    selectTabTitleId: string;
    /** Select tab count element ID */
    selectTabCountId: string;
    /** Selected items */
    selected: T[];
    /** Loading state */
    loading: boolean;
    /** Actual filters */
    filters: VhdFilter[];
    /** Close dialog immediately after select any row from search table. It'll be skipped if multi option is true */
    selection: VdhTableSelection;
    /** Whether to allow users to select all table entries with one checkbox. */
    allowSelectAll: boolean;
    /** Uniq field from data source */
    uniqueKey: string;
    /** Items per page for pagination below search table */
    pageSize: number;
    /** Count of default mobile header from search table */
    defaultMobileHeaders: number;
    /** Displayed data for search table */
    displayedData: T[];
    /** Event emitted when row was selected. */
    select: EventEmitter<T[]>;
    /** @hidden */
    infiniteScrollTable: InfiniteScrollDirective;
    /** @hidden indeterminate flag for `select all` checkbox */
    _selectedAll: boolean | null;
    /** @hidden Shown items count in mobile view */
    _shownFrom: number;
    /** @hidden Shown items count in mobile view */
    _shownCount: number;
    /** @hidden Current page in desktop view */
    _currentPage: number;
    /** @hidden Headers and body for search table */
    _tableFilters: {
        main: VhdFilter[];
        secondary: VhdFilter[];
    };
    /** @hidden */
    _selectedMap: {
        [key: string]: boolean;
    };
    /** Selection type getters */
    get isSingleSelection(): boolean;
    /** Selection type getters */
    get isOnceSelection(): boolean;
    /** Selection type getters */
    get isMultiSelection(): boolean;
    /** @hidden */
    _columnDefMap: Map<string, ValueHelpColumnDefDirective<any>>;
    /** @hidden */
    private selectedItems;
    /** @hidden */
    private readonly _vhd;
    /** @hidden */
    private readonly _destroyRef;
    /** @hidden */
    ngAfterViewInit(): void;
    /** @hidden  */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden Track function for main data */
    _trackByTableRowFn: (_index: number, item: T) => string | undefined;
    /** @hidden Track function for filters */
    _trackByFilterFn(_index: number, item: VhdFilter): number | string | undefined;
    /** @hidden Show more elements */
    _showMoreElements(): void;
    /** @hidden Refresh page in desktop view */
    _updatePage(pageNumber?: number): void;
    /** @hidden Method toggle selected state for all items  */
    _toggleAllRows(): void;
    /** @hidden Method toggle selected state for one items  */
    _toggleSelectRow(item: T): void;
    /** @hidden */
    private _checkScrollAndShowMore;
    /** @hidden */
    private _resetShown;
    /** @hidden Manually clear selected items */
    private _clearSelectedItems;
    /** @hidden Refresh indeterminate attribute on `select all` checkbox */
    private _refreshTristate;
    /** @hidden Set up filters */
    private _initializeFilters;
    /** @hidden Refresh display data */
    private _refreshDisplayedData;
    /** @hidden Refresh selected map for display data */
    private _refreshSelectedMap;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectTabComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectTabComponent<any>, "fdp-select-tab", never, { "selectTabTitleId": { "alias": "selectTabTitleId"; "required": false; }; "selectTabCountId": { "alias": "selectTabCountId"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "filters": { "alias": "filters"; "required": false; }; "selection": { "alias": "selection"; "required": false; }; "allowSelectAll": { "alias": "allowSelectAll"; "required": false; }; "uniqueKey": { "alias": "uniqueKey"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "defaultMobileHeaders": { "alias": "defaultMobileHeaders"; "required": false; }; "displayedData": { "alias": "displayedData"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
}

declare class ValueHelpFilterDefDirective implements ValueHelpFilterDef {
    /** Template reference */
    readonly templateRef: TemplateRef<ValueHelpFilterDefContext>;
    /** @hidden */
    static ngTemplateContextGuard(dir: ValueHelpFilterDefDirective, ctx: unknown): ctx is ValueHelpFilterDefContext;
    static ɵfac: i0.ɵɵFactoryDeclaration<ValueHelpFilterDefDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ValueHelpFilterDefDirective, "[fdpValueHelpFilterDef]", never, {}, {}, never, never, true, never>;
}

declare class VhdFilterComponent implements VhdFilter {
    /** Uniq key for search and filtering */
    key: string;
    /** Allow to control which of filters should show as main in mobile view.
     * Apply for search table only */
    main: boolean;
    /** Label for header in search table and search field */
    label: string;
    /** Initial filter's value for search section in `select from list tab` only */
    value: string;
    /** Allow to show filter in advanced search template */
    advanced: boolean;
    /** Allow to use filter for including in `define conditions tab` */
    include: boolean;
    /** Allow to use filter for excluding in `define conditions tab` */
    exclude: boolean;
    /** @hidden */
    filterDef: Nullable<ValueHelpFilterDefDirective>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VhdFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VhdFilterComponent, "fdp-value-help-dialog-filter", never, { "key": { "alias": "key"; "required": false; }; "main": { "alias": "main"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "advanced": { "alias": "advanced"; "required": false; }; "include": { "alias": "include"; "required": false; }; "exclude": { "alias": "exclude"; "required": false; }; }, {}, ["filterDef"], never, true, never>;
}

declare const defaultConditionDisplayFn: (item: VhdIncludedEntity | VhdExcludedEntity, filters?: VhdFilter[]) => string | null;

declare const MAX_CHARACTER_HINT_COUNT = 7;

declare class ConditionCountMessageDirective {
    /** Max characters allowed */
    set maxCharacters(value: number);
    get maxCharacters(): number;
    /** @hidden */
    private _maxCharacters;
    /** @hidden */
    private readonly validator;
    /** @hidden */
    constructor();
    /** @hidden */
    validate(control: FormControl): ValidationErrors | null;
    /** @hidden */
    private checkError;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConditionCountMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ConditionCountMessageDirective, "[fdp-condition-count-message]", never, { "maxCharacters": { "alias": "maxCharacters"; "required": false; }; }, {}, never, never, true, never>;
}

declare abstract class VhdComponent {
    abstract columnDef: QueryList<ValueHelpColumnDefDirective>;
}

type FdpValueHelpDialogDataSource<T> = ValueHelpDialogDataSource<T> | ArrayValueHelpDialogDataSource<T> | ObservableValueHelpDialogDataSource<T>;
declare class PlatformValueHelpDialogComponent<T = any> extends VhdComponent implements OnChanges, OnDestroy {
    readonly elementRef: ElementRef;
    private readonly _changeDetectorRef;
    private readonly _dialogService;
    /** Id of the popover */
    id: string;
    /** Initial state of Value help dialog */
    value: VhdValue<T>;
    /** Dialog title */
    dialogTitle: string;
    /** Select from list tab activation */
    initialTab: VhdTab;
    /** Visible tabs */
    tabs: 'both' | 'select' | 'define';
    /** Initial expand state for advanced search panel */
    isOpenAdvanced: boolean;
    /** Data source */
    set dataSource(value: FdpValueHelpDialogDataSource<any> | undefined);
    get dataSource(): FdpValueHelpDialogDataSource<any> | undefined;
    /** Dialog's custom config */
    dialogConfig: DialogConfig;
    /** Unique key from the source field names. Required field. */
    uniqueKey: string;
    /** Id attribute for dialog title */
    headerId: string;
    /** Field name for default render from data.
     * Required field if tokenizerFn is not exist. */
    tokenViewField: string;
    /** Tokenizer function for custom token render, it has higher prio that `tokenViewField`.
     * Required field if tokenViewField is not exist. */
    tokenizerFn: (item: T) => string;
    /** Whether the value help dialog should be view in mobile mode */
    mobile: boolean;
    /** It should be able if you use multiple selection */
    formatToken: (value: VhdValueChangeEvent<T>) => void;
    /** Tokenizer function for condition's token render */
    conditionDisplayFn: (item: _fundamental_ngx_platform_value_help_dialog.VhdIncludedEntity | _fundamental_ngx_platform_value_help_dialog.VhdExcludedEntity, filters?: VhdFilter[]) => string | null;
    /** Validator function. Called when user submits VHD dialog. */
    tokenValidator: ((value: VhdValueChangeEvent) => Observable<boolean> | boolean) | undefined;
    /** Selection mode for search table */
    searchSelection: VdhTableSelection;
    /** Items per page for pagination below search table */
    searchTablePageSize: number;
    /** Count of default mobile header from search table */
    searchTableMobileHeaders: number;
    /** Max shown initial filters on open. Desktop only */
    maxShownInitialFilters: number;
    /** Loading state */
    loading: boolean | undefined;
    /** Whether to allow users to select all table entries with one checkbox. */
    allowSelectAll: boolean;
    /** Custom strategies labels
     * Allowed keys: contains, equalTo, between, startsWith, endsWith, lessThan, lessThanEqual, greaterThan, greaterThanEqual, empty
     */
    defineStrategyLabels: {
        [key in keyof (typeof VhdDefineIncludeStrategy | typeof VhdDefineExcludeStrategy)]?: string;
    };
    /** Dialog outputs */
    /** Event emitted when filters/tokens were changed. */
    valueChange: EventEmitter<VhdValueChangeEvent<T>>;
    /** Event emitted when data loading is started. */
    onDataRequested: EventEmitter<void>;
    /** Event emitted when data loading is finished. */
    onDataReceived: EventEmitter<void>;
    /** @hidden Fitlers for search table and defince conditions */
    filters: QueryList<VhdFilterComponent>;
    /** Column definitions. */
    columnDef: QueryList<ValueHelpColumnDefDirective>;
    /** @hidden Internal container for dialog */
    dialogContainer: TemplateRef<any>;
    /**
     * Heading level of the dialog title.
     */
    headingLevel: i0.InputSignal<HeadingLevel>;
    /** @hidden */
    _headingLevel: i0.Signal<number | undefined>;
    /** @hidden */
    activeDialog?: DialogRef;
    /** @hidden */
    _tabTypes: typeof VhdTab;
    /** @hidden */
    _hasAdvanced: boolean;
    /** @hidden */
    _displayedFilters: VhdFilter[];
    /** @hidden */
    _displayedData: T[];
    /** @hidden */
    _mainSearch: string;
    /** @hidden */
    selectedTab: VhdTab | null;
    /** @hidden */
    shownFilterCount: number;
    /** @hidden */
    get loadingState(): boolean;
    /** @hidden
     * To differentiate between first loading when skeletons be shown and subsequent loadings when busy indicator be shown
     */
    _firstLoadingDone: boolean;
    /** handles rtl service
     * @hidden */
    protected readonly dir: i0.Signal<Direction>;
    /** @hidden */
    private _destroyed;
    /** @hidden */
    private _dataSource;
    /** @hidden for data source handling */
    private _dsSubscription;
    /** @hidden Previous state */
    private _prevState;
    /** @hidden Current data for local manupulation */
    private _currentValue;
    /** @hidden */
    private _internalLoadingState;
    /** @hidden */
    private readonly _onDestroy$;
    /** @hidden */
    private readonly _rtlService;
    /** @hidden */
    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef, _dialogService: DialogService);
    /** @hidden */
    get isMobileAdvancedSearchActive(): boolean;
    /** @hidden */
    get hasSelectedTab(): boolean;
    /** @hidden */
    get showSelectionTab(): boolean;
    /** @hidden */
    get showDefineTab(): boolean;
    /** @hidden */
    get isSelectionTab(): boolean;
    /** @hidden */
    get selectedItems(): T[];
    /** @hidden */
    get conditionItems(): BaseEntity[];
    /** @hidden */
    get validConditions(): BaseEntity[];
    /** @hidden */
    get hasSelectedAndConditions(): boolean;
    /** @hidden */
    get isShowAllFilters(): boolean;
    /** @hidden */
    get isOpen(): boolean;
    /** @hidden */
    ngOnChanges(changes: SimpleChanges): void;
    /** @hidden */
    ngOnDestroy(): void;
    /** Open dialog */
    open(): void;
    /**
     * Toggle advanced search panel
     */
    toggleAdvancedSearch(state?: boolean): void;
    /**
     * Clear all selected items
     */
    clearSelectedAndConditionItems(): void;
    /** Search by only the search term. */
    search(): void;
    /**
     * Search by all filled filters, including the search term.
     */
    filter(onlySearch?: boolean): void;
    /**
     * Apply search from advanced filters view, using when mobile view is active
     */
    searchAdvanced(): void;
    /** Remove item from selected array */
    removeSelected(index: number): void;
    /**
     * Remove condition item
     */
    removeCondition(index: number): void;
    /**
     * Switch tab by type
     */
    switchTab(type?: VhdTab | null): void;
    /**
     * Close dialog with value;
     */
    success(): void;
    /**
     * Hide advanced search on mobile view and if it's opened
     * Close dialog with null value;
     */
    dismiss(): void;
    /** @hidden */
    _trackBySelectedFn: (_index: number, item: T) => number | string;
    /** @hidden */
    _trackByFilterFn(_index: number, item: VhdFilter): number | string;
    /** @hidden */
    _trackByConditionFn(_index: number, item: BaseEntity): number | string | undefined;
    /** @hidden */
    onSelect($event: T[]): void;
    /** @hidden */
    onConditionChange($event: BaseEntity[]): void;
    /** @hidden */
    toggleShownFilters(): void;
    /** @hidden */
    private _initShownFilters;
    /** @hidden */
    private _getValidCondition;
    /** @hidden */
    private _initializeDS;
    /** @hidden Save previous state */
    private _savePreviousState;
    /** @hidden */
    private _initializeTab;
    /** @hidden */
    private _listenDialogEvents;
    /** @hidden */
    private _resetState;
    /** @hidden */
    private _updateFilters;
    /** @hidden */
    private openDataStream;
    /** @hidden */
    private toDataStream;
    /** @hidden */
    private _resetSourceStream;
    /** @hidden */
    private isValidOptions;
    private _getValidatorFunction;
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformValueHelpDialogComponent<any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PlatformValueHelpDialogComponent<any>, "fdp-value-help-dialog", never, { "id": { "alias": "id"; "required": false; }; "value": { "alias": "value"; "required": false; }; "dialogTitle": { "alias": "dialogTitle"; "required": false; }; "initialTab": { "alias": "initialTab"; "required": false; }; "tabs": { "alias": "tabs"; "required": false; }; "isOpenAdvanced": { "alias": "isOpenAdvanced"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "dialogConfig": { "alias": "dialogConfig"; "required": false; }; "uniqueKey": { "alias": "uniqueKey"; "required": false; }; "headerId": { "alias": "headerId"; "required": false; }; "tokenViewField": { "alias": "tokenViewField"; "required": false; }; "tokenizerFn": { "alias": "tokenizerFn"; "required": false; }; "mobile": { "alias": "mobile"; "required": false; }; "formatToken": { "alias": "formatToken"; "required": false; }; "conditionDisplayFn": { "alias": "conditionDisplayFn"; "required": false; }; "tokenValidator": { "alias": "tokenValidator"; "required": false; }; "searchSelection": { "alias": "searchSelection"; "required": false; }; "searchTablePageSize": { "alias": "searchTablePageSize"; "required": false; }; "searchTableMobileHeaders": { "alias": "searchTableMobileHeaders"; "required": false; }; "maxShownInitialFilters": { "alias": "maxShownInitialFilters"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "allowSelectAll": { "alias": "allowSelectAll"; "required": false; }; "defineStrategyLabels": { "alias": "defineStrategyLabels"; "required": false; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "onDataRequested": "onDataRequested"; "onDataReceived": "onDataReceived"; }, ["filters", "columnDef"], never, true, never>;
}

/**
 * @deprecated
 * Use direct imports of components and directives.
 */
declare class PlatformValueHelpDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PlatformValueHelpDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PlatformValueHelpDialogModule, never, [typeof PlatformValueHelpDialogComponent, typeof VhdFilterComponent, typeof i3.ContentDensityModule], [typeof PlatformValueHelpDialogComponent, typeof VhdFilterComponent, typeof i3.ContentDensityModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PlatformValueHelpDialogModule>;
}

export { ArrayValueHelpDialogDataSource, BaseEntity, ConditionCountMessageDirective, DefineTabComponent, MAX_CHARACTER_HINT_COUNT, ObservableValueHelpDialogDataSource, PlatformValueHelpDialogComponent, PlatformValueHelpDialogModule, SelectTabComponent, ValueHelpColumnDefDirective, ValueHelpDialogDataSource, ValueHelpFilterDefDirective, VhdBaseTab, VhdDataProvider, VhdDefineExcludeStrategy, VhdDefineIncludeStrategy, VhdDefineType, VhdExcludedEntity, VhdFilterComponent, VhdIncludedEntity, VhdTab, defaultConditionDisplayFn };
export type { FdpValueHelpDialogDataSource, ValueHelpColumnDefContext, ValueHelpFilterDef, ValueHelpFilterDefContext, VdhTableSelection, VhdDefineEntityRule, VhdFilter, VhdValue, VhdValueChangeEvent };