@cexy/hoonfca 1.0.1 → 1.0.2

package/src/engine/models/setOptions.js

@@ -1,88 +0,0 @@
-"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

@@ -1,109 +0,0 @@
-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

@@ -1,498 +0,0 @@
-/// <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;
-}