WorkerClient

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;

get workerId(): number;

get latency(): number;

private onShardDisconnect;

private onShardReconnect;

get applicationId(): When<Ready, string, ''>;

set applicationId(id: string);

get workerData(): WorkerData;

private generateNonce;

private generateSendPromise;

rest: ApiHandler<this>;

cache: Cache;

applications: ApplicationShorter;

users: UsersShorter;

channels: ChannelShorter;

guilds: GuildShorter;

messages: MessageShorter;

members: MemberShorter;

webhooks: WebhookShorter;

templates: TemplateShorter;

roles: RoleShorter;

reactions: ReactionShorter;

emojis: EmojiShorter;

threads: ThreadShorter;

bans: BanShorter;

interactions: InteractionShorter;

voiceStates: VoiceStateShorter;

soundboards: SoundboardShorter;

invites: InvitesShorter;

debugger?: Logger;

logger: Logger;

langs: LangsHandler;

commands: CommandHandler;

components: ComponentHandler;

handleCommand: HandleCommand;

private _applicationId?;

private _botId?;

middlewares?: ClientMiddlewares;

readonly plugins: ResolvedPluginList;

shared: PluginSharedRegistry;

private pluginsSetupPromise?;

private pluginsClosePromise?;

private langBaseValues;

private pluginCacheDisabledCache;

private pluginBaseGatewayIntents;

private pluginComponentsBeforeLoadDepth;

get proxy(): APIRoutes;

set botId(id: string);

get botId(): string;

private bindPluginRestObserverProvider;

private bindPluginLangReload;

private refreshPluginCacheResources;

private reloadPluginMiddlewares;

private reloadPluginCommands;

private reloadPluginComponents;

private setupPlugins;

private applyPluginCommands;

private get loadedCommands();

private applyPluginComponents;

private createPluginCommandInstance;

private createPluginComponentInstance;

private runPluginHandlerCreators;

private matchesPluginHandlerKind;

private createPluginLoadedMetadata;

private emitPluginCustomEvent;

private shouldUploadCommands;

private syncCachePath;

private cachedCommandGuilds;

private emitUploadCommandsMetadata;

private applyPluginLangs;

constructor(options?: WorkerClientOptions);

setServices(rest: ServicesOptions): void;

setWorkerData(data: WorkerData): void;

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;

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>;

protected configureLogger(defaults: LoggerOptions, options?: LoggerOptions): void;

protected execute(..._options: unknown[]): Promise<void>;

reloadPluginContributions(): Promise<void>;

protected resolvePluginGatewayIntents(base?: GatewayIntentInput): number;

close(): Promise<void>;

Closes resources managed by the plugin lifecycle. This waits for in-flight plugin setup and runs `SeyfertPlugin.teardown`. It does not close the gateway, REST client, or cache adapter.

onInteractionRequest(rawBody: APIInteraction): Promise<{    headers: {        'Content-Type'?: string;    };    response: APIInteractionResponse | FormData;}>;

uploadCommands({ applicationId, cachePath }?: {    applicationId?: string;    cachePath?: string;}): Promise<void>;

loadCommands(dir?: string): Promise<void>;

loadComponents(dir?: string): Promise<void>;

loadLangs(dir?: string): Promise<void>;

t(locale: string): SeyfertLocale;

getRC<T extends InternalRuntimeConfigHTTP | InternalRuntimeConfig = InternalRuntimeConfigHTTP | InternalRuntimeConfig>(): Promise<ResolvedRC>;