seyfert/lib/client/workerclient.d.ts

The most advanced framework for discord bots

import { 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 type { 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 { MemberUpdateHandler } from '../websocket/discord/events/memberUpdate';
import { PresenceUpdateHandler } from '../websocket/discord/events/presenceUpdate';
import type { ShardData } from '../websocket/discord/shared';
import { Collectors } from './collectors';
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;
    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): unknown;
    handleManagerMessages(data: ManagerMessages): Promise<any>;
    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'>): Shard;
    resumeShard(shardId: number, shardData: MakeRequired<ShardData>): Promise<unknown>;
    protected onPacket(packet: GatewayDispatchPayload, shardId: number): Promise<void>;
}
export declare function generateShardInfo(shard: Shard): WorkerShardInfo;
interface WorkerClientOptions extends BaseClientOptions {
    commands?: NonNullable<Client['options']>['commands'];
    handlePayload?: ShardManagerOptions['handlePayload'];
    gateway?: ClientOptions['gateway'];
    postMessage?: (body: unknown) => 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): any;
}
export {};