import { Awaitable, ClusterManagerCreateOptions, ClusterManagerEvents, ClusterManagerOptions, ClusteringMode, EvalOptions, Serialized, ValidIfSerializable, Serializable, SerializableInput } from '../types';
import { ReClusterManager } from '../plugins/reCluster';
import { HeartbeatManager } from '../plugins/heartbeat';
import { IPCBrokerManager } from '../handlers/broker';
import { PromiseHandler } from '../handlers/promise';
import { Cluster, RefCluster } from './cluster';
import { RefShardingClient } from './client';
import { Queue } from '../handlers/queue';
import CustomMap from '../other/map';
import { Guild } from 'discord.js';
import EventEmitter from 'events';
/** Manager for the Clusters. */
export declare class ClusterManager<InternalClient extends RefShardingClient = RefShardingClient, InternalCluster extends RefCluster = RefCluster> extends EventEmitter {
    file: string;
    /** Check if all clusters are ready. */
    ready: boolean;
    /** IPC Broker for the ClusterManager. */
    readonly broker: IPCBrokerManager;
    /** Options for the ClusterManager */
    readonly options: ClusterManagerOptions<ClusteringMode>;
    /** Promise Handler for the ClusterManager */
    readonly promise: PromiseHandler;
    /** A collection of all clusters the manager spawned. */
    readonly clusters: CustomMap<number, InternalCluster>;
    /** ReCluster Manager for the ClusterManager */
    readonly reCluster: ReClusterManager;
    /** Heartbeat Manager for the ClusterManager */
    readonly heartbeat: HeartbeatManager | null;
    /** Queue for the ClusterManager */
    readonly clusterQueue: Queue;
    /** Creates an instance of ClusterManager. */
    constructor(file: string, options: ClusterManagerCreateOptions<ClusteringMode>);
    /** Spawns multiple internal clusters. */
    spawn(): Promise<Queue>;
    /** Sends a message to all clusters. */
    broadcast<T extends Serializable>(message: SerializableInput<T>, ignoreClusters?: number[]): Promise<void>;
    /** Kills all running clusters and respawns them. */
    respawnAll(clusterDelay?: number, respawnDelay?: number, timeout?: number, except?: number[]): Promise<Map<number, InternalCluster>>;
    /** Kills specific clusters and respawns them. */
    respawnClusters(clusters: number[], clusterDelay?: number, respawnDelay?: number, timeout?: number): Promise<Map<number, InternalCluster>>;
    /** Evaluates a script on the Manager. */
    eval<T, P extends object, M = ClusterManager>(script: string | ((manager: M, context: Serialized<P>) => Awaitable<T>), options?: {
        context?: P;
        timeout?: number;
    }): Promise<{
        result: Serialized<T> | undefined;
        error: Error | undefined;
    }>;
    /** Evaluates a script on all clusters, or a given cluster, in the context of the Client. */
    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 a given Cluster's Client. */
    evalOnClusterClient<T, P extends object, C = InternalClient>(cluster: number, script: ((client: C, context: Serialized<P>) => Awaitable<T>), options?: Exclude<EvalOptions<P>, 'cluster'>): Promise<ValidIfSerializable<T>>;
    /** Evaluates a script on a given Cluster. */
    evalOnCluster<T, P extends object, C = InternalCluster>(cluster: number, script: string | ((cluster: C, context: Serialized<P>) => Awaitable<T>), options?: Exclude<EvalOptions<P>, 'cluster'>): Promise<ValidIfSerializable<T>>;
    /** Evaluates a script on specific guild. */
    evalOnGuild<T, P extends object, C = InternalClient>(guildId: string, script: string | ((client: C, context: Serialized<P>, guild: Guild | undefined) => Awaitable<T>), options?: EvalOptions<P>): Promise<ValidIfSerializable<T>>;
    /** Creates a new cluster. (Using this method is usually not necessary if you use the spawn method.) */
    createCluster(id: number, shardsToSpawn: number[], recluster?: boolean): Cluster<this>;
    /** Logs out the Debug Messages. */
    _debug(message: string): void;
}
export type RefClusterManager = ClusterManager;
/** ClusterManager Events. */
export declare interface ClusterManager {
    /** Emit an event. */
    emit: (<K extends keyof ClusterManagerEvents>(event: K, ...args: ClusterManagerEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterManagerEvents>, ...args: unknown[]) => boolean);
    /** Remove an event listener. */
    off: (<K extends keyof ClusterManagerEvents>(event: K, listener: (...args: ClusterManagerEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterManagerEvents>, listener: (...args: unknown[]) => void) => this);
    /** Listen for an event. */
    on: (<K extends keyof ClusterManagerEvents>(event: K, listener: (...args: ClusterManagerEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterManagerEvents>, listener: (...args: unknown[]) => void) => this);
    /** Listen for an event once. */
    once: (<K extends keyof ClusterManagerEvents>(event: K, listener: (...args: ClusterManagerEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof ClusterManagerEvents>, listener: (...args: unknown[]) => void) => this);
    /** Remove all listeners for an event. */
    removeAllListeners: (<K extends keyof ClusterManagerEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof ClusterManagerEvents>) => this);
}