cloudstorm 0.5.8 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,686 @@
-import Client from "./Client";
-import Constants from "./Constants";
-import Intents from "./Intents";
-export * from "./Types";
-export { Client, Constants, Intents };
-declare const _default: typeof import("./index");
-export default _default;
+import * as discord_typings from 'discord-typings';
+import * as snowtransfer from 'snowtransfer';
+import * as events from 'events';
+import { EventEmitter } from 'events';
+
+type IntentFlags = typeof flags;
+type IntentResolvable = number | Array<number> | keyof IntentFlags | Array<keyof IntentFlags>;
+declare const flags: {
+    GUILDS: number;
+    GUILD_MEMBERS: number;
+    GUILD_BANS: number;
+    GUILD_EMOJIS_AND_STICKERS: number;
+    GUILD_INTEGRATIONS: number;
+    GUILD_WEBHOOKS: number;
+    GUILD_INVITES: number;
+    GUILD_VOICE_STATES: number;
+    GUILD_PRESENCES: number;
+    GUILD_MESSAGES: number;
+    GUILD_MESSAGE_REACTIONS: number;
+    GUILD_MESSAGE_TYPING: number;
+    DIRECT_MESSAGES: number;
+    DIRECT_MESSAGE_REACTIONS: number;
+    DIRECT_MESSAGE_TYPING: number;
+    MESSAGE_CONTENT: number;
+    GUILD_SCHEDULED_EVENTS: number;
+};
+declare function resolve(bit?: IntentResolvable): number;
+declare const _default: {
+    flags: {
+        GUILDS: number;
+        GUILD_MEMBERS: number;
+        GUILD_BANS: number;
+        GUILD_EMOJIS_AND_STICKERS: number;
+        GUILD_INTEGRATIONS: number;
+        GUILD_WEBHOOKS: number;
+        GUILD_INVITES: number;
+        GUILD_VOICE_STATES: number;
+        GUILD_PRESENCES: number;
+        GUILD_MESSAGES: number;
+        GUILD_MESSAGE_REACTIONS: number;
+        GUILD_MESSAGE_TYPING: number;
+        DIRECT_MESSAGES: number;
+        DIRECT_MESSAGE_REACTIONS: number;
+        DIRECT_MESSAGE_TYPING: number;
+        MESSAGE_CONTENT: number;
+        GUILD_SCHEDULED_EVENTS: number;
+    };
+    privileged: number;
+    all: number;
+    non_privileged: number;
+    resolve: typeof resolve;
+};
+
+interface IWSMessage {
+    op: discord_typings.GatewayOpcode;
+    d?: any;
+    s?: number;
+    t?: discord_typings.GatewayEvent;
+}
+interface IGatewayMessage extends IWSMessage {
+    shard_id: number;
+}
+interface IClientOptions {
+    largeGuildThreshold?: number;
+    /**
+     * A note on "auto" sharding:
+     * "auto" will always start at 0 as there is no way to know the next available shard id.
+     * If you have more than one "cluster", you must specify an Array of shard ids. along with totalShards
+     */
+    shards?: "auto" | Array<number>;
+    /**
+     * Ignored and overwrote if using "auto" sharding.
+     * The total number of shards expected across all clusters.
+     */
+    totalShards?: number;
+    reconnect?: boolean;
+    initialPresence?: discord_typings.GatewayPresenceUpdate;
+    intents?: IntentResolvable;
+    snowtransferInstance?: snowtransfer.SnowTransfer;
+    ws?: IClientWSOptions;
+}
+interface IClientWSOptions {
+    compress?: boolean;
+    encoding?: "etf" | "json";
+}
+
+/**
+ * RatelimitBucket, used for ratelimiting the execution of functions.
+ */
+declare class RatelimitBucket {
+    fnQueue: Array<{
+        fn: () => unknown;
+        callback: () => unknown;
+        error: Error;
+    }>;
+    limit: number;
+    remaining: number;
+    limitReset: number;
+    defaultReset: number | undefined;
+    resetTimeout: NodeJS.Timeout | null;
+    /**
+     * Create a new Bucket.
+     * @param limit Number of functions that may be executed during the timeframe set in limitReset.
+     * @param limitReset Timeframe in milliseconds until the ratelimit resets.
+     * @param defaultReset If the bucket info does not provide default values, but provides remaining, this is the reset to use after the initial reset.
+     */
+    constructor(limit?: number, limitReset?: number, defaultReset?: number);
+    /**
+     * Queue a function to be executed.
+     * @param fn Function to be executed.
+     * @returns Result of the function if any.
+     */
+    queue<T>(fn: () => T): Promise<T>;
+    /**
+     * Check if there are any functions in the queue that haven't been executed yet.
+     */
+    private checkQueue;
+    /**
+     * Reset the remaining tokens to the base limit.
+     */
+    private resetRemaining;
+    /**
+     * Clear the current queue of events to be sent.
+     */
+    dropQueue(): void;
+}
+
+interface BWSEvents {
+    ws_open: [];
+    ws_close: [number, string];
+    ws_message: [IGatewayMessage];
+    debug_send: [IWSMessage];
+    debug: [string];
+}
+interface BetterWs {
+    addListener<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    emit<E extends keyof BWSEvents>(event: E, ...args: BWSEvents[E]): boolean;
+    eventNames(): Array<keyof BWSEvents>;
+    listenerCount(event: keyof BWSEvents): number;
+    listeners(event: keyof BWSEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    on<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    once<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    prependListener<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    prependOnceListener<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+    rawListeners(event: keyof BWSEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof BWSEvents): this;
+    removeListener<E extends keyof BWSEvents>(event: E, listener: (...args: BWSEvents[E]) => any): this;
+}
+/**
+ * Helper Class for simplifying the websocket connection to Discord.
+ */
+declare class BetterWs extends EventEmitter {
+    encoding: "etf" | "json";
+    compress: boolean;
+    address: string;
+    options: IClientWSOptions;
+    wsBucket: RatelimitBucket;
+    presenceBucket: RatelimitBucket;
+    private _socket;
+    private _internal;
+    private _connecting;
+    constructor(address: string, options: IClientWSOptions);
+    get status(): 1 | 2 | 3 | 4;
+    connect(): Promise<void>;
+    close(code: number, reason?: string): Promise<void>;
+    sendMessage(data: IWSMessage): Promise<void>;
+    private _write;
+    private _onError;
+    private _onClose;
+    private _onReadable;
+    private _processFrame;
+}
+
+interface ConnectorEvents {
+    queueIdentify: [number];
+    event: [IWSMessage];
+    ready: [boolean];
+    disconnect: [number, string, boolean];
+    stateChange: ["connecting" | "identifying" | "resuming" | "ready" | "disconnected"];
+}
+interface DiscordConnector {
+    addListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    emit<E extends keyof ConnectorEvents>(event: E, ...args: ConnectorEvents[E]): boolean;
+    eventNames(): Array<keyof ConnectorEvents>;
+    listenerCount(event: keyof ConnectorEvents): number;
+    listeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    on<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    once<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    prependListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+    rawListeners(event: keyof ConnectorEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ConnectorEvents): this;
+    removeListener<E extends keyof ConnectorEvents>(event: E, listener: (...args: ConnectorEvents[E]) => any): this;
+}
+/**
+ * Class used for acting based on received events.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class DiscordConnector extends EventEmitter {
+    id: number;
+    client: EventEmitter;
+    options: Omit<IClientOptions, "snowtransferInstance"> & {
+        token: string;
+        endpoint?: string;
+    };
+    reconnect: boolean;
+    betterWs: BetterWs;
+    heartbeatTimeout: NodeJS.Timeout | null;
+    heartbeatInterval: number;
+    _trace: string | null;
+    seq: number;
+    status: "connecting" | "identifying" | "resuming" | "ready" | "disconnected";
+    sessionId: string | null;
+    lastACKAt: number;
+    lastHeartbeatSend: number;
+    latency: number;
+    private _closing;
+    identifyAddress: string;
+    resumeAddress: string | null;
+    static readonly default: typeof DiscordConnector;
+    /**
+     * Create a new Discord Connector.
+     * @param id id of the shard that created this class.
+     * @param client Main client instance.
+     */
+    constructor(id: number, client: EventEmitter & {
+        options: Omit<IClientOptions, "snowtransferInstance"> & {
+            token: string;
+            endpoint?: string;
+        };
+    });
+    /**
+     * Connect to Discord.
+     */
+    connect(): Promise<void>;
+    /**
+     * Close the websocket connection and disconnect.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Called with a parsed Websocket message to execute further actions.
+     * @param message Message that was received.
+     */
+    private messageAction;
+    /**
+     * Reset this connector to be ready to resume or hard reconnect, then connect.
+     * @param resume Whether or not the client intends to send an OP 6 RESUME later.
+     */
+    private _reconnect;
+    /**
+     * Hard reset this connector.
+     */
+    private reset;
+    /**
+     * Clear the heart beat interval, set it to null and set the cached heartbeat_interval as 0.
+     */
+    private clearHeartBeat;
+    /**
+     * Send an OP 2 IDENTIFY to the gateway or an OP 6 RESUME if forceful identify is falsy.
+     * @param force Whether CloudStorm should send an OP 2 IDENTIFY even if there's a session that could be resumed.
+     */
+    identify(force?: boolean): Promise<void>;
+    /**
+     * Send an OP 6 RESUME to the gateway.
+     */
+    private resume;
+    /**
+     * Send an OP 1 HEARTBEAT to the gateway.
+     */
+    private heartbeat;
+    /**
+     * Handle dispatch events.
+     * @param message Message received from the websocket.
+     */
+    private handleDispatch;
+    /**
+     * Handle a close from the underlying websocket.
+     * @param code Websocket close code.
+     * @param reason Close reason if any.
+     */
+    private handleWsClose;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to the gateway.
+     * @param data Presence data to send.
+     */
+    presenceUpdate(data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to the gateway.
+     * @param data Voice state update data to send.
+     */
+    voiceStateUpdate(data: discord_typings.VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to the gateway.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data: discord_typings.GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+    /**
+     * Checks presence data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkPresenceData;
+    /**
+     * Checks voice state update data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkVoiceStateUpdateData;
+    /**
+     * Checks request guild members data and fills in missing elements.
+     * @param data Data to send.
+     * @returns Data after it's fixed/checked.
+     */
+    private _checkRequestGuildMembersData;
+}
+
+interface ShardEvents {
+    disconnect: [number, string, boolean];
+    ready: [boolean];
+    queueIdentify: [number];
+}
+interface Shard {
+    addListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    emit<E extends keyof ShardEvents>(event: E, ...args: ShardEvents[E]): boolean;
+    eventNames(): Array<keyof ShardEvents>;
+    listenerCount(event: keyof ShardEvents): number;
+    listeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    on<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    once<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+    rawListeners(event: keyof ShardEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ShardEvents): this;
+    removeListener<E extends keyof ShardEvents>(event: E, listener: (...args: ShardEvents[E]) => any): this;
+}
+/**
+ * Shard class, which provides a wrapper around the DiscordConnector with metadata like the id of the shard.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class Shard extends EventEmitter {
+    id: number;
+    client: EventEmitter & {
+        options: Omit<IClientOptions, "snowtransferInstance"> & {
+            token: string;
+            endpoint?: string;
+        };
+    };
+    ready: boolean;
+    connector: DiscordConnector;
+    /**
+     * Create a new Shard.
+     * @param id id of the shard.
+     * @param client Main class used for forwarding events.
+     */
+    constructor(id: number, client: Shard["client"]);
+    /**
+     * Time in ms it took for Discord to ackknowledge an OP 1 HEARTBEAT.
+     */
+    get latency(): number;
+    /**
+     * Create a new connection to Discord.
+     */
+    connect(): void;
+    /**
+     * Close the current connection to Discord.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord.
+     * @param data Data to send.
+     */
+    presenceUpdate(data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord.
+     * @param data Data to send
+     */
+    voiceStateUpdate(data: discord_typings.VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param data Data to send.
+     */
+    requestGuildMembers(data: discord_typings.GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+}
+
+/**
+ * Class used for managing shards for the user.
+ *
+ * This class is automatically instantiated by the library and is documented for reference.
+ */
+declare class ShardManager {
+    client: events.EventEmitter & {
+        options: Omit<IClientOptions, "snowtransferInstance"> & {
+            token: string;
+            endpoint?: string;
+        };
+    };
+    options: ShardManager["client"]["options"];
+    shards: {
+        [id: number]: Shard;
+    };
+    identifyBucket: RatelimitBucket;
+    concurrencyBucket: RatelimitBucket | null;
+    /**
+     * Create a new ShardManager.
+     */
+    constructor(client: ShardManager["client"]);
+    /**
+     * Create shard instances and add them to the connection queue.
+     */
+    spawn(): void;
+    /**
+     * Disconnect all shards facilitated by this manager.
+     */
+    disconnect(): void;
+    /**
+     * Add event listeners to a shard to that the manager can act on received events.
+     * @param shard Shard to add the event listeners to.
+     */
+    private _addListener;
+    /**
+     * Checks if all shards spawned by this manager are ready.
+     */
+    private _checkReady;
+    /**
+     * Checks if all shards spawned by this manager are disconnected.
+     */
+    private _checkDisconnect;
+    /**
+     * Update the status of all currently connected shards which have been spawned by this manager.
+     * @param data Data to send.
+     */
+    presenceUpdate(data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Update the status of a single connected shard which has been spawned by this manager.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    shardPresenceUpdate(shardId: number, data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    voiceStateUpdate(shardId: number, data: discord_typings.VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS with a certain shard.
+     * @param shardId id of the shard.
+     * @param data Data to send.
+     */
+    requestGuildMembers(shardId: number, data: discord_typings.GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+}
+
+interface ClientEvents {
+    debug: [string];
+    rawSend: [IWSMessage];
+    rawReceive: [IGatewayMessage];
+    event: [IGatewayMessage];
+    dispatch: [IGatewayMessage];
+    voiceStateUpdate: [IGatewayMessage];
+    shardReady: [{
+        id: number;
+        ready: boolean;
+    }];
+    error: [string];
+    ready: [];
+    disconnected: [];
+}
+interface Client {
+    addListener<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    emit<E extends keyof ClientEvents>(event: E, ...args: ClientEvents[E]): boolean;
+    eventNames(): Array<keyof ClientEvents>;
+    listenerCount(event: keyof ClientEvents): number;
+    listeners(event: keyof ClientEvents): Array<(...args: Array<any>) => any>;
+    off<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    on<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    once<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    prependListener<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    prependOnceListener<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+    rawListeners(event: keyof ClientEvents): Array<(...args: Array<any>) => any>;
+    removeAllListeners(event?: keyof ClientEvents): this;
+    removeListener<E extends keyof ClientEvents>(event: E, listener: (...args: ClientEvents[E]) => any): this;
+}
+/**
+ * Main class used for receiving events and interacting with the Discord gateway.
+ */
+declare class Client extends EventEmitter {
+    token: string;
+    options: Omit<IClientOptions, "snowtransferInstance"> & {
+        token: string;
+        endpoint?: string;
+    };
+    shardManager: ShardManager;
+    version: string;
+    private _restClient;
+    /**
+     * Create a new Client to connect to the Discord gateway.
+     * @param token Token received from creating a discord bot user, which will be used to connect to the gateway.
+     */
+    constructor(token: string, options?: IClientOptions);
+    /**
+     * Create one or more connections (depending on the selected amount of shards) to the Discord gateway.
+     * @returns This function returns a promise which is solely used for awaiting the getGateway() method's return value.
+     */
+    connect(): Promise<void>;
+    /**
+     * Method to grab initial connection info from Discord.
+     * Should only be called automatically by the lib unless you are a large bot with a max_concurrency not equal to 1.
+     * If you are a large bot, you should call this method at a rate of your own discretion to update your max_concurrency cached value to have up to date bucket info.
+     * @returns The amount of shards the bot should spawn if set to auto.
+     */
+    fetchConnectInfo(): Promise<number>;
+    /**
+     * Get the gateway endpoint to connect to.
+     * @returns String url with the Gateway Endpoint to connect to.
+     */
+    getGateway(): Promise<string>;
+    /**
+     * Get the GatewayData including recommended amount of shards and other helpful info.
+     * @returns Object with url and shards to use to connect to discord.
+     */
+    getGatewayBot(): Promise<{
+        url: string;
+        shards: number;
+        session_start_limit: discord_typings.SessionStartLimit;
+    }>;
+    /**
+     * Disconnect the bot gracefully,
+     * you will receive a 'disconnected' event once the ShardManager successfully closes all shard websocket connections.
+     */
+    disconnect(): void;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord, which updates the status of all shards facilitated by this client's ShardManager.
+     * @returns Promise that's resolved once all shards have sent the websocket payload.
+     *
+     * @example
+     * // Connect to Discord and set status to do not disturb and game to "Memes are Dreams".
+     * const CloudStorm = require("cloudstorm"); // CloudStorm also supports import statements.
+     * const token = "token";
+     * const client = new CloudStorm.Client(token);
+     * client.connect();
+     * client.once("ready", () => {
+     * 	// Client is connected to Discord and is ready, so we can update the status.
+     * 	client.presenceUpdate({ status: "dnd", game: { name: "Memes are Dreams" } });
+     * });
+     */
+    presenceUpdate(data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 3 PRESENCE_UPDATE to Discord, which updates the status of a single shard facilitated by this client's ShardManager.
+     * @param shardId id of the shard that should update it's status.
+     * @param data Presence data to send.
+     * @returns Promise that's resolved once the shard has sent the websocket payload.
+     *
+     * @example
+     * // Connect to Discord and set status to do not disturb and game to "Im shard 0".
+     * const CloudStorm = require("cloudstorm"); // CloudStorm also supports import statements.
+     * const token = "token";
+     * const client = new CloudStorm.Client(token);
+     * client.connect();
+     * client.once("ready", () => {
+     * 	// Client is connected to Discord and is ready, so we can update the status of shard 0.
+     * 	client.shardPresenceUpdate(0, { status: "dnd", game: { name: "Im shard 0" } });
+     * });
+     */
+    shardStatusUpdate(shardId: number, data: discord_typings.GatewayPresenceUpdate): Promise<void>;
+    /**
+     * Send an OP 4 VOICE_STATE_UPDATE to Discord. this does **not** allow you to send audio with CloudStorm itself,
+     * it just provides the necessary data for another application to send audio data to Discord.
+     * @param shardId id of the shard that should send the payload.
+     * @param data Voice state update data to send.
+     * @returns Promise that's resolved once the payload was sent to Discord.
+     *
+     * @example
+     * // Connect to Discord and join a voice channel
+     * const CloudStorm = require("cloudstorm"); // CloudStorm also supports import statements.
+     * const token = "token";
+     * const client = new CloudStorm.Client(token);
+     * client.connect();
+     * client.once("ready", () => {
+     * 	// Client is connected to Discord and is ready, so we can join a voice channel.
+     * 	// We will use shard 0 as the shard to send the payload.
+     * 	client.voiceStateUpdate(0, { guild_id: "id", channel_id: "id", self_mute: false, self_deaf: false });
+     * });
+     */
+    voiceStateUpdate(shardId: number, data: discord_typings.VoiceStateUpdatePayload & {
+        self_deaf?: boolean;
+        self_mute?: boolean;
+    }): Promise<void>;
+    /**
+     * Send an OP 8 REQUEST_GUILD_MEMBERS to Discord.
+     * @param shardId id of the shard that should send the payload.
+     * @param data Request guild members data to send.
+     * @returns Promise that's resolved once the payload was send to Discord.
+     *
+     * @example
+     * // Connect to Discord and request guild members.
+     * const CloudStorm = require("cloudstorm"); // CloudStorm also supports import statements.
+     * const token = "token";
+     * const client = new CloudStorm.Client(token);
+     * client.connect();
+     * client.once("ready", () => {
+     * 	// Client is connected to Discord and is ready, so we can send the request guild members payload.
+     * 	// We will use shard 0 as the shard to send the payload.
+     * 	client.requestGuildMembers(0, { guild_id: "id" });
+     * });
+     */
+    requestGuildMembers(shardId: number, data: discord_typings.GuildRequestMembersPayload & {
+        limit?: number;
+    }): Promise<void>;
+    /**
+     * Update the endpoint shard websockets will connect to.
+     * @param gatewayUrl Base gateway wss url to update the cached endpoint to.
+     */
+    private _updateEndpoint;
+}
+
+declare const Constants: {
+    GATEWAY_OP_CODES: {
+        /**
+         * Receive.
+         */
+        DISPATCH: 0;
+        /**
+         * Send/Receive.
+         */
+        HEARTBEAT: 1;
+        /**
+         * Send.
+         */
+        IDENTIFY: 2;
+        /**
+         * Send.
+         */
+        PRESENCE_UPDATE: 3;
+        /**
+         * Send.
+         */
+        VOICE_STATE_UPDATE: 4;
+        /**
+         * Send.
+         */
+        RESUME: 6;
+        /**
+         * Receive.
+         */
+        RECONNECT: 7;
+        /**
+         * Send.
+         */
+        REQUEST_GUILD_MEMBERS: 8;
+        /**
+         * Receive.
+         */
+        INVALID_SESSION: 9;
+        /**
+         * Receive.
+         */
+        HELLO: 10;
+        /**
+         * Receive.
+         */
+        HEARTBEAT_ACK: 11;
+    };
+    GATEWAY_VERSION: 10;
+};
+
+export { Client, Constants, IClientOptions, IClientWSOptions, IGatewayMessage, IWSMessage, _default as Intents, Shard, ShardManager };