import { IFuseOptions } from 'fuse.js';
import { Connectable, Subject } from 'rxjs';
import { DeepPartial } from 'utility-types';
import { RivSelect } from '../../input/select/state';
import { HighlightComponent } from '../../visualization/highlight/highlight.component';
export declare namespace RivViews {
    const ViewPermissions: readonly ["private", "shared", "public"];
    type ViewPermission = (typeof ViewPermissions)[number];
    const MenuContexts: readonly ["tab", "all-views", "overflow"];
    type MenuContext = (typeof MenuContexts)[number];
    type User = RivSelect.BaseOption;
    const UserSelectModes: readonly ["select", "search-select"];
    type UserSelectMode = (typeof UserSelectModes)[number];
    type SearchSelectUser<U extends User> = U & {
        new: boolean;
    };
    type OnAddUser<U extends User> = (searchText: string) => SearchSelectUser<U>;
    type View<U extends User> = {
        id: string | number;
        title: string;
        enabled: boolean;
    } & ({
        permission: 'private' | 'public';
    } | {
        permission: 'shared';
        sharedUsers: U[];
    });
    type FullView<U extends User, V extends View<U>> = V & {
        active: boolean;
        system: boolean;
        titleHighlightIndices?: HighlightComponent.HighlightIndices[];
        temporary: boolean;
    };
    type CoreState<U extends User, V extends View<U>> = {
        views: V[];
        activeViewId: V['id'] | null;
        temporaryViewId: V['id'] | null;
        containerWidth: number;
        editingViewContext: {
            id: V['id'];
            autoRename: boolean;
            menuContext: MenuContext;
        } | null;
        deletingViewContext: {
            id: V['id'];
            menuContext: MenuContext;
        } | null;
        overflow: {
            search: string;
            pickerOpen: boolean;
        };
        all: {
            search: string;
            privateOpen: boolean;
            sharedOpen: boolean;
            publicOpen: boolean;
        };
        userSource: UserSource<U>;
        userSelectMode: UserSelectMode;
        onAddUser?: OnAddUser<U>;
        newTooltip?: string;
        hasSystemView: boolean;
    };
    type FullState<U extends User, V extends View<U>> = CoreState<U, V> & {
        allViews: FullView<U, V>[];
        displayedViews: FullView<U, V>[];
        enabledViews: FullView<U, V>[];
        allEnabledViews: FullView<U, V>[];
        all: {
            privateViews: FullView<U, V>[];
            sharedViews: FullView<U, V>[];
            publicViews: FullView<U, V>[];
        };
    };
    type Action<U extends User, V extends View<U>> = {
        type: 'load';
    } | {
        type: 'setActiveView';
        id: V['id'];
        source?: 'tab' | 'menu' | 'overflow';
    } | {
        type: 'setEnabled';
        id: V['id'];
        enabled: boolean;
        source?: 'menu' | 'eyeIcon';
    } | {
        type: 'setContainerWidth';
        width: number;
    } | {
        type: 'setOverflowPickerOpen';
        open: boolean;
    } | {
        type: 'setOverflowSearchQuery';
        query: string;
    } | {
        type: 'setAllViewsSearchQuery';
        query: string;
    } | {
        type: 'updateView';
        view: V;
    } | {
        type: 'deleteView';
        view: V;
    } | {
        type: 'duplicateView';
        view: V;
        menuContext: MenuContext;
    } | {
        type: 'copyLinkToView';
        view: V;
    } | {
        type: 'setEditingView';
        context: CoreState<U, V>['editingViewContext'];
    } | {
        type: 'setDeletingView';
        context: CoreState<U, V>['deletingViewContext'];
    } | {
        type: 'viewOrderChange';
        previousEnabledIndex: number;
        newEnabledIndex: number;
        source?: 'tabDrag' | 'overflowDrag';
        viewTitle?: V['title'];
    } | {
        type: 'setAllViewsToggle';
        permission: ViewPermission;
        open: boolean;
    } | {
        type: 'createTemporaryView';
        view: V;
    };
    type Source<U extends User, V extends View<U>> = () => V[] | Promise<V[]>;
    type Save<U extends User, V extends View<U>> = (views: V[]) => void | Promise<void>;
    type Duplicate<U extends User, V extends View<U>> = (viewToDuplicate: V) => V | Promise<V>;
    type UserSource<U extends User> = () => U[] | Promise<U[]>;
    type CopyLink<U extends User, V extends View<U>> = (view: V) => void | Promise<void>;
    type SetActiveViewId<U extends User, V extends View<U>> = (id: V['id']) => void | Promise<void>;
    type Manager<U extends User, V extends View<U>> = {
        actions: Subject<Action<U, V>>;
        state: Connectable<FullState<U, V>>;
    };
    type ManagerOptions<U extends User, V extends View<U>> = {
        initialState?: DeepPartial<CoreState<U, V>>;
        fuseOptions?: IFuseOptions<V>;
    };
    type CreateManagerInput<U extends User, V extends View<U>> = {
        source: Source<U, V>;
        save: Save<U, V>;
        duplicate: Duplicate<U, V>;
        userSource: UserSource<U>;
        userSelectMode?: UserSelectMode;
        onAddUser?: OnAddUser<U>;
        newTooltip?: string;
        copyLink: CopyLink<U, V>;
        setActiveViewId: SetActiveViewId<U, V>;
        options?: ManagerOptions<U, V>;
    };
    function createManager<U extends User, V extends View<U>>({ source, save, duplicate, userSource, userSelectMode, onAddUser, newTooltip, copyLink, options, setActiveViewId, }: CreateManagerInput<U, V>): Manager<U, V>;
    function getPermissionTitle(permission: ViewPermission): string;
    function getPermissionDescription(permission: ViewPermission): string;
    function isSharedView<U extends User, V extends View<U>>(view?: FullView<U, V>): view is FullView<U, V> & {
        permission: 'shared';
        sharedUsers: U[];
    };
    /**
     * Converts SearchSelectUser<U> items back to U[] for storage in sharedUsers.
     *
     * Cast required because TypeScript cannot prove that destructuring `new`
     * from `U & { new: boolean }` yields exactly `U` (spread/rest doesn't
     * narrow intersection types).
     *
     * - Strips `new: false` so isEqual() comparisons work (original users lack `new`)
     * - Preserves `new: true` so the backend knows which users to create
     */
    function toSharedUsers<U extends User>(users: SearchSelectUser<U>[]): U[];
}