import { tl } from '../../tl/index.js';
import { PublicPart } from '../../types/utils.js';
import { CurrentUserInfo, CurrentUserService } from '../storage/service/current-user.js';
import { PeersService } from '../storage/service/peers.js';
import { TelegramStorageManager } from '../storage/storage.js';
import { WorkerInvoker } from './invoker.js';
declare class CurrentUserServiceProxy implements PublicPart<CurrentUserService> {
    private _store;
    private _storeFrom;
    private _fetch;
    private _update;
    constructor(invoker: WorkerInvoker);
    private _cached?;
    store(info: CurrentUserInfo | null): Promise<void>;
    storeFrom(user: tl.TypeUser): Promise<CurrentUserInfo>;
    fetch(): Promise<CurrentUserInfo | null>;
    getCached(safe?: boolean): CurrentUserInfo | null;
    update(params: Parameters<CurrentUserService['update']>[0]): Promise<void>;
    setCached(info: CurrentUserInfo | null): void;
}
declare class PeersServiceProxy implements PublicPart<PeersService> {
    private _invoker;
    readonly updatePeersFrom: PeersService['updatePeersFrom'];
    readonly store: PeersService['store'];
    readonly getById: PeersService['getById'];
    readonly getByPhone: PeersService['getByPhone'];
    readonly getByUsername: PeersService['getByUsername'];
    readonly getCompleteById: PeersService['getCompleteById'];
    readonly getMinAccessHash: PeersService['getMinAccessHash'];
    readonly close: PeersService['close'];
    constructor(_invoker: WorkerInvoker);
}
export declare class TelegramStorageProxy implements PublicPart<TelegramStorageManager> {
    private _invoker;
    readonly self: CurrentUserServiceProxy;
    readonly peers: PeersServiceProxy;
    readonly clear: TelegramStorageManager['clear'];
    readonly close: TelegramStorageManager['close'];
    constructor(_invoker: WorkerInvoker);
    readonly updates: never;
    readonly refMsgs: never;
}
export {};