import { type Awaitable, type DeepPartial, type MakeRequired, type When } from '../common';
import { EventHandler } from '../events';
import { type GatewayDispatchPayload } from '../types';
import { Shard, type ShardManagerOptions, type WorkerData } from '../websocket';
import { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
import type { WorkerHeartbeaterMessages } from '../websocket/discord/heartbeater';
import type { ShardData } from '../websocket/discord/shared';
import type { ClientHeartbeaterMessages, WorkerMessages, WorkerShardInfo } from '../websocket/discord/worker';
import type { ManagerMessages, ManagerSpawnShards } from '../websocket/discord/workermanager';
import type { BaseClientOptions, ServicesOptions, StartOptions } from './base';
import { BaseClient } from './base';
import type { Client, ClientOptions } from './client';
import { Collectors } from './collectors';
import { type RegisteredPluginExtension } from './plugins';
import { type ClientUserStructure } from './transformers';
export declare class WorkerClient<Ready extends boolean = boolean> extends BaseClient {
    memberUpdateHandler: MemberUpdateHandler;
    presenceUpdateHandler: PresenceUpdateHandler;
    collectors: Collectors;
    events: EventHandler;
    me: When<Ready, ClientUserStructure>;
    promises: Map<string, {
        resolve: (value: any) => void;
        timeout: NodeJS.Timeout;
    }>;
    shards: Map<number, Shard>;
    resharding: Map<number, Shard>;
    options: WorkerClientOptions;
    constructor(options?: WorkerClientOptions);
    get workerId(): number;
    get latency(): number;
    private onShardDisconnect;
    private onShardReconnect;
    get applicationId(): When<Ready, string, ''>;
    set applicationId(id: string);
    setServices(rest: ServicesOptions): void;
    setWorkerData(data: WorkerData): void;
    get workerData(): WorkerData;
    start(options?: Omit<DeepPartial<StartOptions>, 'httpConnection' | 'token' | 'connection'>): Promise<void>;
    loadEvents(dir?: string): Promise<void>;
    postMessage(body: WorkerMessages | ClientHeartbeaterMessages): unknown;
    handleManagerMessages(data: ManagerMessages | WorkerHeartbeaterMessages): Promise<any>;
    calculateShardId(guildId: string): number;
    private generateNonce;
    private generateSendPromise;
    tellWorker<R, V extends Record<string, unknown>>(workerId: number, func: (_: this, vars: V) => R, vars: V): Promise<R>;
    tellWorkers<R, V extends Record<string, unknown>>(func: (_: this, vars: V) => R, vars: V): Promise<Awaited<R>[]>;
    createShard(id: number, data: Pick<ManagerSpawnShards, 'info' | 'compress' | 'properties'>): Shard;
    resumeShard(shardId: number, shardData: MakeRequired<ShardData>): Promise<unknown>;
    protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<GatewayDispatchPayload | null>;
}
export interface WorkerClient<Ready extends boolean = boolean> extends RegisteredPluginExtension {
}
export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
export interface WorkerClientOptions extends BaseClientOptions {
    commands?: NonNullable<Client['options']>['commands'];
    handlePayload?: ShardManagerOptions['handlePayload'];
    /**
     * @deprecated Use shard disconnect events instead. Injected ShardManager callbacks can double-fire.
     */
    onShardDisconnect?: ShardManagerOptions['onShardDisconnect'];
    /**
     * @deprecated Use shard reconnect events instead. Injected ShardManager callbacks can double-fire.
     */
    onShardReconnect?: ShardManagerOptions['onShardReconnect'];
    gateway?: ClientOptions['gateway'];
    postMessage?: (body: unknown) => Awaitable<unknown>;
    /** can have perfomance issues in big bots if the client sends every event, specially in startup (false by default) */
    sendPayloadToParent?: boolean;
    handleManagerMessages?(message: ManagerMessages | WorkerHeartbeaterMessages): Awaitable<unknown>;
}