meta-messenger.js 0.0.2 → 0.0.5

package/dist/index.d.ts

@@ -0,0 +1,1052 @@
+/**
+ * Event types emitted by the client
+ */
+type EventType = "ready" | "reconnected" | "disconnected" | "error" | "message" | "messageEdit" | "messageUnsend" | "reaction" | "typing" | "readReceipt" | "e2eeConnected" | "e2eeMessage" | "e2eeReaction" | "e2eeReceipt" | "deviceDataChanged";
+/**
+ * Base event interface
+ */
+interface BaseEvent {
+    type: EventType;
+    timestamp: number;
+}
+/**
+ * Ready event - emitted when connected to Messenger
+ */
+interface ReadyEvent extends BaseEvent {
+    type: "ready";
+    data: {
+        isNewSession: boolean;
+    };
+}
+/**
+ * Reconnected event
+ */
+interface ReconnectedEvent extends BaseEvent {
+    type: "reconnected";
+}
+/**
+ * Disconnected event
+ */
+interface DisconnectedEvent extends BaseEvent {
+    type: "disconnected";
+    data?: {
+        isE2EE?: boolean;
+    };
+}
+/**
+ * Error event
+ */
+interface ErrorEvent extends BaseEvent {
+    type: "error";
+    data: {
+        message: string;
+        code?: number;
+    };
+}
+/**
+ * Message event - new message received
+ */
+interface MessageEvent extends BaseEvent {
+    type: "message";
+    data: Message;
+}
+/**
+ * Message edit event
+ */
+interface MessageEditEvent extends BaseEvent {
+    type: "messageEdit";
+    data: {
+        messageId: string;
+        threadId: number;
+        newText: string;
+        editCount?: number;
+        timestampMs?: number;
+    };
+}
+/**
+ * Message unsend event
+ */
+interface MessageUnsendEvent extends BaseEvent {
+    type: "messageUnsend";
+    data: {
+        messageId: string;
+        threadId: number;
+    };
+}
+/**
+ * Reaction event
+ */
+interface ReactionEvent extends BaseEvent {
+    type: "reaction";
+    data: {
+        messageId: string;
+        threadId: number;
+        actorId: number;
+        reaction: string;
+        timestampMs: number;
+    };
+}
+/**
+ * Typing event
+ */
+interface TypingEvent extends BaseEvent {
+    type: "typing";
+    data: {
+        threadId: number;
+        senderId: number;
+        isTyping: boolean;
+    };
+}
+/**
+ * Read receipt event
+ */
+interface ReadReceiptEvent extends BaseEvent {
+    type: "readReceipt";
+    data: {
+        threadId: number;
+        readerId: number;
+        readWatermarkTimestampMs: number;
+        timestampMs?: number;
+    };
+}
+/**
+ * E2EE connected event
+ */
+interface E2EEConnectedEvent extends BaseEvent {
+    type: "e2eeConnected";
+}
+/**
+ * E2EE message event
+ */
+interface E2EEMessageEvent extends BaseEvent {
+    type: "e2eeMessage";
+    data: E2EEMessage;
+}
+/**
+ * E2EE reaction event
+ */
+interface E2EEReactionEvent extends BaseEvent {
+    type: "e2eeReaction";
+    data: {
+        messageId: string;
+        chatJid: string;
+        senderJid: string;
+        reaction: string;
+    };
+}
+/**
+ * E2EE receipt event
+ */
+interface E2EEReceiptEvent extends BaseEvent {
+    type: "e2eeReceipt";
+    data: {
+        type: string;
+        chat: string;
+        sender: string;
+        messageIds: string[];
+    };
+}
+/**
+ * Device data changed event - emitted when E2EE device data changes (only when using deviceData option)
+ */
+interface DeviceDataChangedEvent extends BaseEvent {
+    type: "deviceDataChanged";
+    data: {
+        deviceData: string;
+    };
+}
+/**
+ * Union of all events
+ */
+type ClientEvent = ReadyEvent | ReconnectedEvent | DisconnectedEvent | ErrorEvent | MessageEvent | MessageEditEvent | MessageUnsendEvent | ReactionEvent | TypingEvent | ReadReceiptEvent | E2EEConnectedEvent | E2EEMessageEvent | E2EEReactionEvent | E2EEReceiptEvent | DeviceDataChangedEvent;
+/**
+ * User information
+ */
+interface User {
+    id: number;
+    name: string;
+    username: string;
+}
+/**
+ * Thread/conversation
+ */
+interface Thread {
+    id: number;
+    type: ThreadType;
+    name: string;
+    lastActivityTimestampMs: number;
+    snippet: string;
+}
+/**
+ * Thread types
+ */
+declare enum ThreadType {
+    ONE_TO_ONE = 1,
+    GROUP = 2,
+    PAGE = 3,
+    MARKETPLACE = 4,
+    ENCRYPTED_ONE_TO_ONE = 7,
+    ENCRYPTED_GROUP = 8
+}
+/**
+ * Attachment type
+ */
+type AttachmentType = "image" | "video" | "audio" | "file" | "sticker" | "gif" | "voice" | "location" | "link";
+/**
+ * Media attachment
+ */
+interface Attachment {
+    type: AttachmentType;
+    url?: string;
+    fileName?: string;
+    mimeType?: string;
+    fileSize?: number;
+    width?: number;
+    height?: number;
+    duration?: number;
+    stickerId?: number;
+    latitude?: number;
+    longitude?: number;
+    previewUrl?: string;
+    mediaKey?: string;
+    mediaSha256?: string;
+    directPath?: string;
+}
+/**
+ * Reply info
+ */
+interface ReplyTo {
+    messageId: string;
+    senderId?: number;
+    text?: string;
+}
+/**
+ * Mention in message
+ */
+interface Mention {
+    userId: number;
+    offset: number;
+    length: number;
+    type?: "user" | "page" | "group";
+}
+/**
+ * Message
+ */
+interface Message {
+    id: string;
+    threadId: number;
+    senderId: number;
+    text: string;
+    timestampMs: number;
+    isE2EE?: boolean;
+    chatJid?: string;
+    senderJid?: string;
+    attachments?: Attachment[];
+    replyTo?: ReplyTo;
+    mentions?: Mention[];
+    isAdminMsg?: boolean;
+}
+/**
+ * E2EE Message
+ */
+interface E2EEMessage {
+    id: string;
+    threadId: number;
+    chatJid: string;
+    senderJid: string;
+    senderId: number;
+    text: string;
+    timestampMs: number;
+    attachments?: Attachment[];
+    replyTo?: ReplyTo;
+    mentions?: Mention[];
+}
+/**
+ * Initial data received on connect
+ */
+interface InitialData {
+    threads: Thread[];
+    messages: Message[];
+}
+/**
+ * Platform type
+ */
+type Platform = "facebook" | "messenger" | "instagram";
+/**
+ * Log level
+ */
+type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "none";
+/**
+ * Cookies required for authentication
+ */
+interface Cookies {
+    c_user: string;
+    xs: string;
+    datr?: string;
+    fr?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * Client options
+ */
+interface ClientOptions {
+    /** Platform to connect to (Only tested on Facebook) */
+    platform?: Platform;
+    /** Path to E2EE device store (if not using deviceData) */
+    devicePath?: string;
+    /** E2EE device data as JSON string (takes priority over devicePath) */
+    deviceData?: string;
+    /** Log level */
+    logLevel?: LogLevel;
+    /** Enable E2EE */
+    enableE2EE?: boolean;
+    /** Auto reconnect on disconnect */
+    autoReconnect?: boolean;
+}
+/**
+ * Send message options
+ */
+interface SendMessageOptions {
+    /** Text content */
+    text: string;
+    /** Reply to message ID */
+    replyToId?: string;
+    /** User IDs to mention */
+    mentions?: Array<{
+        userId: number;
+        offset: number;
+        length: number;
+    }>;
+}
+/**
+ * Send message result
+ */
+interface SendMessageResult {
+    messageId: string;
+    timestampMs: number;
+}
+/**
+ * Upload media result
+ */
+interface UploadMediaResult {
+    fbId: number;
+    filename: string;
+}
+/**
+ * Search user result
+ */
+interface SearchUserResult {
+    id: number;
+    name: string;
+    username: string;
+}
+/**
+ * Create thread result (1:1 chat)
+ */
+interface CreateThreadResult {
+    threadId: number;
+}
+/**
+ * User information
+ */
+interface UserInfo {
+    id: number;
+    name: string;
+    firstName?: string;
+    username?: string;
+    profilePictureUrl?: string;
+    isMessengerUser?: boolean;
+    isVerified?: boolean;
+    gender?: number;
+    canViewerMessage?: boolean;
+}
+
+declare class TypedEventEmitter<T> {
+    on<K extends keyof T>(event: K, listener: (...args: T[K] extends unknown[] ? T[K] : never) => void): this;
+    once<K extends keyof T>(event: K, listener: (...args: T[K] extends unknown[] ? T[K] : never) => void): this;
+    off<K extends keyof T>(event: K, listener: (...args: T[K] extends unknown[] ? T[K] : never) => void): this;
+    emit<K extends keyof T>(event: K, ...args: T[K] extends unknown[] ? T[K] : never): boolean;
+    removeAllListeners<K extends keyof T>(event?: K): this;
+}
+interface ClientEventMap {
+    ready: [{
+        isNewSession: boolean;
+    }];
+    fullyReady: [];
+    reconnected: [];
+    disconnected: [{
+        isE2EE?: boolean;
+    }];
+    error: [Error];
+    message: [Message];
+    messageEdit: [{
+        messageId: string;
+        threadId: number;
+        newText: string;
+        editCount?: number;
+        timestampMs?: number;
+    }];
+    messageUnsend: [{
+        messageId: string;
+        threadId: number;
+    }];
+    reaction: [{
+        messageId: string;
+        threadId: number;
+        actorId: number;
+        reaction: string;
+        timestampMs?: number;
+    }];
+    typing: [{
+        threadId: number;
+        senderId: number;
+        isTyping: boolean;
+    }];
+    readReceipt: [{
+        threadId: number;
+        readerId: number;
+        readWatermarkTimestampMs: number;
+        timestampMs?: number;
+    }];
+    e2eeConnected: [];
+    e2eeMessage: [E2EEMessage];
+    e2eeReaction: [{
+        messageId: string;
+        chatJid: string;
+        senderJid: string;
+        senderId?: number;
+        reaction: string;
+    }];
+    e2eeReceipt: [{
+        type: string;
+        chat: string;
+        sender: string;
+        messageIds: string[];
+    }];
+    deviceDataChanged: [{
+        deviceData: string;
+    }];
+}
+declare const Client_base: new () => TypedEventEmitter<ClientEventMap>;
+/**
+ * Demonstrates how to use the Client class to connect to Messenger and handle messages (E2EE disabled for simplicity).
+ *
+ * @example
+ * ```typescript
+ * import { Client } from 'meta-messenger.js'
+ *
+ * const client = new Client({
+ *     c_user: 'your_user_id',
+ *     xs: 'your_xs_cookie',
+ *     datr: 'your_datr_cookie',
+ *     fr: 'your_fr_cookie'
+ * })
+ *
+ * client.on('message', (message) => {
+ *     console.log('New message:', message)
+ *     if (message.text === 'ping') {
+ *         client.sendMessage(message.threadId, { text: 'pong' })
+ *     }
+ * })
+ *
+ * await client.connect()
+ * ```
+ */
+declare class Client extends Client_base {
+    private handle;
+    private options;
+    private cookies;
+    private _user;
+    private _initialData;
+    private eventLoopRunning;
+    private eventLoopAbort;
+    private _socketReady;
+    private _e2eeConnected;
+    private _fullyReadyEmitted;
+    private pendingEvents;
+    /**
+     * Create a new Messenger client
+     *
+     * @param cookies - Authentication cookies
+     * @param options - Client options
+     */
+    constructor(cookies: Cookies, options?: ClientOptions);
+    /**
+     * Get the current user info
+     */
+    get user(): User | null;
+    /**
+     * Get the current user's Facebook ID
+     */
+    get currentUserId(): number | null;
+    /**
+     * Get initial sync data (threads and messages)
+     */
+    get initialData(): InitialData | null;
+    /**
+     * Check if client is fully ready (socket ready + E2EE connected if enabled)
+     */
+    get isFullyReady(): boolean;
+    /**
+     * Check if client is connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Check if E2EE is connected
+     */
+    get isE2EEConnected(): boolean;
+    /**
+     * Connect to Messenger
+     *
+     * @returns User info and initial data
+     */
+    connect(): Promise<{
+        user: User;
+        initialData: InitialData;
+    }>;
+    /**
+     * Connect E2EE (end-to-end encryption)
+     * @warn This Promise is not resolved after the connection setup is completed; instead, it is resolved after the function finishes executing.\
+     * You should not rely on this Promise to wait for the E2EE connection to be fully established.
+     */
+    connectE2EE(): Promise<void>;
+    /**
+     * Disconnect from Messenger
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a text message
+     *
+     * @param threadId - Thread ID to send to
+     * @param options - Message options (text, reply, mentions)
+     * @returns Send result with message ID
+     */
+    sendMessage(threadId: number, options: SendMessageOptions | string): Promise<SendMessageResult>;
+    /**
+     * Send / Remove a reaction to a message
+     *
+     * @param threadId - Thread ID
+     * @param messageId - Message ID to react to
+     * @param emoji - Reaction emoji (to remove, simply omit this parameter)
+     */
+    sendReaction(threadId: number, messageId: string, emoji?: string): Promise<void>;
+    /**
+     * Edit a message
+     *
+     * @param messageId - Message ID to edit
+     * @param newText - New text content
+     */
+    editMessage(messageId: string, newText: string): Promise<void>;
+    /**
+     * Unsend/delete a message
+     *
+     * @param messageId - Message ID to unsend
+     */
+    unsendMessage(messageId: string): Promise<void>;
+    /**
+     * Send typing indicator
+     *
+     * @param threadId - Thread ID
+     * @param isTyping - Whether typing or not
+     * @param isGroup - Whether it's a group chat
+     */
+    sendTypingIndicator(threadId: number, isTyping?: boolean, isGroup?: boolean): Promise<void>;
+    /**
+     * Mark messages as read
+     *
+     * @param threadId - Thread ID
+     * @param watermarkTs - Timestamp to mark read up to (optional)
+     */
+    markAsRead(threadId: number, watermarkTs?: number): Promise<void>;
+    /**
+     * Upload media to Messenger
+     *
+     * @param threadId - Thread ID
+     * @param data - File data as Buffer
+     * @param filename - Filename
+     * @param mimeType - MIME type
+     * @param isVoice - Whether it's a voice message
+     * @returns Upload result with Facebook ID
+     */
+    uploadMedia(threadId: number, data: Buffer, filename: string, mimeType: string, isVoice?: boolean): Promise<UploadMediaResult>;
+    /**
+     * Send an image
+     *
+     * @param threadId - Thread ID
+     * @param data - Image data as Buffer
+     * @param filename - Filename
+     * @param caption - Optional caption
+     */
+    sendImage(threadId: number, data: Buffer, filename: string, caption?: string): Promise<SendMessageResult>;
+    /**
+     * Send a video
+     *
+     * @param threadId - Thread ID
+     * @param data - Video data as Buffer
+     * @param filename - Filename
+     * @param caption - Optional caption
+     */
+    sendVideo(threadId: number, data: Buffer, filename: string, caption?: string): Promise<SendMessageResult>;
+    /**
+     * Send a voice message
+     *
+     * @param threadId - Thread ID
+     * @param data - Audio data as Buffer
+     * @param filename - Filename
+     */
+    sendVoice(threadId: number, data: Buffer, filename: string): Promise<SendMessageResult>;
+    /**
+     * Send a file
+     *
+     * @param threadId - Thread ID
+     * @param data - File data as Buffer
+     * @param filename - Filename
+     * @param mimeType - MIME type
+     * @param caption - Optional caption
+     */
+    sendFile(threadId: number, data: Buffer, filename: string, mimeType: string, caption?: string): Promise<SendMessageResult>;
+    /**
+     * Send a sticker
+     *
+     * @param threadId - Thread ID
+     * @param stickerId - Sticker ID
+     */
+    sendSticker(threadId: number, stickerId: number): Promise<SendMessageResult>;
+    /**
+     * Create a 1:1 thread with a user
+     *
+     * @param userId - User ID to create thread with
+     * @returns Created thread info
+     */
+    createThread(userId: number): Promise<CreateThreadResult>;
+    /**
+     * Get detailed information about a user
+     *
+     * @param userId - User ID
+     * @returns User info
+     */
+    getUserInfo(userId: number): Promise<UserInfo>;
+    /**
+     * Set group photo/avatar
+     *
+     * @param threadId - Thread ID
+     * @param data - Image data as Buffer or base64 string
+     * @param mimeType - MIME type (e.g., 'image/jpeg', 'image/png')
+     *
+     * @warn Cannot remove group photo. Messenger web doesn't have a remove option?
+     */
+    setGroupPhoto(threadId: number, data: Buffer | string, mimeType?: string): Promise<void>;
+    /**
+     * Rename a group thread
+     *
+     * @param threadId - Thread ID
+     * @param newName - New name
+     */
+    renameThread(threadId: number, newName: string): Promise<void>;
+    /**
+     * Mute a thread
+     *
+     * @param threadId - Thread ID
+     * @param muteSeconds - Duration in seconds (-1 for forever, 0 to unmute)
+     */
+    muteThread(threadId: number, muteSeconds?: number): Promise<void>;
+    /**
+     * Unmute a thread
+     *
+     * @param threadId - Thread ID
+     */
+    unmuteThread(threadId: number): Promise<void>;
+    /**
+     * Delete a thread
+     *
+     * @param threadId - Thread ID
+     */
+    deleteThread(threadId: number): Promise<void>;
+    /**
+     * Search for users
+     *
+     * @param query - Search query
+     * @returns List of matching users
+     */
+    searchUsers(query: string): Promise<SearchUserResult[]>;
+    /**
+     * Send an E2EE message
+     *
+     * @param chatJid - Chat JID
+     * @param text - Message text
+     * @param options - Optional: replyToId and replyToSenderJid for replies
+     */
+    sendE2EEMessage(chatJid: string, text: string, options?: {
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Send / Remove an E2EE reaction
+     *
+     * @param chatJid - Chat JID
+     * @param messageId - Message ID
+     * @param senderJid - Sender JID
+     * @param emoji - Reaction emoji (To remove it, simply omit this parameter)
+     */
+    sendE2EEReaction(chatJid: string, messageId: string, senderJid: string, emoji?: string): Promise<void>;
+    /**
+     * Send E2EE typing indicator
+     *
+     * @param chatJid - Chat JID
+     * @param isTyping - Whether typing
+     */
+    sendE2EETyping(chatJid: string, isTyping?: boolean): Promise<void>;
+    /**
+     * Edit an E2EE message
+     *
+     * @param chatJid - Chat JID
+     * @param messageId - Message ID to edit
+     * @param newText - New message text
+     */
+    editE2EEMessage(chatJid: string, messageId: string, newText: string): Promise<void>;
+    /**
+     * Unsend/delete an E2EE message
+     *
+     * @param chatJid - Chat JID
+     * @param messageId - Message ID to unsend
+     */
+    unsendE2EEMessage(chatJid: string, messageId: string): Promise<void>;
+    /**
+     * Send an E2EE image
+     *
+     * @param chatJid - Chat JID
+     * @param data - Image data as Buffer
+     * @param mimeType - MIME type (e.g., image/jpeg, image/png)
+     * @param options - Optional caption, dimensions, and reply options
+     */
+    sendE2EEImage(chatJid: string, data: Buffer, mimeType?: string, options?: {
+        caption?: string;
+        width?: number;
+        height?: number;
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Send an E2EE video
+     *
+     * @param chatJid - Chat JID
+     * @param data - Video data as Buffer
+     * @param mimeType - MIME type (default: video/mp4)
+     * @param options - Optional caption, dimensions, duration, and reply options
+     */
+    sendE2EEVideo(chatJid: string, data: Buffer, mimeType?: string, options?: {
+        caption?: string;
+        width?: number;
+        height?: number;
+        duration?: number;
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Send an E2EE audio/voice message
+     *
+     * @param chatJid - Chat JID
+     * @param data - Audio data as Buffer
+     * @param mimeType - MIME type (default: audio/ogg)
+     * @param options - Optional PTT (push-to-talk/voice message), duration, and reply options
+     */
+    sendE2EEAudio(chatJid: string, data: Buffer, mimeType?: string, options?: {
+        ptt?: boolean;
+        duration?: number;
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Send an E2EE document/file
+     *
+     * @param chatJid - Chat JID
+     * @param data - File data as Buffer
+     * @param filename - Filename
+     * @param mimeType - MIME type
+     * @param options - Optional reply options
+     */
+    sendE2EEDocument(chatJid: string, data: Buffer, filename: string, mimeType: string, options?: {
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Send an E2EE sticker
+     *
+     * @param chatJid - Chat JID
+     * @param data - Sticker data as Buffer (WebP format)
+     * @param mimeType - MIME type (default: image/webp)
+     * @param options - Optional reply options
+     */
+    sendE2EESticker(chatJid: string, data: Buffer, mimeType?: string, options?: {
+        replyToId?: string;
+        replyToSenderJid?: string;
+    }): Promise<SendMessageResult>;
+    /**
+     * Get E2EE device data as JSON string
+     *
+     * Use this to persist device data externally (e.g., in a database)
+     *
+     * @returns Device data as JSON string
+     */
+    getDeviceData(): string;
+    private startEventLoop;
+    private stopEventLoop;
+    private checkFullyReady;
+    private handleEvent;
+    private emitEvent;
+    /**
+     * Unload the native library (for cleanup)
+     * @warn Any attempt to find or call a function from this library after unloading it will crash.
+     * @returns void
+     */
+    unloadLibrary(): void;
+}
+
+/**
+ * Utility class for cookie parsing and conversion
+ *
+ * Supports multiple cookie formats:
+ * - C3C UFC Utility / EditThisCookie (array of cookie objects)
+ * - Simple object format { name: value }
+ * - Netscape/HTTP cookie file format
+ * - Cookie header string format
+ * - Base64 encoded cookies
+ */
+
+/**
+ * Cookie object format (C3C UFC Utility / EditThisCookie style)
+ */
+interface CookieObject {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: number | string;
+    expirationDate?: number;
+    httpOnly?: boolean;
+    secure?: boolean;
+    sameSite?: string;
+    hostOnly?: boolean;
+    session?: boolean;
+}
+/**
+ * Static utility class for cookie operations
+ * @example
+ * ```typescript
+ * import { Utils } from 'meta-messenger.js'
+ *
+ * // Parse any cookie format
+ * const cookies = Utils.parseCookies(rawData)
+ *
+ * // Convert cookies to header string
+ * const header = Utils.toCookieString(cookies)
+ * ```
+ */
+declare class Utils extends null {
+    /**
+     * Parse cookies from various formats
+     * Automatically detects the format and parses accordingly
+     *
+     * @param input - Cookie data in any supported format
+     * @returns Parsed cookies object
+     */
+    static parseCookies(input: string | CookieObject[] | Record<string, string>): Cookies;
+    /**
+     * Parse cookies from C3C UFC Utility / EditThisCookie array format
+     *
+     * @param cookies - Array of cookie objects
+     * @returns Parsed cookies object
+     *
+     * @example
+     * ```typescript
+     * const cookies = Utils.fromCookieArray([
+     *     { name: 'c_user', value: '123456' },
+     *     { name: 'xs', value: 'abc...' }
+     * ])
+     * ```
+     */
+    static fromCookieArray(cookies: CookieObject[]): Cookies;
+    /**
+     * Parse cookies from cookie header string format
+     *
+     * @param cookieString - Cookie string (e.g., "name1=value1; name2=value2")
+     * @returns Parsed cookies object
+     *
+     * @example
+     * ```typescript
+     * const cookies = Utils.fromCookieString('c_user=123456; xs=abc...; datr=xyz...')
+     * ```
+     */
+    static fromCookieString(cookieString: string): Cookies;
+    /**
+     * Parse cookies from Netscape/HTTP cookie file format
+     *
+     * @param content - Netscape cookie file content
+     * @returns Parsed cookies object
+     *
+     * @example
+     * ```typescript
+     * const cookies = Utils.fromNetscape(`
+     * # Netscape HTTP Cookie File
+     * .facebook.com	TRUE	/	TRUE	1234567890	c_user	123456
+     * .facebook.com	TRUE	/	TRUE	1234567890	xs	abc...
+     * `)
+     * ```
+     */
+    static fromNetscape(content: string): Cookies;
+    /**
+     * Parse cookies from Base64 encoded string
+     *
+     * @param base64 - Base64 encoded cookie data
+     * @returns Parsed cookies object
+     */
+    static fromBase64(base64: string): Cookies;
+    /**
+     * Convert cookies object to cookie header string
+     *
+     * @param cookies - Cookies object
+     * @returns Cookie header string
+     *
+     * @example
+     * ```typescript
+     * const header = Utils.toCookieString({ c_user: '123456', xs: 'abc...' })
+     * // Returns: "c_user=123456; xs=abc..."
+     * ```
+     */
+    static toCookieString(cookies: Cookies): string;
+    /**
+     * Convert cookies object to array format (C3C UFC Utility style)
+     *
+     * @param cookies - Cookies object
+     * @param domain - Cookie domain (default: .facebook.com)
+     * @returns Array of cookie objects
+     *
+     * @example
+     * ```typescript
+     * const arr = Utils.toCookieArray({ c_user: '123456', xs: 'abc...' })
+     * ```
+     */
+    static toCookieArray(cookies: Cookies, domain?: string): CookieObject[];
+    /**
+     * Convert cookies object to Netscape format
+     *
+     * @param cookies - Cookies object
+     * @param domain - Cookie domain (default: .facebook.com)
+     * @returns Netscape cookie file content
+     */
+    static toNetscape(cookies: Cookies, domain?: string): string;
+    /**
+     * Convert cookies to Base64 encoded JSON
+     *
+     * @param cookies - Cookies object
+     * @returns Base64 encoded string
+     */
+    static toBase64(cookies: Cookies): string;
+    /**
+     * Filter cookies to only essential ones for Facebook/Messenger
+     *
+     * @param cookies - Cookies object
+     * @returns Filtered cookies with only essential keys
+     */
+    static filterEssential(cookies: Cookies): Cookies;
+    /**
+     * Validate that cookies contain required fields
+     *
+     * @param cookies - Cookies object
+     * @returns True if cookies are valid
+     */
+    static validate(cookies: Cookies): boolean;
+    /**
+     * Get missing required cookies
+     *
+     * @param cookies - Cookies object
+     * @returns Array of missing cookie names
+     */
+    static getMissing(cookies: Cookies): string[];
+    /**
+     * Check if a string is valid Base64
+     */
+    private static isBase64;
+}
+
+/**
+ * meta-messenger.js - TypeScript wrapper for Facebook Messenger with E2EE support
+ *
+ * @example
+ * ```typescript
+ * import { Client, login } from 'meta-messenger.js'
+ *
+ * // Method 1: Using Client class directly
+ * const client = new Client({
+ *     c_user: 'your_user_id',
+ *     xs: 'your_xs_cookie',
+ *     datr: 'your_datr_cookie',
+ *     fr: 'your_fr_cookie'
+ * })
+ *
+ * client.on('message', (message) => {
+ *     console.log('New message:', message)
+ *     if (message.text === 'ping') {
+ *         client.sendMessage(message.threadId, 'pong')
+ *     }
+ * })
+ *
+ * await client.connect()
+ *
+ * // Method 2: Using login function (facebook-chat-api style)
+ * const api = await login({
+ *     c_user: 'your_user_id',
+ *     xs: 'your_xs_cookie',
+ *     datr: 'your_datr_cookie',
+ *     fr: 'your_fr_cookie'
+ * })
+ *
+ * api.on('message', (message) => {
+ *     console.log('Got message:', message.text)
+ * })
+ * ```
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Login to Facebook Messenger (E2EE disabled for simplicity)
+ *
+ * @param cookies - Authentication cookies
+ * @param options - Client options
+ * @returns Connected client instance
+ *
+ * @example
+ * ```typescript
+ * const api = await login({
+ *     c_user: 'your_user_id',
+ *     xs: 'your_xs_cookie',
+ *     datr: 'your_datr_cookie',
+ *     fr: 'your_fr_cookie'
+ * })
+ *
+ * console.log('Logged in as:', api.user?.name)
+ *
+ * api.on('message', async (message) => {
+ *     if (message.senderId !== api.currentUserId) {
+ *         await api.sendMessage(message.threadId, 'Hello!')
+ *     }
+ * })
+ * ```
+ */
+declare function login(cookies: Cookies, options?: ClientOptions): Promise<Client>;
+/**
+ * Create a client without connecting
+ *
+ * @param cookies - Authentication cookies
+ * @param options - Client options
+ * @returns Client instance (not connected)
+ */
+declare function createClient(cookies: Cookies, options?: ClientOptions): Client;
+declare const _default: {
+    Client: typeof Client;
+    login: typeof login;
+    createClient: typeof createClient;
+};
+
+export { type BaseEvent, Client, type ClientEvent, type ClientEventMap, type ClientOptions, type CookieObject, type Cookies, type CreateThreadResult, type DisconnectedEvent, type E2EEConnectedEvent, type E2EEMessage, type E2EEMessageEvent, type E2EEReactionEvent, type E2EEReceiptEvent, type ErrorEvent, type EventType, type InitialData, type LogLevel, type Message, type MessageEditEvent, type MessageEvent, type MessageUnsendEvent, type Platform, type ReactionEvent, type ReadyEvent, type ReconnectedEvent, type SearchUserResult, type SendMessageOptions, type SendMessageResult, type Thread, ThreadType, type TypingEvent, type UploadMediaResult, type User, type UserInfo, Utils, createClient, _default as default, login };