import { BaseSearchSource, type SearchSourceOptions } from '../../../search';
import type { TextComposerMiddlewareOptions, UserSuggestion } from './types';
import type { StreamChat } from '../../../client';
import type { MemberFilters, MemberSort, UserFilters, UserOptions, UserResponse, UserSort } from '../../../types';
import type { Channel } from '../../../channel';
import type { Middleware } from '../../../middleware';
import type { TextComposerMiddlewareExecutorState } from './TextComposerMiddlewareExecutor';
export declare const accentsMap: {
    [key: string]: string;
};
export declare const removeDiacritics: (text?: string) => string;
export declare const calculateLevenshtein: (query: string, name: string) => number;
export type MentionsSearchSourceOptions = SearchSourceOptions & {
    mentionAllAppUsers?: boolean;
    textComposerText?: string;
    transliterate?: (text: string) => string;
};
export declare class MentionsSearchSource extends BaseSearchSource<UserSuggestion> {
    readonly type = "mentions";
    protected client: StreamChat;
    protected channel: Channel;
    userFilters: UserFilters | undefined;
    memberFilters: MemberFilters | undefined;
    userSort: UserSort | undefined;
    memberSort: MemberSort | undefined;
    searchOptions: Omit<UserOptions, 'limit' | 'offset'> | undefined;
    config: MentionsSearchSourceOptions;
    constructor(channel: Channel, options?: MentionsSearchSourceOptions);
    get allMembersLoadedWithInitialChannelQuery(): boolean;
    toUserSuggestion: (user: UserResponse) => UserSuggestion;
    getStateBeforeFirstQuery(newSearchString: string): {
        items: UserSuggestion[] | undefined;
        hasNext: boolean;
        isActive: boolean;
        isLoading: boolean;
        searchQuery: string;
        lastQueryError?: Error;
        next?: string | null;
        offset?: number;
    };
    canExecuteQuery: (newSearchString?: string) => boolean;
    transliterate: (text: string) => string;
    getMembersAndWatchers: () => UserResponse[];
    searchMembersLocally: (searchQuery: string) => UserResponse[];
    prepareQueryUsersParams: (searchQuery: string) => {
        filters: UserFilters;
        sort: UserSort;
        options: {
            limit: number;
            offset: number | undefined;
            include_deactivated_users?: boolean;
            presence?: boolean;
        };
    };
    prepareQueryMembersParams: (searchQuery: string) => {
        filters: MemberFilters;
        sort: MemberSort;
        options: {
            limit: number;
            offset: number | undefined;
            include_deactivated_users?: boolean;
            presence?: boolean;
        };
    };
    queryUsers: (searchQuery: string) => Promise<UserResponse[]>;
    queryMembers: (searchQuery: string) => Promise<UserResponse[]>;
    query(searchQuery: string): Promise<{
        items: UserSuggestion[];
    }>;
    filterMutes: (data: UserSuggestion[]) => UserSuggestion[];
    filterQueryResults(items: UserSuggestion[]): UserSuggestion[];
}
/**
 * TextComposer middleware for mentions
 * Usage:
 *
 *  const textComposer = new TextComposer(options);
 *
 *  textComposer.use(createMentionsMiddleware(channel, {
 *   trigger: '$',
 *   minChars: 2
 *  }));
 *
 * @param channel
 * @param {{
 *     minChars: number;
 *     trigger: string;
 *   }} options
 * @returns
 */
export type MentionsMiddleware = Middleware<TextComposerMiddlewareExecutorState<UserSuggestion>, 'onChange' | 'onSuggestionItemSelect'>;
export declare const createMentionsMiddleware: (channel: Channel, options?: Partial<TextComposerMiddlewareOptions> & {
    searchSource?: MentionsSearchSource;
}) => MentionsMiddleware;