import WebSocket from "ws";
import Emittery from "emittery";
import { RequestInit } from "node-fetch";
import { Timestamp, Snowflake } from "@wilsonjs/constants";
import { ClientOptions } from "./models/ClientOptions";
import { Resolvable, EmojiCache, GuildCache, GuildMemberCache, MessageCache, RoleCache, UserCache, ChannelCache, AnyMessageable, MaskedCache } from "./cache";
import { User, Guild, Message, Emoji, Reaction, GuildMember, Role } from "./structures";
import { Querystring } from "./utils";
export declare type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
export declare enum HttpResponse {
    NoContent = ""
}
export interface HttpRequestOptions extends RequestInit {
    query?: Querystring;
    type?: string;
}
export interface ClientEvents {
    connect: Record<string, never>;
    ready: Record<string, never>;
    channelCreate: {
        channel: AnyMessageable;
    };
    channelUpdate: {
        old?: AnyMessageable;
        channel: AnyMessageable;
    };
    channelDelete: {
        channel: AnyMessageable;
    };
    channelPinsUpdate: {
        channel: AnyMessageable;
        timestamp: Timestamp;
    };
    guildCreate: {
        guild: Guild;
    };
    guildUpdate: {
        old?: Guild;
        guild: Guild;
    };
    guildDelete: {
        guild: Guild;
    };
    guildBanAdd: {
        guild: Guild;
        user: User;
    };
    guildBanRemove: {
        guild: Guild;
        user: User;
    };
    guildEmojisUpdate: {
        guild: Guild;
        emojis: MaskedCache<Emoji>;
    };
    guildIntegrationsUpdate: {
        guild: Guild;
    };
    guildMemberAdd: {
        member: GuildMember;
    };
    guildMemberRemove: {
        guild: Guild;
        user: User;
    };
    guildMemberUpdate: {
        old?: GuildMember;
        member: GuildMember;
    };
    guildMembersChunk: {
        members: MaskedCache<GuildMember>;
        notFound: Snowflake[];
        remaining: number;
        presences: unknown[];
        nonce: string;
    };
    guildRoleCreate: {
        role: Role;
    };
    guildRoleUpdate: {
        old: Role;
        role: Role;
    };
    guildRoleDelete: {
        role: Role;
    };
    inviteCreate: {
        invite: unknown;
    };
    inviteDelete: {
        invite: unknown;
    };
    message: {
        author: User;
        message: Message;
    };
    messageUpdate: {
        old?: Message;
        message: Message;
    };
    messageDelete: {
        message: Message;
    };
    messageDeleteBulk: {
        messages: MaskedCache<Message>;
    };
    messageReactionAdd: {
        user: User;
        message: Message;
        reaction: Reaction;
        emoji: Emoji;
    };
    messageReactionRemove: {
        user: User;
        message: Message;
        reaction: Reaction;
        emoji: Emoji;
    };
    messageReactionRemoveAll: {
        message: Message;
    };
    messageReactionRemoveEmoji: {
        message: Message;
        emoji: Emoji;
    };
    presenceUpdate: Record<string, never>;
    typingStart: {
        channel: AnyMessageable;
        timestamp: Timestamp;
        user: User;
        member?: GuildMember;
    };
    userUpdate: {
        old?: User;
        user: User;
    };
    voiceStateUpdate: Record<string, never>;
    voiceServerUpdate: {
        token: string;
        guild: Guild;
        endpoint: string;
    };
    webhooksUpdate: {
        guild: Guild;
        channel: AnyMessageable;
    };
    applicationCommandCreate: Record<string, never>;
    applicationCommandUpdate: Record<string, never>;
    applicationCommandDelete: Record<string, never>;
    interactionCreate: Record<string, never>;
}
export declare class WilsonClient extends Emittery<ClientEvents> {
    private _token;
    private _socket;
    private _inflate;
    private _heartbeat;
    private _heartbeat_interval;
    private _seqnum;
    private _sessionid;
    private _did_recieve_ack;
    options: ClientOptions;
    user: User;
    readonly users: UserCache;
    readonly roles: RoleCache;
    readonly guilds: GuildCache;
    readonly channels: ChannelCache;
    readonly members: GuildMemberCache;
    readonly emojis: EmojiCache;
    readonly messages: MessageCache;
    private handleMessage;
    constructor(options?: ClientOptions);
    get socket(): WebSocket;
    private send;
    disconnect(): Promise<void>;
    resume(): Promise<void>;
    private heartbeat;
    private identify;
    private handleEvent;
    private handlePayload;
    private _handleMessage;
    make<T = any>(method: HttpMethod, options: HttpRequestOptions, path: string, ...params: any[]): Promise<T>;
    connect(token: string): Promise<void>;
    getUser(resolvable: Resolvable<User>): Promise<User>;
    getGuild(resolvable: Resolvable<Guild>): Promise<Guild>;
}