status-sharding/dist/core/clusterManager.d.ts

Welcome to Status Sharding! This package is designed to provide an efficient and flexible solution for sharding Discord bots, allowing you to scale your bot across multiple processes or workers.

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 { ClientRefType } from './clusterClient';
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 ClientRefType = ClientRefType, 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;
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);
}