@cexy/hoonfca 1.0.7 → 2.0.1

package/src/engine/models/setOptions.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const utils = require('../../utils');
+
+/**
+ * Sets global options for the API.
+ *
+ * @param {object} globalOptions The global options object to modify.
+ * @param {object} [options={}] New options to apply.
+ * @returns {Promise<void>}
+ */
+async function setOptions(globalOptions, options = {}) {
+    const optionHandlers = {
+        online: (value) => (globalOptions.online = Boolean(value)),
+        selfListen: (value) => (globalOptions.selfListen = Boolean(value)),
+        selfListenEvent: (value) => (globalOptions.selfListenEvent = value),
+        listenEvents: (value) => (globalOptions.listenEvents = Boolean(value)),
+        updatePresence: (value) => (globalOptions.updatePresence = Boolean(value)),
+        forceLogin: (value) => (globalOptions.forceLogin = Boolean(value)),
+        userAgent: (value) => (globalOptions.userAgent = value),
+        autoMarkDelivery: (value) => (globalOptions.autoMarkDelivery = Boolean(value)),
+        autoMarkRead: (value) => (globalOptions.autoMarkRead = Boolean(value)),
+        listenTyping: (value) => (globalOptions.listenTyping = Boolean(value)),
+        proxy(value) {
+            if (typeof value !== "string") {
+                delete globalOptions.proxy;
+                utils.setProxy();
+            } else {
+                globalOptions.proxy = value;
+                utils.setProxy(value);
+            }
+        },
+        autoReconnect: (value) => (globalOptions.autoReconnect = Boolean(value)),
+        emitReady: (value) => (globalOptions.emitReady = Boolean(value)),
+        randomUserAgent(value) {
+            globalOptions.randomUserAgent = Boolean(value);
+            if (value) {
+                globalOptions.userAgent = utils.randomUserAgent();
+            }
+        },
+        simulateTyping: (value) => (globalOptions.simulateTyping = Boolean(value)),
+        bypassRegion(value) {
+            if (value){
+                value = value.toUpperCase();
+            } 
+            globalOptions.bypassRegion = value;
+        },
+        maxConcurrentRequests(value) {
+            if (typeof value === 'number') {
+                globalOptions.maxConcurrentRequests = Math.floor(value);
+                utils.configureRateLimiter({ maxConcurrentRequests: globalOptions.maxConcurrentRequests });
+            }
+        },
+        maxRequestsPerMinute(value) {
+            if (typeof value === 'number') {
+                globalOptions.maxRequestsPerMinute = Math.floor(value);
+                utils.configureRateLimiter({ maxRequestsPerMinute: globalOptions.maxRequestsPerMinute });
+            }
+        },
+        requestCooldownMs(value) {
+            if (typeof value === 'number') {
+                globalOptions.requestCooldownMs = Math.floor(value);
+                utils.configureRateLimiter({ requestCooldownMs: globalOptions.requestCooldownMs });
+            }
+        },
+        errorCacheTtlMs(value) {
+            if (typeof value === 'number') {
+                globalOptions.errorCacheTtlMs = Math.floor(value);
+                utils.configureRateLimiter({ errorCacheTtlMs: globalOptions.errorCacheTtlMs });
+            }
+        },
+        stealthMode(value) {
+            const enable = Boolean(value);
+            globalOptions.stealthMode = enable;
+            if (enable) {
+                globalOptions.updatePresence = false;
+                globalOptions.online = false;
+                globalOptions.simulateTyping = false;
+                utils.configureRateLimiter({ maxConcurrentRequests: 2, maxRequestsPerMinute: 60 });
+            }
+        }
+    };
+    Object.entries(options).forEach(([key, value]) => {
+        if (optionHandlers[key]) optionHandlers[key](value);
+    });
+}
+
+module.exports = setOptions;

package/src/security/e2ee.js

@@ -0,0 +1,109 @@
+const crypto = require('crypto');
+
+function b64(buf) {
+  return Buffer.from(buf).toString('base64');
+}
+function b64d(str) {
+  return Buffer.from(str, 'base64');
+}
+function ensure(ctx) {
+  if (!ctx.e2ee) {
+    ctx.e2ee = { enabled: false, bot: null, peers: Object.create(null) };
+  }
+  return ctx.e2ee;
+}
+function genBot(ctx) {
+  const e = ensure(ctx);
+  if (!e.bot) {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('x25519');
+    e.bot = {
+      publicKey: publicKey.export({ type: 'spki', format: 'der' }),
+      privateKey: privateKey.export({ type: 'pkcs8', format: 'der' })
+    };
+  }
+}
+function enable(ctx) {
+  const e = ensure(ctx);
+  genBot(ctx);
+  e.enabled = true;
+}
+function disable(ctx) {
+  const e = ensure(ctx);
+  e.enabled = false;
+}
+function getPublicKey(ctx) {
+  genBot(ctx);
+  return b64(ensure(ctx).bot.publicKey);
+}
+function setPeerKey(ctx, threadID, peerPublicKeyB64) {
+  const e = ensure(ctx);
+  e.peers[String(threadID)] = peerPublicKeyB64;
+}
+function clearPeerKey(ctx, threadID) {
+  const e = ensure(ctx);
+  delete e.peers[String(threadID)];
+}
+function hasPeer(ctx, threadID) {
+  const e = ensure(ctx);
+  return !!e.peers[String(threadID)];
+}
+function isEnabled(ctx) {
+  const e = ensure(ctx);
+  return !!e.enabled;
+}
+function deriveKey(ctx, threadID) {
+  const e = ensure(ctx);
+  if (!e.bot || !e.peers[String(threadID)]) {
+    throw new Error('missing_keys');
+  }
+  const priv = crypto.createPrivateKey({ key: e.bot.privateKey, format: 'der', type: 'pkcs8' });
+  const pub = crypto.createPublicKey({ key: b64d(e.peers[String(threadID)]), format: 'der', type: 'spki' });
+  const shared = crypto.diffieHellman({ privateKey: priv, publicKey: pub });
+  const salt = Buffer.from(String(threadID));
+  return crypto.hkdfSync('sha256', shared, salt, Buffer.from('neokex-e2ee-v1'), 32);
+}
+function encrypt(ctx, threadID, plaintext) {
+  const key = deriveKey(ctx, threadID);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  const ct = Buffer.concat([cipher.update(Buffer.from(String(plaintext))), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const payload = {
+    v: 1,
+    alg: 'X25519+HKDF+AES-256-GCM',
+    n: b64(iv),
+    t: b64(tag),
+    c: b64(ct)
+  };
+  const body = Buffer.from(JSON.stringify(payload)).toString('base64');
+  return '.NKX-E2EE|' + body;
+}
+function decrypt(ctx, threadID, armored) {
+  const s = String(armored || '');
+  if (!s.startsWith('.NKX-E2EE|')) return null;
+  const raw = s.slice('.NKX-E2EE|'.length);
+  let payload;
+  try { payload = JSON.parse(Buffer.from(raw, 'base64').toString()); } catch (_) { return null; }
+  if (!payload || payload.v !== 1) return null;
+  const key = deriveKey(ctx, threadID);
+  const iv = b64d(payload.n);
+  const tag = b64d(payload.t);
+  const ct = b64d(payload.c);
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+  decipher.setAuthTag(tag);
+  const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+  return pt.toString();
+}
+
+module.exports = {
+  ensure,
+  enable,
+  disable,
+  isEnabled,
+  getPublicKey,
+  setPeerKey,
+  clearPeerKey,
+  hasPeer,
+  encrypt,
+  decrypt
+};

package/src/types/index.d.ts

@@ -0,0 +1,498 @@
+/// <reference types="node" />
+import { ReadStream } from "fs";
+import { EventEmitter } from "events";
+
+declare module "@neoaz07/nkxfca" {
+    export type UserID = string;
+    export type ThreadID = string;
+    export type MessageID = string;
+    export type Callback<T = any> = (err: any, result?: T) => void;
+
+    export interface Coordinates {
+        latitude: number;
+        longitude: number;
+    }
+
+    export interface Mention {
+        tag: string;
+        id: UserID;
+        fromIndex?: number;
+    }
+
+    export interface Reaction {
+        reaction: string;
+        userID: UserID;
+    }
+
+    export interface StickerPackInfo {
+        id: string;
+        name: string;
+        thumbnail?: string;
+    }
+
+    export interface StickerInfo {
+        type: "sticker";
+        ID: string;
+        url?: string;
+        animatedUrl?: string;
+        packID?: string;
+        label: string;
+        stickerID: string;
+    }
+
+    export interface AddedStickerPackInfo {
+        id: string;
+        name: string;
+        in_sticker_tray: boolean;
+        artist?: string;
+        preview_image?: { uri: string };
+        thumbnail_image?: { uri: string };
+    }
+
+    export interface CommentMessage {
+        body: string;
+        attachment?: ReadStream[];
+        mentions?: Mention[];
+        url?: string;
+        sticker?: string;
+    }
+
+    export interface CommentResult {
+        id: string;
+        url: string;
+        count: number;
+    }
+
+    export interface ShareResult {
+        postID: string;
+        url: string;
+    }
+
+    export interface Attachment {
+        type: "photo" | "animated_image" | "video" | "audio" | "file" | "sticker" | "share" | "location" | "unknown";
+        ID: string;
+        filename: string;
+        url?: string;
+        name?: string;
+    }
+
+    export interface PhotoAttachment extends Attachment {
+        type: "photo";
+        thumbnailUrl: string;
+        previewUrl: string;
+        previewWidth: number;
+        previewHeight: number;
+        largePreviewUrl: string;
+        largePreviewWidth: number;
+        largePreviewHeight: number;
+        width: number;
+        height: number;
+    }
+
+    export interface VideoAttachment extends Attachment {
+        type: "video";
+        duration: number;
+        width: number;
+        height: number;
+        previewUrl: string;
+        previewWidth: number;
+        previewHeight: number;
+        videoType: "file_attachment" | "native_video" | "unknown";
+    }
+
+    export interface AudioAttachment extends Attachment {
+        type: "audio";
+        duration: number;
+        audioType: string;
+        isVoiceMail: boolean;
+    }
+
+    export interface FileAttachment extends Attachment {
+        type: "file";
+        isMalicious: boolean;
+        contentType: string;
+    }
+
+    export interface StickerAttachment extends Attachment {
+        type: "sticker";
+        packID: string;
+        spriteUrl?: string;
+        spriteUrl2x?: string;
+        width: number;
+        height: number;
+        caption: string;
+        description: string;
+        frameCount: number;
+        frameRate: number;
+        framesPerRow: number;
+        framesPerCol: number;
+    }
+
+    export interface ShareAttachment extends Attachment {
+        type: "share";
+        title: string;
+        description?: string;
+        source?: string;
+        image?: string;
+        width?: number;
+        height?: number;
+        playable?: boolean;
+        subattachments?: any[];
+        properties: Record<string, any>;
+    }
+
+    export type AnyAttachment =
+        | PhotoAttachment
+        | VideoAttachment
+        | AudioAttachment
+        | FileAttachment
+        | StickerAttachment
+        | ShareAttachment;
+
+    export interface MessageReply {
+        messageID: MessageID;
+        senderID: UserID;
+        body: string;
+        attachments: AnyAttachment[];
+        timestamp: string;
+        isReply: true;
+    }
+
+    export interface Message {
+        type: "message";
+        senderID: UserID;
+        body: string;
+        threadID: ThreadID;
+        messageID: MessageID;
+        attachments: AnyAttachment[];
+        mentions: Record<string, string>;
+        timestamp: string;
+        isGroup: boolean;
+        participantIDs?: UserID[];
+        messageReply?: MessageReply;
+        isUnread?: boolean;
+        reactions?: Reaction[];
+    }
+
+    export interface Event {
+        type: "event";
+        threadID: ThreadID;
+        logMessageType: string;
+        logMessageData: any;
+        logMessageBody: string;
+        timestamp: string;
+        author: UserID;
+    }
+
+    export interface TypingIndicator {
+        type: "typ";
+        isTyping: boolean;
+        from: UserID;
+        threadID: ThreadID;
+        fromMobile: boolean;
+    }
+
+    export interface UnsendMessageEvent {
+        type: "unsend";
+        messageID: MessageID;
+        threadID: ThreadID;
+        senderID: UserID;
+        deletionTimestamp: string;
+    }
+
+    export interface EmojiEvent {
+        type: "change_thread_emoji";
+        threadID: ThreadID;
+        author: UserID;
+        emoji: string;
+    }
+
+    export interface GroupNameEvent {
+        type: "change_thread_name";
+        threadID: ThreadID;
+        author: UserID;
+        name: string;
+    }
+
+    export interface NicknameEvent {
+        type: "change_thread_nickname";
+        threadID: ThreadID;
+        author: UserID;
+        participantID: UserID;
+        nickname: string;
+    }
+
+    export type ListenEvent = Message | Event | TypingIndicator;
+
+    export interface UserInfo {
+        id: UserID;
+        name: string;
+        firstName: string;
+        lastName?: string;
+        vanity: string;
+        profileUrl: string;
+        profilePicUrl: string;
+        gender: string;
+        type: "user" | "page";
+        isFriend: boolean;
+        isBirthday: boolean;
+        bio?: string;
+        live_city?: string;
+        followers?: string;
+        following?: string;
+        coverPhoto?: string;
+    }
+
+    export interface ThreadInfo {
+        threadID: ThreadID;
+        threadName?: string;
+        participantIDs: UserID[];
+        userInfo: UserInfo[];
+        unreadCount: number;
+        messageCount: number;
+        imageSrc?: string;
+        timestamp: string;
+        muteUntil: number;
+        isGroup: boolean;
+        isArchived: boolean;
+        isSubscribed: boolean;
+        folder: string;
+        nicknames: Record<UserID, string>;
+        adminIDs: UserID[];
+        emoji?: string;
+        color?: string;
+        canReply: boolean;
+        inviteLink: {
+            enable: boolean;
+            link: string | null;
+        };
+    }
+
+    export interface MessageObject {
+        body?: string;
+        attachment?: ReadStream | ReadStream[];
+        sticker?: string;
+        emoji?: string;
+        emojiSize?: "small" | "medium" | "large";
+        mentions?: Mention[];
+        edit?: [string, number][];
+        url?: string;
+        location?: Coordinates;
+    }
+
+    export interface FriendInfo {
+        alternateName: string;
+        firstName: string;
+        gender: string;
+        userID: UserID;
+        isFriend: boolean;
+        fullName: string;
+        profilePicture: string;
+        type: string;
+        profileUrl: string;
+        vanity: string;
+        isBirthday: boolean;
+    }
+
+    export interface HealthStatus {
+        mqttConnected: boolean;
+        autoReconnect: boolean;
+        tokenRefresh: {
+            lastRefresh: number;
+            nextRefresh: number;
+            failureCount: number;
+        };
+        rateLimiter: {
+            activeRequests: number;
+            maxConcurrentRequests: number;
+            maxRequestsPerMinute: number;
+            threadCooldowns: number;
+            endpointCooldowns: number;
+            errorCacheSize: number;
+        } | null;
+    }
+
+    export interface API {
+        setOptions(options: LoginOptions): void;
+        getAppState(): any[];
+        getCurrentUserID(): UserID;
+        getHealthStatus(): HealthStatus;
+
+        listen(callback: (err: any, event: ListenEvent) => void): EventEmitter;
+
+        listenMqtt(callback: (err: any, event: ListenEvent) => void): void;
+
+        sendMessage(
+            message: string | MessageObject,
+            threadID: ThreadID,
+            replyToMessage?: MessageID | Callback<Message>,
+            callback?: Callback<Message>,
+        ): Promise<Message> | void;
+
+        sendMessageMqtt(
+            message: string | MessageObject,
+            threadID: ThreadID,
+            replyToMessage?: MessageID,
+            callback?: Callback<Message>,
+        ): void;
+
+        editMessage(text: string, messageID: MessageID, callback?: Callback): void;
+
+        unsendMessage(messageID: MessageID, threadID: ThreadID, callback?: Callback<UnsendMessageEvent>): Promise<UnsendMessageEvent>;
+
+        forwardMessage(messageID: MessageID, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        deleteMessage(messageIDs: MessageID | MessageID[], callback?: Callback): Promise<void>;
+
+        setMessageReaction(reaction: string, messageID: MessageID, callback?: Callback, forceCustomReaction?: boolean): Promise<void>;
+        setMessageReactionMqtt(reaction: string, messageID: MessageID, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        shareContact(text: string, senderID: UserID, threadID: ThreadID, callback?: Callback): void;
+        shareContact(senderID: UserID, threadID: ThreadID, callback?: Callback): void;
+        resolvePhotoUrl(photoID: string, callback?: Callback<string>): Promise<string>;
+
+        pinMessage(action: "pin" | "unpin", threadID: ThreadID, messageID: MessageID): Promise<any>;
+        pinMessage(action: "list", threadID: ThreadID): Promise<Message[]>;
+
+        markAsRead(threadID: ThreadID, read?: boolean, callback?: Callback): Promise<any>;
+        markAsReadAll(callback?: Callback): Promise<void>;
+        markAsSeen(timestamp?: number, callback?: Callback): Promise<void>;
+        markAsDelivered(threadID: ThreadID, messageID: MessageID, callback?: Callback): Promise<void>;
+
+        muteThread(threadID: ThreadID, muteSeconds: number, callback?: Callback): Promise<void>;
+
+        sendTypingIndicator(sendTyping: boolean, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        getThreadInfo(threadID: ThreadID, callback?: Callback<ThreadInfo>): Promise<ThreadInfo>;
+        getThreadInfo(threadID: ThreadID[], callback?: Callback<Record<ThreadID, ThreadInfo>>): Promise<Record<ThreadID, ThreadInfo>>;
+
+        getThreadList(limit: number, timestamp: number | null, tags: string[], callback?: Callback<ThreadInfo[]>): Promise<ThreadInfo[]>;
+        getThreadHistory(threadID: ThreadID, amount: number, timestamp: number | null, callback?: Callback<Message[]>): Promise<Message[]>;
+        getThreadPictures(threadID: ThreadID, offset: number, limit: number, callback?: Callback<string[]>): Promise<string[]>;
+
+        getMessage(messageID: MessageID, callback?: Callback<Message>): Promise<Message>;
+
+        getUserInfo(id: UserID, usePayload?: boolean, callback?: Callback<UserInfo>): Promise<UserInfo>;
+        getUserInfo(id: UserID[], usePayload?: boolean, callback?: Callback<Record<UserID, UserInfo>>): Promise<Record<UserID, UserInfo>>;
+        getUserInfoV2(id: UserID, callback?: Callback<UserInfo>): Promise<UserInfo>;
+        getUserID(name: string, callback?: Callback<{ userID: UserID; [key: string]: any }[]>): Promise<{ userID: UserID; [key: string]: any }[]>;
+
+        getFriendsList(callback?: Callback<Record<UserID, FriendInfo>>): Promise<Record<UserID, FriendInfo>>;
+
+        searchForThread(name: string, callback?: Callback<ThreadInfo[]>): Promise<ThreadInfo[]>;
+
+        createNewGroup(participantIDs: UserID[], groupName?: string, callback?: Callback<ThreadID>): Promise<ThreadID>;
+
+        addUserToGroup(userID: UserID, threadID: ThreadID, callback?: Callback): Promise<void>;
+        removeUserFromGroup(userID: UserID, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeAdminStatus(threadID: ThreadID, userID: UserID, adminStatus: boolean, callback?: Callback): Promise<void>;
+
+        changeGroupImage(image: ReadStream, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeThreadColor(color: string, threadID: ThreadID, callback?: Callback): Promise<void>;
+        changeThreadEmoji(emoji: string, threadID: ThreadID, callback?: Callback): Promise<void>;
+
+        changeArchivedStatus(threadID: ThreadID | ThreadID[], archive: boolean, callback?: Callback): Promise<void>;
+        changeBlockedStatus(userID: UserID, block: boolean, callback?: Callback): Promise<void>;
+
+        changeAvatar(image: ReadStream, callback?: Callback): Promise<void>;
+        changeBio(bio: string, publish: boolean, callback?: Callback): Promise<void>;
+
+        handleMessageRequest(threadID: ThreadID | ThreadID[], accept: boolean, callback?: Callback): Promise<void>;
+
+        deleteThread(threadID: ThreadID | ThreadID[], callback?: Callback): Promise<void>;
+
+        createPoll(title: string, threadID: ThreadID, options?: Record<string, boolean>, callback?: Callback): Promise<void>;
+
+        logout(callback?: (err: any) => void): Promise<void>;
+
+        addExternalModule(moduleObj: Record<string, Function>): void;
+        getAccess(authCode?: string, callback?: Callback<string>): Promise<string>;
+
+        httpGet(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+        httpPost(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+        httpPostFormData(url: string, form?: any, customHeader?: any, callback?: Callback<string>, notAPI?: boolean): Promise<string>;
+
+        getTheme(threadID: ThreadID): Promise<any[]>;
+        getThemeInfo(threadID: ThreadID): Promise<{ threadName?: string; color?: string; emoji?: string; [key: string]: any }>;
+        setThreadTheme(threadID: ThreadID, themeID: string, callback?: Callback): Promise<void>;
+        setThreadThemeMqtt(threadID: ThreadID, themeID: string, callback?: Callback): Promise<void>;
+        createAITheme(prompt: string): Promise<{ id: string; [key: string]: any }[]>;
+
+        follow(senderID: UserID, follow: boolean, callback?: Callback): void;
+        unfriend(userID: UserID, callback?: Callback): Promise<void>;
+        friend(userID: UserID, callback?: Callback): Promise<void>;
+
+        emoji(emoji: string, threadID?: ThreadID, callback?: Callback<EmojiEvent>): Promise<EmojiEvent>;
+        gcname(newName: string, threadID?: ThreadID, callback?: Callback<GroupNameEvent>): Promise<GroupNameEvent>;
+        nickname(nickname: string, threadID: ThreadID, participantID: UserID, callback?: Callback<NicknameEvent>): Promise<NicknameEvent>;
+        theme(newName: string, threadID?: ThreadID, callback?: Callback<GroupNameEvent>): Promise<GroupNameEvent>;
+
+        comment(msg: string | CommentMessage, postID: string, replyCommentID?: string, callback?: Callback<CommentResult>): Promise<CommentResult>;
+        share(text: string, postID: string, callback?: Callback<ShareResult>): Promise<ShareResult>;
+        share(postID: string, callback?: Callback<ShareResult>): Promise<ShareResult>;
+
+        stickers: {
+            search(query: string): Promise<StickerInfo[]>;
+            listPacks(): Promise<StickerPackInfo[]>;
+            getStorePacks(): Promise<StickerPackInfo[]>;
+            listAllPacks(): Promise<StickerPackInfo[]>;
+            addPack(packID: string): Promise<AddedStickerPackInfo>;
+            getStickersInPack(packID: string): Promise<StickerInfo[]>;
+            getAiStickers(options?: { limit?: number }): Promise<StickerInfo[]>;
+        };
+
+        e2ee: {
+            enable(): void;
+            disable(): void;
+            isEnabled(): boolean;
+            getPublicKey(): string;
+            setPeerKey(threadID: ThreadID, peerPublicKeyB64: string): void;
+            clearPeerKey(threadID: ThreadID): void;
+            hasPeer(threadID: ThreadID): boolean;
+            encrypt(threadID: ThreadID, text: string): string;
+            decrypt(threadID: ThreadID, armored: string): string | null;
+        };
+
+        getBotInfo(callback?: Callback): Promise<any>;
+        getUserInfoV2(userID: UserID, callback?: Callback<UserInfo>): Promise<UserInfo>;
+
+        [key: string]: any;
+    }
+
+    export interface LoginCredentials {
+        appState?: any;
+        email?: string;
+        password?: string;
+    }
+
+    export interface LoginOptions {
+        online?: boolean;
+        selfListen?: boolean;
+        listenEvents?: boolean;
+        updatePresence?: boolean;
+        forceLogin?: boolean;
+        autoMarkDelivery?: boolean;
+        autoMarkRead?: boolean;
+        listenTyping?: boolean;
+        proxy?: string;
+        autoReconnect?: boolean;
+        userAgent?: string;
+        emitReady?: boolean;
+        randomUserAgent?: boolean;
+        bypassRegion?: string;
+        simulateTyping?: boolean;
+        maxConcurrentRequests?: number;
+        maxRequestsPerMinute?: number;
+        requestCooldownMs?: number;
+        errorCacheTtlMs?: number;
+        stealthMode?: boolean;
+        persona?: "desktop" | "android" | "mobile";
+        logging?: boolean;
+    }
+
+    export function login(
+        credentials: LoginCredentials,
+        options: LoginOptions | Callback<API>,
+        callback?: Callback<API>
+    ): Promise<API> | void;
+}