import { type IAttributeWithReferences } from "@gooddata/sdk-backend-spi";
import { type DashboardAttributeFilterItem, type FilterContextItem, type IAttributeDisplayFormMetadataObject, type IDashboardAttributeFilter, type IDashboardDateFilter, type IDashboardMeasureValueFilter, type IDashboardObjectIdentity, type IFilterContextDefinition, type ObjRef } from "@gooddata/sdk-model";
import { type ObjRefMap } from "../../../../_staging/metadata/objRefMap.js";
import { type DashboardSelector, type DashboardState } from "../../types.js";
import { type FilterContextState } from "./filterContextState.js";
/**
 * Returns filter context state for each tab keyed by identifier.
 *
 * @internal
 */
export declare const selectFilterContextStatesByTab: ((state: DashboardState) => Record<string, FilterContextState>) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>;
    memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, FilterContextState>;
    dependencies: [((state: DashboardState) => import("../tabsState.js").ITabState[]) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[];
        memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => import("../tabsState.js").ITabState[];
        dependencies: [DashboardSelector<import("../tabsState.js").ITabState[] | undefined>];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
};
/**
 * Returns applied filter context definitions for each tab keyed by identifier.
 *
 * @internal
 */
export declare const selectFilterContextDefinitionsByTab: ((state: DashboardState) => Record<string, IFilterContextDefinition | undefined>) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>;
    memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, IFilterContextDefinition | undefined>;
    dependencies: [((state: DashboardState) => Record<string, FilterContextState>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>;
        memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, FilterContextState>;
        dependencies: [((state: DashboardState) => import("../tabsState.js").ITabState[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[];
            memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => import("../tabsState.js").ITabState[];
            dependencies: [DashboardSelector<import("../tabsState.js").ITabState[] | undefined>];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
};
/**
 * Returns filters from each tab keyed by tab identifier.
 * This selector is useful for exporting dashboards with per-tab filters.
 *
 * @internal
 */
export declare const selectFiltersByTab: ((state: DashboardState) => Record<string, FilterContextItem[]>) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Record<string, IFilterContextDefinition | undefined>) => Record<string, FilterContextItem[]>;
    memoizedResultFunc: ((resultFuncArgs_0: Record<string, IFilterContextDefinition | undefined>) => Record<string, FilterContextItem[]>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, FilterContextItem[]>;
    dependencies: [((state: DashboardState) => Record<string, IFilterContextDefinition | undefined>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>;
        memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, IFilterContextDefinition | undefined>;
        dependencies: [((state: DashboardState) => Record<string, FilterContextState>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>;
            memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, FilterContextState>;
            dependencies: [((state: DashboardState) => import("../tabsState.js").ITabState[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[];
                memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[]) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => import("../tabsState.js").ITabState[];
                dependencies: [DashboardSelector<import("../tabsState.js").ITabState[] | undefined>];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
                argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
};
/**
 * Returns original (persisted) filter context definitions for each tab keyed by identifier.
 *
 * @internal
 */
export declare const selectOriginalFilterContextDefinitionsByTab: ((state: DashboardState) => Record<string, IFilterContextDefinition | undefined>) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>;
    memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, IFilterContextDefinition | undefined>;
    dependencies: [((state: DashboardState) => Record<string, FilterContextState>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>;
        memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, FilterContextState>;
        dependencies: [((state: DashboardState) => import("../tabsState.js").ITabState[]) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[];
            memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => import("../tabsState.js").ITabState[];
            dependencies: [DashboardSelector<import("../tabsState.js").ITabState[] | undefined>];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
};
/**
 * Returns original (persisted) filters for each tab keyed by identifier.
 *
 * @internal
 */
export declare const selectOriginalFilterContextFiltersByTab: ((state: DashboardState) => Record<string, FilterContextItem[]>) & {
    clearCache: () => void;
    resultsCount: () => number;
    resetResultsCount: () => void;
} & {
    resultFunc: (resultFuncArgs_0: Record<string, IFilterContextDefinition | undefined>) => Record<string, FilterContextItem[]>;
    memoizedResultFunc: ((resultFuncArgs_0: Record<string, IFilterContextDefinition | undefined>) => Record<string, FilterContextItem[]>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    };
    lastResult: () => Record<string, FilterContextItem[]>;
    dependencies: [((state: DashboardState) => Record<string, IFilterContextDefinition | undefined>) & {
        clearCache: () => void;
        resultsCount: () => number;
        resetResultsCount: () => void;
    } & {
        resultFunc: (resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>;
        memoizedResultFunc: ((resultFuncArgs_0: Record<string, FilterContextState>) => Record<string, IFilterContextDefinition | undefined>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        };
        lastResult: () => Record<string, IFilterContextDefinition | undefined>;
        dependencies: [((state: DashboardState) => Record<string, FilterContextState>) & {
            clearCache: () => void;
            resultsCount: () => number;
            resetResultsCount: () => void;
        } & {
            resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>;
            memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[]) => Record<string, FilterContextState>) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            };
            lastResult: () => Record<string, FilterContextState>;
            dependencies: [((state: DashboardState) => import("../tabsState.js").ITabState[]) & {
                clearCache: () => void;
                resultsCount: () => number;
                resetResultsCount: () => void;
            } & {
                resultFunc: (resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[];
                memoizedResultFunc: ((resultFuncArgs_0: import("../tabsState.js").ITabState[] | undefined) => import("../tabsState.js").ITabState[]) & {
                    clearCache: () => void;
                    resultsCount: () => number;
                    resetResultsCount: () => void;
                };
                lastResult: () => import("../tabsState.js").ITabState[];
                dependencies: [DashboardSelector<import("../tabsState.js").ITabState[] | undefined>];
                recomputations: () => number;
                resetRecomputations: () => void;
                dependencyRecomputations: () => number;
                resetDependencyRecomputations: () => void;
            } & {
                memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
                argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            }];
            recomputations: () => number;
            resetRecomputations: () => void;
            dependencyRecomputations: () => number;
            resetDependencyRecomputations: () => void;
        } & {
            memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
            argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        }];
        recomputations: () => number;
        resetRecomputations: () => void;
        dependencyRecomputations: () => number;
        resetDependencyRecomputations: () => void;
    } & {
        memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
        argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    }];
    recomputations: () => number;
    resetRecomputations: () => void;
    dependencyRecomputations: () => number;
    resetDependencyRecomputations: () => void;
} & {
    memoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
    argsMemoize: typeof import("@reduxjs/toolkit").weakMapMemoize;
};
/**
 * This selector returns array of filter localIds that have invalid selections.
 *
 * @returns Array of filter localIds with invalid selections.
 *
 * @public
 */
export declare const selectFiltersWithInvalidSelection: DashboardSelector<string[]>;
/**
 * This selector returns original (stored) dashboard's filter context definition.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @returns {@link @gooddata/sdk-backend-spi#IFilterContextDefinition} or `undefined` if original filter context definition is not set.
 *
 * @public
 */
export declare const selectOriginalFilterContextDefinition: DashboardSelector<IFilterContextDefinition | undefined>;
/**
 * This selector returns original (stored) dashboard's filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @returns an array of {@link @gooddata/sdk-backend-spi#FilterContextItem} or an empty array.
 *
 * @public
 */
export declare const selectOriginalFilterContextFilters: DashboardSelector<FilterContextItem[]>;
/**
 * This selector returns current applied dashboard's filter context definition.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @returns a {@link @gooddata/sdk-backend-spi#IFilterContextDefinition}
 *
 * @public
 */
export declare const selectFilterContextDefinition: DashboardSelector<IFilterContextDefinition>;
/**
 * This selector returns current working dashboard's filter context definition.
 *
 * @remarks
 * It is expected that the selector is called only after the wokring filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @returns a {@link @gooddata/sdk-backend-spi#IFilterContextDefinition}
 *
 * @alpha
 */
export declare const selectWorkingFilterContextDefinition: DashboardSelector<IFilterContextDefinition>;
/**
 * Returns true if working filters and applied filters are same.
 *
 * Attribute filters are considered equal if
 *  - they have same localIdentifier
 *  - they have same elements (order does not matter)
 *  - all other fields are deep equal EXCEPT displayForm
 * We exclude diplayForm becuase of primary display form migration code.
 * Which changes display forms after update.
 *
 * @alpha
 */
export declare const selectIsWorkingFilterContextChanged: DashboardSelector<boolean | undefined>;
/**
 * Selects dashboard's filter context identity.
 *
 * @remarks
 * The identity may be undefined in two circumstances:
 *
 * -  a new, yet unsaved dashboard; the filter context is saved together with the dashboard and after the
 *    save the identity will be known and added
 *
 * -  export of an existing, saved dashboard; during the export the dashboard receives a temporary
 *    filter context that represents values of filters at the time the export was initiated - which may
 *    be different from what is saved in the filter context itself. that temporary context is not
 *    persistent and lives only for that particular export operation.
 *
 * Invocations before initialization lead to invariant errors.
 *
 * @returns a {@link @gooddata/sdk-backend-spi#IDashboardObjectIdentity} or undefined, if the filter context identity is not set.
 *
 * @internal
 */
export declare const selectFilterContextIdentity: DashboardSelector<IDashboardObjectIdentity | undefined>;
/**
 * Selects list of display form metadata objects referenced by attribute filters.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @returns an array of {@link @gooddata/sdk-backend-spi#IAttributeDisplayFormMetadataObject}
 *
 * @public
 */
export declare const selectAttributeFilterDisplayForms: DashboardSelector<IAttributeDisplayFormMetadataObject[]>;
/**
 * Selects map of display form metadata objects referenced by attribute filters.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @returns a {@link ObjRefMap} of {@link @gooddata/sdk-backend-spi#IAttributeDisplayFormMetadataObject}
 *
 * @internal
 */
export declare const selectAttributeFilterDisplayFormsMap: DashboardSelector<ObjRefMap<IAttributeDisplayFormMetadataObject>>;
/**
 * This selector returns dashboard's applied filter context filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextFilters: DashboardSelector<FilterContextItem[]>;
/**
 * This selector returns dashboard's working filter context filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectWorkingFilterContextFilters: DashboardSelector<FilterContextItem[]>;
/**
 * This selector returns dashboard's applied filter context attribute filters with element-based selection only.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not include arbitrary or match (text) attribute filters.
 * Use {@link selectFilterContextAttributeFilterItems} to get all attribute-based filters.
 *
 * @public
 * @deprecated Use {@link selectFilterContextAttributeFilterItems} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilters: DashboardSelector<IDashboardAttributeFilter[]>;
/**
 * This selector returns all dashboard's applied filter context attribute-based filters,
 * including element-based, arbitrary, and match filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextAttributeFilterItems: DashboardSelector<DashboardAttributeFilterItem[]>;
/**
 * This selector returns dashboard's working filter context attribute filters with element-based selection only.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not include arbitrary or match (text) attribute filters.
 * Use {@link selectWorkingFilterContextAttributeFilterItems} to get all attribute-based filters.
 *
 * @public
 * @deprecated Use {@link selectWorkingFilterContextAttributeFilterItems} to include all attribute filter types.
 */
export declare const selectWorkingFilterContextAttributeFilters: DashboardSelector<IDashboardAttributeFilter[]>;
/**
 * This selector returns all dashboard's working filter context attribute-based filters,
 * including element-based, arbitrary, and match filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectWorkingFilterContextAttributeFilterItems: DashboardSelector<DashboardAttributeFilterItem[]>;
/**
 * This selector returns dashboard's applied filter context date filter.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDateFilter: DashboardSelector<IDashboardDateFilter | undefined>;
/**
 * This selector returns dashboard's working filter context date filter.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectWorkingFilterContextDateFilter: DashboardSelector<IDashboardDateFilter | undefined>;
/**
 * This selector returns dashboard's filter context draggable filters (element-based attribute filters and date filters).
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not include arbitrary or match (text) attribute filters.
 * Use {@link selectFilterContextDraggableFilterItems} to get all draggable filters.
 *
 * @public
 * @deprecated Use {@link selectFilterContextDraggableFilterItems} to include all attribute filter types.
 */
export declare const selectFilterContextDraggableFilters: DashboardSelector<Array<IDashboardDateFilter | IDashboardAttributeFilter>>;
/**
 * This selector returns all dashboard's filter context draggable filters,
 * including date filters, all attribute-based filters (element-based, arbitrary, and match),
 * and measure value filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDraggableFilterItems: DashboardSelector<Array<IDashboardDateFilter | DashboardAttributeFilterItem | IDashboardMeasureValueFilter>>;
/**
 * This selector returns dashboard's applied filter context measure value filters.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @alpha
 */
export declare const selectFilterContextMeasureValueFilters: DashboardSelector<IDashboardMeasureValueFilter[]>;
/**
 * Creates a selector for finding a dashboard measure value filter by its local identifier.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @alpha
 */
export declare const selectFilterContextMeasureValueFilterByLocalId: (localIdentifier: string) => (state: DashboardState) => IDashboardMeasureValueFilter | undefined;
/**
 * Creates a selector for finding a working dashboard measure value filter by its local identifier.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @alpha
 */
export declare const selectWorkingFilterContextMeasureValueFilterByLocalId: (localIdentifier: string) => (state: DashboardState) => IDashboardMeasureValueFilter | undefined;
/**
 * This selector returns dashboard's applied filter context date filter with dimension specified.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDateFiltersWithDimension: DashboardSelector<IDashboardDateFilter[]>;
/**
 * This selector returns dashboard's working filter context date filter with dimension specified.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectWorkingFilterContextDateFiltersWithDimension: DashboardSelector<IDashboardDateFilter[]>;
/**
 * Creates a selector for selecting date filter by its dataset {@link @gooddata/sdk-model#ObjRef}.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDateFilterByDataSet: (dataSet: ObjRef) => (state: DashboardState) => IDashboardDateFilter | undefined;
/**
 * Creates a selector for selecting date filter's index by its dataset {@link @gooddata/sdk-model#ObjRef}.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDateFilterIndexByDataSet: (dataSet: ObjRef) => (state: DashboardState) => number;
/**
 * Returns date filters with dimension for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Date filters with dimension for the specified tab
 *
 * @internal
 */
export declare const selectFilterContextDateFiltersWithDimensionForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardDateFilter[]>;
/**
 * Returns the common date filter for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Common date filter for the specified tab, or undefined if not found
 *
 * @internal
 */
export declare const selectFilterContextDateFilterForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardDateFilter | undefined>;
/**
 * Creates a selector for selecting date filter by its dataset from a specific tab.
 *
 * @param dataSet - Date dataset ref
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Date filter matching the dataset, or undefined if not found
 *
 * @internal
 */
export declare const selectFilterContextDateFilterByDataSetForTab: (dataSet: ObjRef, tabLocalIdentifier: string) => DashboardSelector<IDashboardDateFilter | undefined>;
/**
 * Creates a selector for selecting draggable filter's index by its ref:
 * dataSet ref for date filters {@link @gooddata/sdk-model#ObjRef}
 * localIdentifier for attribute, text attribute, and measure value filters
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextDraggableFilterIndexByRef: (ref: ObjRef | string) => (state: DashboardState) => number;
/**
 * Creates a selector for selecting element-based attribute filter by its displayForm {@link @gooddata/sdk-model#ObjRef}.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not match arbitrary or match (text) attribute filters.
 * Use {@link selectFilterContextAttributeFilterItemByDisplayForm} to match all attribute filter types.
 *
 * @public
 * @deprecated Use {@link selectFilterContextAttributeFilterItemByDisplayForm} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilterByDisplayForm: (displayForm: ObjRef) => (state: DashboardState) => IDashboardAttributeFilter | undefined;
/**
 * Creates a selector for selecting any attribute-based filter by its displayForm {@link @gooddata/sdk-model#ObjRef}.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextAttributeFilterItemByDisplayForm: (displayForm: ObjRef) => (state: DashboardState) => DashboardAttributeFilterItem | undefined;
/**
 * Creates a selector for selecting element-based attribute filter by its localId.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not match arbitrary or match (text) attribute filters.
 * Use {@link selectFilterContextAttributeFilterItemByLocalId} to match all attribute filter types.
 *
 * @public
 * @deprecated Use {@link selectFilterContextAttributeFilterItemByLocalId} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilterByLocalId: (localId: string) => DashboardSelector<IDashboardAttributeFilter | undefined>;
/**
 * Creates a selector for selecting any attribute-based filter by its localId.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextAttributeFilterItemByLocalId: (localId: string) => DashboardSelector<DashboardAttributeFilterItem | undefined>;
/**
 * Returns element-based attribute filters for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Attribute filters for the specified tab
 *
 * @internal
 * @deprecated Use {@link selectFilterContextAttributeFilterItemsForTab} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFiltersForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardAttributeFilter[]>;
/**
 * Returns all attribute-based filters (element-based, arbitrary, and match) for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns All attribute-based filters for the specified tab
 *
 * @internal
 */
export declare const selectFilterContextAttributeFilterItemsForTab: (tabLocalIdentifier: string) => DashboardSelector<DashboardAttributeFilterItem[]>;
/**
 * Creates a selector for selecting element-based attribute filter by its display form from a specific tab.
 *
 * @param displayForm - Display form ref
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Attribute filter matching the display form, or undefined if not found
 *
 * @internal
 * @deprecated Use {@link selectFilterContextAttributeFilterItemByDisplayFormForTab} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilterByDisplayFormForTab: (displayForm: ObjRef, tabLocalIdentifier: string) => DashboardSelector<IDashboardAttributeFilter | undefined>;
/**
 * Creates a selector for selecting any attribute-based filter by its display form from a specific tab.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @param displayForm - Display form ref
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Attribute filter item matching the display form, or undefined if not found
 *
 * @internal
 */
export declare const selectFilterContextAttributeFilterItemByDisplayFormForTab: (displayForm: ObjRef, tabLocalIdentifier: string) => DashboardSelector<DashboardAttributeFilterItem | undefined>;
/**
 * Creates a selector for selecting element-based attribute filter by its localId from a specific tab.
 *
 * @param localId - Filter local identifier
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Attribute filter matching the local id, or undefined if not found
 *
 * @internal
 * @deprecated Use {@link selectFilterContextAttributeFilterItemByLocalIdForTab} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilterByLocalIdForTab: (localId: string, tabLocalIdentifier: string) => DashboardSelector<IDashboardAttributeFilter | undefined>;
/**
 * Creates a selector for selecting any attribute-based filter by its localId from a specific tab.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @param localId - Filter local identifier
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Attribute filter item matching the local id, or undefined if not found
 *
 * @internal
 */
export declare const selectFilterContextAttributeFilterItemByLocalIdForTab: (localId: string, tabLocalIdentifier: string) => DashboardSelector<DashboardAttributeFilterItem | undefined>;
/**
 * Creates a selector for selecting element-based attribute filter index by its localId.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * Note: This selector does not match arbitrary or match (text) attribute filters.
 * Use {@link selectFilterContextAttributeFilterItemIndexByLocalId} to match all attribute filter types.
 *
 * @public
 * @deprecated Use {@link selectFilterContextAttributeFilterItemIndexByLocalId} to include all attribute filter types.
 */
export declare const selectFilterContextAttributeFilterIndexByLocalId: (localId: string) => DashboardSelector<number>;
/**
 * Creates a selector for selecting any attribute-based filter index by its localId.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectFilterContextAttributeFilterItemIndexByLocalId: (localId: string) => DashboardSelector<number>;
/**
 * Creates a selector for selecting all descendants of the attribute filter with given localId.
 *
 * @remarks
 * Invocations before initialization lead to invariant errors.
 * This selector should only be used when circular filter dependencies are not allowed.
 *
 * @public
 */
export declare const selectAttributeFilterDescendants: (localId: string) => DashboardSelector<string[]>;
/**
 * Creates a selector for selecting all element-based filters with different reference than the given one.
 *
 * @internal
 * @deprecated Use {@link selectOtherContextAttributeFilterItems} to include all attribute filter types.
 */
export declare const selectOtherContextAttributeFilters: (ref?: ObjRef) => DashboardSelector<IDashboardAttributeFilter[]>;
/**
 * Creates a selector for selecting all attribute-based filters with different reference than the given one.
 * Includes element-based, arbitrary, and match attribute filters.
 *
 * @internal
 */
export declare const selectOtherContextAttributeFilterItems: (ref?: ObjRef) => DashboardSelector<DashboardAttributeFilterItem[]>;
/**
 * Creates a selector to get a display form of an element-based filter defined by its local identifier.
 *
 * @internal
 * @deprecated Use {@link selectAttributeFilterItemDisplayFormByLocalId} to include all attribute filter types.
 */
export declare const selectAttributeFilterDisplayFormByLocalId: (localId: string) => DashboardSelector<ObjRef>;
/**
 * Creates a selector to get a display form of any attribute-based filter defined by its local identifier.
 * Matches element-based, arbitrary, and match attribute filters.
 *
 * @internal
 */
export declare const selectAttributeFilterItemDisplayFormByLocalId: (localId: string) => DashboardSelector<ObjRef>;
/**
 * Creates a selector which checks for a circular dependency between filters.
 *
 * @remarks
 * This selector should only be used when circular filter dependencies are not allowed.
 *
 * @internal
 */
export declare const selectIsCircularDependency: (currentFilterLocalId: string, neighborFilterLocalId: string) => DashboardSelector<boolean>;
/**
 * This selector returns whether any more attribute filters can be added.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 * @deprecated use selectCanAddMoreFilters instead
 */
export declare const selectCanAddMoreAttributeFilters: DashboardSelector<boolean>;
/**
 * This selector returns whether any more attribute filters can be added.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 * Invocations before initialization lead to invariant errors.
 *
 * @public
 */
export declare const selectCanAddMoreFilters: DashboardSelector<boolean>;
/**
 * This selector returns information whether attribute filter from filter context has some dependencies.
 *
 * @internal
 */
export declare const selectIsAttributeFilterDependentByLocalIdentifier: (attributeFilterLocalIdentifier: string) => DashboardSelector<boolean>;
/**
 * Returns filters for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Filters for the specified tab
 *
 * @internal
 */
export declare const selectFiltersForTab: (tabLocalIdentifier: string) => DashboardSelector<FilterContextItem[]>;
/**
 * Returns working filter context definition for a specific tab.
 * This merges the applied filters with working filter definition for the tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Working filter context definition for the specified tab
 *
 * @internal
 */
export declare const selectWorkingFilterContextDefinitionForTab: (tabLocalIdentifier: string) => DashboardSelector<IFilterContextDefinition | undefined>;
/**
 * Returns working filters for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Working filters for the specified tab
 *
 * @internal
 */
export declare const selectWorkingFiltersForTab: (tabLocalIdentifier: string) => DashboardSelector<FilterContextItem[]>;
/**
 * Returns working element-based attribute filters for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Working attribute filters for the specified tab
 *
 * @internal
 * @deprecated Use {@link selectWorkingFilterContextAttributeFilterItemsForTab} to include all attribute filter types.
 */
export declare const selectWorkingFilterContextAttributeFiltersForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardAttributeFilter[]>;
/**
 * Returns all working attribute-based filters (element-based, arbitrary, and match) for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns All working attribute-based filters for the specified tab
 *
 * @internal
 */
export declare const selectWorkingFilterContextAttributeFilterItemsForTab: (tabLocalIdentifier: string) => DashboardSelector<DashboardAttributeFilterItem[]>;
/**
 * Returns working date filters with dimension for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Working date filters with dimension for the specified tab
 *
 * @internal
 */
export declare const selectWorkingFilterContextDateFiltersWithDimensionForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardDateFilter[]>;
/**
 * Returns the working common date filter for a specific tab.
 *
 * @param tabLocalIdentifier - Tab local identifier
 * @returns Working common date filter for the specified tab, or undefined if not found
 *
 * @internal
 */
export declare const selectWorkingFilterContextDateFilterForTab: (tabLocalIdentifier: string) => DashboardSelector<IDashboardDateFilter | undefined>;
/**
 * Returns information whether attribute filter from a specific tab's filter context has some dependencies.
 *
 * @param attributeFilterLocalIdentifier - Filter local identifier
 * @param tabLocalIdentifier - Tab local identifier
 * @returns True if the filter has dependencies, false otherwise
 *
 * @internal
 */
export declare const selectIsAttributeFilterDependentByLocalIdentifierForTab: (attributeFilterLocalIdentifier: string, tabLocalIdentifier: string) => DashboardSelector<boolean>;
/**
 * Select preloaded attribute metadata objects with references for attribute filters.
 * Returns merged attributes from all filters across all tabs.
 *
 * @internal
 */
export declare const selectPreloadedAttributesWithReferences: DashboardSelector<IAttributeWithReferences[] | undefined>;
/**
 * This selector returns an array of attribute names related to filters with invalid selection.
 *
 * @remarks
 * It is expected that the selector is called only after the filter context state is correctly initialized.
 *
 * @returns An array of attribute names that have filters with invalid selections.
 *
 * @public
 */
export declare const selectNamesOfFiltersWithInvalidSelection: DashboardSelector<string[]>;
/**
 * Selects default filter overrides for the dashboard.
 *
 * @beta
 */
export declare const selectDefaultFilterOverrides: DashboardSelector<FilterContextItem[] | undefined>;
//# sourceMappingURL=filterContextSelectors.d.ts.map