import { ClusterClientEvents, EvalOptions, Serialized, Awaitable, ValidIfSerializable, SerializableInput, ClusterClientData } from '../types';
import { BaseMessage, DataType } from '../other/message';
import { IPCBrokerClient } from '../handlers/broker';
import { RefClusterManager } from './clusterManager';
import { PromiseHandler } from '../handlers/promise';
import { WorkerClient } from '../classes/worker';
import { ChildClient } from '../classes/child';
import { Serializable } from 'child_process';
import { RefShardingClient } from './client';
import { Guild } from 'discord.js';
import EventEmitter from 'events';
/** Simplified Cluster instance available on the {@link ClusterClient}. */
export declare class ClusterClient<InternalClient extends RefShardingClient = RefShardingClient, InternalManager extends RefClusterManager = RefClusterManager> extends EventEmitter {
    client: InternalClient;
    /** Ready state of the cluster. */
    ready: boolean;
    /** Handler that resolves sent messages and requests. */
    promise: PromiseHandler;
    /** Client that manages broker tunnels. */
    readonly broker: IPCBrokerClient;
    /** Client that manages the cluster process. */
    readonly process: ChildClient | WorkerClient | null;
    /** Handler that handles messages from the ClusterManager and the Cluster. */
    private messageHandler;
    /** Creates an instance of ClusterClient. */
    constructor(client: InternalClient);
    /** Current cluster id. */
    get id(): number;
    /** Total number of shards. */
    get totalShards(): number;
    /** Total number of clusters. */
    get totalClusters(): number;
    /** Utility function to get some info about the cluster. */
    get info(): ClusterClientData;
    /** Sends a message to the Cluster as child. (goes to Cluster on _handleMessage). */
    send<T extends Serializable>(message: SerializableInput<T>): Promise<void>;
    /** Broadcasts a message to all clusters. */
    broadcast<T extends Serializable>(message: SerializableInput<T>, sendSelf?: boolean): Promise<void>;
    /** Sends a message to the Cluster. */
    _sendInstance<D extends DataType, A = Serializable, P extends object = object>(message: BaseMessage<D, A, P>): Promise<void>;
    /** Evaluates a script on the master process, in the context of the {@link ClusterManager}. */
    evalOnManager<T, P extends object, M = InternalManager>(script: ((manager: M, context: Serialized<P>) => Awaitable<T>), options?: {
        context?: P;
        timeout?: number;
    }): Promise<ValidIfSerializable<T>>;
    /** Evaluates a script on all clusters in parallel. */
    broadcastEval<T, P extends object, C = InternalClient>(script: string | ((client: C, context: Serialized<P>) => Awaitable<T>), options?: EvalOptions<P>): Promise<ValidIfSerializable<T>[]>;
    /** Evaluates a script on specific guild. */
    evalOnGuild<T, P extends object, C = InternalClient, E extends boolean = false>(guildId: string, script: (client: C, context: Serialized<P>, guild: E extends true ? Guild : Guild | undefined) => Awaitable<T>, options?: EvalOptions<P>): Promise<ValidIfSerializable<T>>;
    /** Evaluates a script on a current client, in the context of the {@link ShardingClient}. */
    evalOnClient<T, P extends object, C = InternalClient>(script: string | ((client: C, context: Serialized<P>) => Awaitable<T>), options?: EvalOptions<P>): Promise<ValidIfSerializable<T>>;
    /** Sends a request to the Cluster (cluster has to respond with a reply (cluster.on('message', (message) => message.reply('reply')))). */
    request<T extends Serializable>(message: SerializableInput<T>, options?: {
        timeout?: number;
    }): Promise<ValidIfSerializable<T>>;
    /** Kills all running clusters and respawns them. */
    respawnAll(clusterDelay?: number, respawnDelay?: number, timeout?: number, except?: number[]): Promise<void>;
    /** Kills specific clusters and respawns them. */
    respawnClusters(clusters: number[], clusterDelay?: number, respawnDelay?: number, timeout?: number): Promise<void>;
    /** Handles a message from the ClusterManager. */
    private _handleMessage;
    /** Sends a message to the master process. */
    _respond<D extends DataType, A = Serializable, P extends object = object>(message: BaseMessage<D, A, P>): void;
    /** Triggers the ready event, do not use this unless you know what you are doing. */
    triggerReady(): boolean;
    /** Spawns the next cluster, when queue mode is on 'manual'. */
    spawnNextCluster(): Promise<void>;
    /** Kills the cluster. */
    _debug(message: string): void;
}
export type RefClusterClient = ClusterClient;
/** Modified ClusterClient with bunch of new methods. */
export declare interface ClusterClient {
    /** Emit an event. */
    emit: (<K extends keyof ClusterClientEvents>(event: K, ...args: ClusterClientEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, ...args: unknown[]) => boolean);
    /** Remove an event listener. */
    off: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
    /** Listen for an event. */
    on: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
    /** Listen for an event once. */
    once: (<K extends keyof ClusterClientEvents>(event: K, listener: (...args: ClusterClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterClientEvents>, listener: (...args: unknown[]) => void) => this);
    /** Remove all listeners for an event. */
    removeAllListeners: (<K extends keyof ClusterClientEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof ClusterClientEvents>) => this);
}