@ytsaurus/ui 1.13.0 → 1.14.0

package/build/esm/ui/store/selectors/scheduling/attributes-to-filter.d.ts

@@ -0,0 +1,876 @@
+import { RootState } from '../../reducers';
+export declare const getSchedulingFilter: (state: RootState) => string;
+export declare const getSchedulingAbcFilter: (state: RootState) => {
+    slug?: string | undefined;
+    id?: number | undefined;
+};
+export declare const getSchedulingAttributesToFilter: (state: RootState) => Record<string, {
+    parent?: string | undefined;
+    abc: {
+        id: number;
+    };
+}> | undefined;
+export declare const getSchedulingAttributesToFilterTime: (state: RootState) => number;
+export declare const schedulingOverviewHasFilter: (state: RootState) => boolean;
+export declare const getSchedulingFilteredPoolNames: ((state: Omit<import("redux").CombinedState<{
+    acl: any;
+    aclFilters: import("../../reducers/acl/acl-filters").AclFiltersState;
+    actions: never;
+    clustersMenu: {
+        viewMode: any;
+        clusters: {};
+        clusterFilter: string;
+    } | {
+        clusterFilter: any;
+        clusters: {};
+        viewMode: string;
+    };
+    components: import("redux").CombinedState<{
+        versionsV2: import("../../reducers/components/versions/versions_v2").VersionsState & import("../../reducers/components/versions/versions_v2").VersionsFiltersState;
+        nodes: import("redux").CombinedState<{
+            nodes: import("../../reducers/components/nodes/nodes/nodes").NodesEphemeralState & import("../../reducers/components/nodes/nodes/nodes").NodesPersistedState;
+            setup: import("../../reducers/components/nodes/setup/setup").NodesSetupState;
+        }>;
+        node: import("redux").CombinedState<{
+            node: import("../../reducers/components/node/node").NodeEphemeralState;
+            memory: {
+                sortOrder: import("../../../types").SortState<string>[];
+                tablesSortOrder: import("../../../types").SortState<string>[];
+                collapsedBundles: string[];
+                viewMode: "cells" | "tables";
+                loading: boolean;
+                loaded: boolean;
+                error: import("../../../types").YTError | undefined;
+                memory: import("../../../types/node/node").MemoryUsage | undefined;
+                filter: string;
+                host: string;
+            };
+            unrecognizedOptions: {
+                loading: boolean;
+                loaded: boolean;
+                error: import("../../../types").YTError | undefined;
+                data: any;
+                host: string | undefined;
+            };
+        }>;
+        proxies: import("redux").CombinedState<{
+            proxies: {
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                proxies: never[];
+            } & {
+                hostFilter: string;
+                stateFilter: string;
+                roleFilter: string;
+                bannedFilter: "false" | "all" | "true";
+            };
+        }>;
+        shards: {
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            errorData: {};
+            shards: never[];
+            nameId: string;
+            nameVisible: boolean;
+            nameLoading: boolean;
+            nameLoaded: boolean;
+            nameError: boolean;
+            nameErrorData: {};
+        };
+        nodeMaintenanceModal: import("../../reducers/components/node-maintenance-modal").NodeMaintenanceState;
+    }>;
+    global: any;
+    supportedFeatures: import("../../reducers/global/supported-features").SupportedFeaturesState;
+    modals: import("redux").CombinedState<{
+        attributesModal: {
+            title: any;
+            visible: boolean;
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            attributes: {};
+            errorData: {};
+        } | {
+            attributes: any;
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            visible: boolean;
+            title: string;
+            errorData: {};
+        } | {
+            errorData: any;
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            visible: boolean;
+            title: string;
+            attributes: {};
+        };
+        errors: import("../../reducers/modals/errors").ErrorsState;
+    }>;
+    navigation: import("redux").CombinedState<{
+        pathEditor: {
+            suggestionsLoaded: boolean;
+            suggestionsLoading: boolean;
+            suggestions: any;
+            suggestionsPath: any;
+            suggestionsError: boolean;
+            errorMessage: string;
+        } | {
+            suggestionsLoading: boolean;
+            errorMessage: any;
+            suggestionsError: boolean;
+            suggestions: never[];
+            suggestionsPath: string;
+            suggestionsLoaded: boolean;
+        };
+        navigation: {
+            loadState: "" | "error" | "loading" | "loaded" | "cancelled";
+            transaction: null;
+            error: undefined;
+            attributes: {};
+            isIdmSupported: boolean;
+            remoteDestinationsConfig: undefined;
+            remoteDestinationsState: "";
+            remoteDestinationsError: undefined;
+            isWriteable: boolean;
+            isAccountUsable: boolean;
+            checkPermissionsError: undefined;
+        } & {
+            path: string;
+            mode: "attributes" | "acl" | "auto" | "consumer" | "content" | "queue" | "user_attributes" | "locks" | "schema" | "tablets" | "tablet_errors" | "annotation" | "access_log" | "mount_config";
+        };
+        content: import("redux").CombinedState<{
+            replicatedTable: import("../../reducers/navigation/content/replicated-table").ReplicatedTableState;
+            mapNode: {
+                loadState: "";
+                resourcesLoading: boolean;
+                error: undefined;
+                nodesData: never[];
+                lastSelected: undefined;
+            } & {
+                filter: string;
+                filterPathname: string;
+                customSort: string;
+                selected: {};
+                mediumType: string;
+                contentMode: "default";
+            };
+            table: {
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                columns: never[];
+                columnsOrder: never[];
+                omittedColumns: never[];
+                deniedKeyColumns: never[];
+                rows: never[];
+                yqlTypes: null;
+                isOffsetSelectorOpen: boolean;
+                isColumnSelectorOpen: boolean;
+                isFullScreen: boolean;
+                nextOffsetValue: null;
+                moveBackward: boolean;
+                validColumns: never[];
+                queryPreparing: boolean;
+            } & {
+                isDynamic: boolean;
+                isStrict: boolean;
+                offsetMode: string;
+                offsetValue: string;
+                pageSize: 10 | 50 | 100 | 200;
+                cellSize: 1024 | 16384 | 32768 | 65536;
+                columnsPresetHash: string;
+                columnsPreset: {
+                    columns: undefined;
+                    hash: undefined;
+                    error: undefined;
+                };
+            };
+            tableMountConfig: import("../../reducers/navigation/content/table/table-mount-config").TableMountConfigState;
+            document: {
+                document: any;
+                loaded: boolean;
+                loading: boolean;
+                error: boolean;
+                errorData: {};
+            } | {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+                loaded: boolean;
+                document: null;
+            };
+            file: {
+                file: any;
+                loaded: boolean;
+                loading: boolean;
+                error: boolean;
+                errorData: {};
+            } | {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+                loaded: boolean;
+                file: string;
+            };
+            transaction: {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+            };
+            transactionMap: {
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                transactions: never[];
+            } & {
+                filter: string;
+            };
+        }>;
+        modals: import("redux").CombinedState<{
+            attributesEditor: import("../../reducers/navigation/modals/attributes-editor").NavAttrEditorState;
+            createDirectory: {
+                creatingPath: any;
+                popupVisible: boolean;
+                showError: boolean;
+                creating: boolean;
+                errorMessage: string;
+                error: {};
+            } | {
+                creatingPath: string;
+                suggestions: never[];
+                popupVisible: boolean;
+                showError: boolean;
+                creating: boolean;
+                errorMessage: string;
+                error: {};
+            } | {
+                showError: boolean;
+                errorMessage: any;
+                error: any;
+                popupVisible: boolean;
+                creating: boolean;
+                creatingPath: string;
+            };
+            restoreObject: {
+                popupVisible: boolean;
+                restoredPath: any;
+                objectPath: any;
+                showError: boolean;
+                errorMessage: string;
+                error: {};
+                restoring: boolean;
+            } | {
+                path: string;
+                objectPath: string;
+                suggestions: never[];
+                popupVisible: boolean;
+                showError: boolean;
+                restoredPath: string;
+                errorMessage: string;
+                error: {};
+                restoring: boolean;
+            } | {
+                showError: boolean;
+                errorMessage: any;
+                error: any;
+                restoredPath: string;
+                objectPath: string;
+                popupVisible: boolean;
+                restoring: boolean;
+            };
+            deleteObject: {
+                item: any;
+                multipleMode: any;
+                permanently: any;
+                visible: boolean;
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                loadingRealPath: boolean;
+                errorRealPath: boolean;
+                errorDataRealPath: {};
+                realPath: string;
+                account: string;
+                name: string;
+                resourceUsage: {};
+                multipleInfo: never[];
+            } | {
+                loadingRealPath: boolean;
+                errorRealPath: boolean;
+                multipleInfo: any;
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                errorDataRealPath: {};
+                realPath: string;
+                account: string;
+                name: string;
+                resourceUsage: {};
+                visible: boolean;
+                permanently: boolean;
+                multipleMode: boolean;
+                item: {};
+            } | {
+                loadingRealPath: boolean;
+                errorRealPath: boolean;
+                realPath: any;
+                name: any;
+                account: any;
+                resourceUsage: any;
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                errorDataRealPath: {};
+                visible: boolean;
+                permanently: boolean;
+                multipleMode: boolean;
+                multipleInfo: never[];
+                item: {};
+            } | {
+                loadingRealPath: boolean;
+                errorRealPath: boolean;
+                errorDataRealPath: any;
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                realPath: string;
+                account: string;
+                name: string;
+                resourceUsage: {};
+                visible: boolean;
+                permanently: boolean;
+                multipleMode: boolean;
+                multipleInfo: never[];
+                item: {};
+            } | {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+                loaded: boolean;
+                loadingRealPath: boolean;
+                errorRealPath: boolean;
+                errorDataRealPath: {};
+                realPath: string;
+                account: string;
+                name: string;
+                resourceUsage: {};
+                visible: boolean;
+                permanently: boolean;
+                multipleMode: boolean;
+                multipleInfo: never[];
+                item: {};
+            };
+            createTable: any;
+            moveObject: {
+                creating: boolean;
+                renaming: boolean;
+                errorMessage: string;
+                error: {};
+                popupVisible: boolean;
+                showError: boolean;
+                multipleMode: boolean;
+                items: never[];
+                movedPath: string;
+                objectPath: string;
+            } | {
+                items: any;
+                multipleMode: any;
+                movedPath: any;
+                popupVisible: boolean;
+                objectPath: any;
+                showError: boolean;
+                renaming: boolean;
+                errorMessage: string;
+                error: {};
+            } | {
+                movedPath: string;
+                suggestions: never[];
+                popupVisible: boolean;
+                showError: boolean;
+                renaming: boolean;
+                multipleMode: boolean;
+                items: never[];
+                errorMessage: string;
+                error: {};
+                objectPath: string;
+            } | {
+                showError: boolean;
+                errorMessage: any;
+                error: any;
+                popupVisible: boolean;
+                renaming: boolean;
+                multipleMode: boolean;
+                items: never[];
+                movedPath: string;
+                objectPath: string;
+            };
+            copyObject: {
+                items: any;
+                objectPath: any;
+                multipleMode: any;
+                popupVisible: boolean;
+                copyPath: any;
+                showError: boolean;
+                errorMessage: string;
+                error: {};
+                copying: boolean;
+            } | {
+                path: string;
+                objectPath: string;
+                suggestions: never[];
+                popupVisible: boolean;
+                showError: boolean;
+                copyPath: string;
+                errorMessage: string;
+                error: {};
+                copying: boolean;
+                multipleMode: boolean;
+                items: never[];
+            } | {
+                showError: boolean;
+                errorMessage: any;
+                error: any;
+                copyPath: string;
+                objectPath: string;
+                popupVisible: boolean;
+                copying: boolean;
+                multipleMode: boolean;
+                items: never[];
+            };
+            tableEraseModal: import("../../reducers/navigation/modals/table-erase-modal").State;
+            tableMergeSortModal: import("../../reducers/navigation/modals/table-merge-sort-modal").TableSortMergeModal;
+            remoteCopyModal: import("../../reducers/navigation/modals/remote-copy-modal").RemoteCopyModalState;
+            dynTablesStateModal: import("../../reducers/navigation/modals/dyn-tables-state-modal").DynTablesStateModalState;
+            linkToModal: import("../../reducers/navigation/modals/link-to-modal").LinkToState;
+        }>;
+        tabs: import("redux").CombinedState<{
+            accessLog: import("redux").CombinedState<{
+                accessLog: import("../../reducers/navigation/tabs/access-log/access-log").AccessLogState;
+                accessLogFilters: import("../../reducers/navigation/tabs/access-log/access-log-filters").AccessLogFiltersState;
+            }>;
+            consumer: import("redux").CombinedState<{
+                filters: import("../../reducers/navigation/tabs/consumer/filters").ConsumerFiltersState;
+                partitions: import("../../reducers/navigation/tabs/consumer/partitions").ConsumerPartitionsState;
+                status: import("../../reducers/navigation/tabs/consumer/status").ConsumerStatusState;
+            }>;
+            locks: any;
+            queue: import("redux").CombinedState<{
+                filters: import("../../reducers/navigation/tabs/queue/filters").QueueFiltersState;
+                partitions: import("../../reducers/navigation/tabs/queue/partitions").QueuePartitionsState;
+                status: import("../../reducers/navigation/tabs/queue/status").QueueStatusState;
+            }>;
+            schema: {
+                column: any;
+            };
+            tablets: {
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+                tablets: never[];
+                expandedHosts: never[];
+            } & {
+                tabletsFilter: string;
+                tabletsMode: string;
+                histogramType: string;
+                histogramCollapsed: boolean;
+            };
+            annotation: any;
+            tabletErrors: import("../../reducers/navigation/tabs/tablet-errors").TabletErrorsState;
+            userAttributes: {
+                userAttributeKeys: any;
+                loaded: boolean;
+                loading: boolean;
+                error: boolean;
+                errorData: {};
+            } | {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+                loaded: boolean;
+                userAttributeKeys: never[];
+            };
+        }>;
+    }>;
+    dashboard: {
+        activeTab: any;
+    };
+    operations: import("redux").CombinedState<{
+        page: {
+            editWeightModal: {
+                visible: boolean;
+                editable: any;
+                operation: any;
+                loading: boolean;
+                loaded: boolean;
+                error: boolean;
+                errorData: {};
+            };
+            status: string;
+            error: {};
+        } | {
+            editWeightModal: {
+                loading: boolean;
+                error: boolean;
+                errorData: any;
+                loaded: boolean;
+                editable: boolean;
+                visible: boolean;
+                operation: {};
+            };
+            status: string;
+            error: {};
+        };
+        list: Pick<import("../../reducers/operations/list/list").OperationsListState, "operations" | "error" | "isLoading" | "hasLoaded" | "hasError" | "dataMode"> & Omit<import("../../reducers/operations/list/list").OperationsListState, "operations" | "error" | "isLoading" | "hasLoaded" | "hasError" | "dataMode">;
+        detail: {
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            errorData: {
+                message: string;
+                details: null;
+            };
+            operation: import("../../../pages/operations/selectors").DetailedOperationSelector;
+            actions: import("../../../utils/operations/details-ts").OperationAction[];
+            details: {
+                alert_events: {
+                    alert_type: string;
+                    time: string;
+                    error: YTError;
+                }[];
+            };
+            resourcesStatus: "";
+            resources: {};
+            monitorChartStates: {};
+        };
+        statistics: import("../../reducers/operations/statistics/statistics").OperationStatistics;
+        jobs: any;
+        jobsMonitor: import("../../reducers/operations/jobs/jobs-monitor").JobsMonitorState;
+    }>;
+    settings: import("../../reducers/settings").SettingsState;
+    slideoutMenu: {
+        pages: {
+            all: import("../../../pages").HeaderItem[];
+            recent: never[];
+            rest: never[];
+        };
+        clusters: {
+            all: any;
+            recent: never[];
+            rest: never[];
+        };
+    };
+    system: import("redux").CombinedState<{
+        schedulersAndAgents: {
+            fetching: boolean;
+            hasError: boolean;
+            error: {};
+            schedulers: never[];
+            schedulerAlerts: never[];
+            agents: never[];
+            agentAlerts: never[];
+        };
+        proxies: import("../../reducers/system/proxies").HttpProxiesState;
+        rpcProxies: import("../../reducers/system/proxies").HttpProxiesState;
+        chunks: {
+            fetching: boolean;
+            error: null;
+            replication: undefined;
+            sealer: undefined;
+            refresh: undefined;
+            requisitionUpdate: undefined;
+            cells: undefined;
+            types: undefined;
+        };
+        resources: {
+            loaded: boolean;
+            nodeAttrsLoaded: boolean;
+            fetching: boolean;
+            resources: {};
+            nodeAttributes: undefined;
+        };
+        masters: import("../../reducers/system/masters").MastersState;
+        nodes: import("../../reducers/system/nodes").SystemNodesState;
+    }>;
+    tables: {
+        clusters: {
+            field: string;
+            asc: boolean;
+        };
+        "system/chunks": {
+            field: string;
+            asc: boolean;
+        };
+        "navigation/map-nodes": {
+            field: string;
+            asc: boolean;
+        };
+        "navigation/tablets": {
+            field: string;
+            asc: boolean;
+        };
+        "navigation/content/transaction-map": {
+            field: string;
+            asc: boolean;
+        };
+        "tablet/partitions": {
+            field: string;
+            asc: boolean;
+        };
+        "tablet/partition/stores": {
+            field: string;
+            asc: boolean;
+        };
+        "accounts/accounts": {
+            field: string;
+            asc: boolean;
+        };
+        "operations/detail/jobs": {
+            field: string;
+            asc: boolean;
+        };
+        "components/versions/detailed": {
+            field: string;
+            asc: boolean;
+        };
+        "components/nodes": {
+            field: string;
+            asc: boolean;
+        };
+        "components/nodes/node": {
+            field: string;
+            asc: boolean;
+        };
+        "components/proxies": {
+            field: string;
+            asc: boolean;
+        };
+        "scheduling/pool-tree": {
+            field: string;
+            asc: boolean;
+        };
+        "scheduling/pool-children": {
+            field: string;
+            asc: boolean;
+        };
+    };
+    accounts: import("redux").CombinedState<{
+        accounts: {
+            fetching: boolean;
+            wasLoaded: boolean;
+            loadTotals: boolean;
+            loadNodes: boolean;
+            error: boolean;
+            errorData: {};
+            accounts: never[];
+            accountsTreeState: string;
+            editableAccount: {};
+            showEditor: boolean;
+            responsibleUsers: never[];
+            usableAccounts: never[];
+            clusterTotalsUsage: {};
+            nodesData: {};
+            editCounter: number;
+            disableCacheForNextFetch: boolean;
+        } & {
+            activeAccount: string;
+            activeNameFilter: string;
+            activeContentModeFilter: string;
+            masterMemoryContentMode: string;
+            activeMediumFilter: string;
+            sortState: {
+                field: string;
+                asc: boolean;
+            };
+            abcServiceFilter: {
+                slug: undefined;
+            };
+        };
+        editor: {
+            users: never[];
+            usersError: {};
+            fetchingError: boolean;
+            activeUserFilter: string;
+            activeUserList: never[];
+            createModalVisible: boolean;
+            deleteModalVisible: boolean;
+            newAccountInfo: {};
+        };
+        usage: import("redux").CombinedState<{
+            snapshots: import("../../reducers/accounts/usage/accounts-usage-snapshots").AccountsSnapshotState;
+            list: import("../../reducers/accounts/usage/accounts-usage-list").AccountUsageListData;
+            tree: import("../../reducers/accounts/usage/accounts-usage-tree").AccountUsageTreeData;
+            filters: import("../../reducers/accounts/usage/accounts-usage-filters").AccountUsageFiltersState;
+            listDiff: import("../../reducers/accounts/usage/accounts-usage-list-diff").AccountUsageListDiffData;
+            treeDiff: import("../../reducers/accounts/usage/accounts-usage-tree-diff").AccountUsageTreeDiffData;
+        }>;
+    }>;
+    pathViewer: {
+        loading: boolean;
+        loaded: boolean;
+        error: boolean;
+        errorData: {};
+        data: undefined;
+    } & {
+        path: string;
+        attributes: string;
+        command: string;
+        maxSize: string;
+        encodeUTF8: boolean;
+        stringify: boolean;
+        annotateWithTypes: boolean;
+    };
+    tablet: import("redux").CombinedState<{
+        tablet: {
+            loading: boolean;
+            loaded: boolean;
+            error: boolean;
+            errorData: {};
+            attributes: {};
+            partitions: never[];
+            tabletErrors: never[];
+            replicationErrors: {};
+            tablePath: string;
+            cellLeadingPeer: {};
+            activeHistogram: string;
+            pivotKey: undefined;
+            nextPivotKey: undefined;
+        } & {
+            contentMode: string;
+        };
+        stores: {
+            stores: any;
+            loaded: boolean;
+            loading: boolean;
+            error: boolean;
+            errorData: {};
+        } | {
+            loading: boolean;
+            error: boolean;
+            errorData: any;
+            loaded: boolean;
+            stores: never[];
+        };
+    }>;
+    tablet_cell_bundles: Pick<import("../../reducers/tablet_cell_bundles").TabletsBundlesState, "error" | "loading" | "loaded" | "cells" | "bundles" | "writableByName" | "cellsIdFilter" | "bundleDefaultConfig"> & Pick<import("../../reducers/tablet_cell_bundles").TabletsBundlesState, "bundlesNameFilter" | "bundlesAccountFilter" | "bundlesTagNodeFilter" | "cellsBundleFilter" | "cellsHostFilter" | "bundlesSort" | "cellsSort" | "activeBundle" | "bundlesTableMode">;
+    tabletCellBundleEditor: import("../../reducers/tablet_cell_bundles/tablet-cell-bundle-editor").TabletCellBundleEditorState;
+    chaos_cell_bundles: Pick<import("../../reducers/chaos_cell_bundles").ChaosBundlesState, "error" | "loading" | "loaded" | "cells" | "bundles" | "cellsIdFilter"> & Pick<import("../../reducers/chaos_cell_bundles").ChaosBundlesState, "bundlesNameFilter" | "bundlesAccountFilter" | "bundlesTagNodeFilter" | "cellsBundleFilter" | "cellsHostFilter" | "bundlesSort" | "cellsSort" | "activeBundle" | "bundlesTableMode">;
+    chaosCellBundleEditor: import("../../reducers/chaos_cell_bundles/tablet-cell-bundle-editor").ChaosCellBundleEditorState;
+    users: import("redux").CombinedState<{
+        table: {
+            loaded: boolean;
+            loading: boolean;
+            error: null;
+            users: never[];
+            sort: {
+                column: string;
+                order: string;
+            };
+        } & {
+            bannedFilter: boolean;
+            nameFilter: string;
+            groupFilter: string;
+        };
+        editUser: {
+            loaded: boolean;
+            loading: boolean;
+            error: null;
+            showModal: boolean;
+            username: string;
+            data: {};
+        };
+    }>;
+    groups: import("redux").CombinedState<{
+        table: {
+            loaded: boolean;
+            loading: boolean;
+            error: null;
+            groups: never[];
+            sort: {
+                column: string;
+                order: string;
+            };
+            expanded: {};
+        } & {
+            nameFilter: string;
+        };
+        editor: {
+            loaded: boolean;
+            loading: boolean;
+            error: null;
+            data: {};
+            idmData: {
+                group: {
+                    members: never[];
+                    responsibles: never[];
+                };
+                version: string;
+            };
+            showModal: boolean;
+            groupName: string;
+        };
+    }>;
+    scheduling: import("redux").CombinedState<{
+        scheduling: import("../../reducers/scheduling/scheduling").SchedulingEphemeralState & import("../../reducers/scheduling/scheduling").SchedulingPersistentState;
+        expandedPools: Omit<import("../../reducers/scheduling/expanded-pools").ExpandedPoolsState, "loadAll"> & Pick<import("../../reducers/scheduling/expanded-pools").ExpandedPoolsState, "loadAll">;
+        createPoolDialog: import("../../reducers/scheduling/create-pool-dialog").CreatePoolDialogState;
+    }>;
+    suggests: import("redux").CombinedState<{
+        tabletCellBundles: import("../../reducers/suggests/tablet-cell-bundless").State;
+    }>;
+    job: import("redux").CombinedState<{
+        general: import("../../reducers/job/general").GeneralState;
+        statistics: import("../../reducers/job/statistics").StatisticsEphemeralState & import("../../reducers/job/statistics").StatisticsPersistedState;
+        competitors: import("../../reducers/job/competitors").CompetitorsState;
+        specification: import("../../reducers/job/specification").SpecificationEphemeralState & import("../../reducers/job/specification").SpecificationPersistedState;
+    }>;
+    executeBatch: import("../../reducers/execute-batch").ExecuteBatchState;
+    queryTracker: import("redux").CombinedState<{
+        list: import("../../../pages/query-tracker/module/queries_list/reducer").QueriesListState;
+        query: import("../../../pages/query-tracker/module/query/reducer").QueryState;
+        results: never;
+    }>;
+    chyt: import("redux").CombinedState<{
+        list: import("../../reducers/chyt/list").ChytListState;
+        listFilters: import("../../reducers/chyt/list-filters").ChytListFilters;
+        clique: Omit<import("../../reducers/chyt/clique").ChytCliqueState, "currentClique"> & Pick<import("../../reducers/chyt/clique").ChytCliqueState, "currentClique">;
+        options: import("../../reducers/chyt/options").ChytCliqueOptionsState;
+        speclet: import("../../reducers/chyt/speclet").ChytCliqueSpecletState;
+    }>;
+}>, "global"> & {
+    global: {
+        [key: string]: any;
+        version: `${number}.${number}.${number}-${string}`;
+        schedulerVersion: `${number}.${number}.${number}-${string}`;
+        masterVersion: `${number}.${number}.${number}-${string}`;
+        clusterUiConfig: import("../../../../shared/yt-types").ClusterUiConfig;
+        cluster?: string | undefined;
+        rootPagesCluster?: string | undefined;
+        asideHeaderWidth: number;
+        allowedExperimentalPages: string[];
+    };
+}) => Set<string> | undefined) & import("reselect").OutputSelectorFields<(args_0: Record<string, {
+    parent?: string | undefined;
+    abc: {
+        id: number;
+    };
+}> | undefined, args_1: Record<string, import("./scheduling-pools").PoolInfo>, args_2: string, args_3: {
+    slug?: string | undefined;
+    id?: number | undefined;
+}) => Set<string> | undefined, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};