import { Buffer } from 'node:buffer';
import { EventEmitter } from 'node:events';
import { type MediaType, type UploadMediaResult, type WasmWhatsAppClient } from 'whatsapp-rust-bridge';
import type { proto } from 'whatsapp-rust-bridge/proto-types';
import type { BinaryNode, ConnectionState, Contact, LIDMapping, ReachoutTimelockState, UserFacingSocketConfig, WAMessage } from '../Types/index.js';
import type { ILogger } from '../Utils/logger.js';
import type { MediaDownloadOptions } from '../Utils/messages-media.js';
declare const makeWASocket: (config: UserFacingSocketConfig) => {
    downloadMedia: <T extends "buffer" | "stream">(message: WAMessage, type: T, options?: MediaDownloadOptions) => Promise<T extends "buffer" ? Buffer<ArrayBufferLike> : import("stream").Readable>;
    newsletterCreate: (name: string, description?: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
    newsletterMetadata: (jid: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
    newsletterSubscribe: (jid: string) => Promise<import("whatsapp-rust-bridge").NewsletterMetadataResult>;
    newsletterUnsubscribe: (jid: string) => Promise<void>;
    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
    newsletterMute: (jid: string, mute: boolean) => Promise<void>;
    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
    fetchBlocklist: () => Promise<import("whatsapp-rust-bridge").BlocklistEntryResult[]>;
    sendPresence: (status: "available" | "unavailable") => Promise<void>;
    presenceSubscribe: (jid: string) => Promise<void>;
    sendChatState: (jid: string, state: "composing" | "recording" | "paused") => Promise<void>;
    pinChat: (jid: string, pin: boolean) => Promise<void>;
    muteChat: (jid: string, muteUntil?: number | null) => Promise<void>;
    archiveChat: (jid: string, archive: boolean) => Promise<void>;
    starMessage: (jid: string, messageId: string, star: boolean) => Promise<void>;
    chatModify: (mod: import("../index.js").ChatModification, jid: string) => Promise<void>;
    resyncAppState: (_collections?: readonly import("../index.js").WAPatchName[], _isInitialSync?: boolean) => Promise<void>;
    fetchDisappearingDuration: (..._jids: string[]) => Promise<undefined>;
    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
    setPushName: (name: string) => Promise<void>;
    updateProfileName: (name: string) => Promise<void>;
    getPushName: () => Promise<string>;
    getJid: () => Promise<string | undefined>;
    getLid: () => Promise<string | undefined>;
    updateProfilePicture: (jid: string, imgData: Uint8Array) => Promise<import("whatsapp-rust-bridge").ProfilePictureResult>;
    removeProfilePicture: (jid?: string) => Promise<import("whatsapp-rust-bridge").ProfilePictureResult>;
    updateProfileStatus: (status: string) => Promise<void>;
    onWhatsApp: (...jids: string[]) => Promise<import("./contacts.js").OnWhatsAppResult[]>;
    profilePictureUrl: (jid: string, type?: "preview" | "image") => Promise<string | undefined>;
    fetchUserInfo: (...jids: string[]) => Promise<Record<string, import("whatsapp-rust-bridge").UserInfoResult>>;
    groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
    groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
    groupLeave: (jid: string) => Promise<void>;
    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
    groupParticipantsUpdate: (jid: string, participants: string[], action: "add" | "remove" | "promote" | "demote") => Promise<import("whatsapp-rust-bridge").ParticipantChangeResult[]>;
    groupFetchAllParticipating: () => Promise<Record<string, import("../index.js").GroupMetadata>>;
    groupInviteCode: (jid: string) => Promise<string>;
    groupRevokeInvite: (jid: string) => Promise<string>;
    groupSettingUpdate: (jid: string, setting: "locked" | "announce" | "unlocked" | "announcement" | "not_announcement" | "membership_approval", value?: boolean) => Promise<void>;
    groupToggleEphemeral: (jid: string, expiration: number) => Promise<void>;
    groupAcceptInvite: (code: string) => Promise<string | undefined>;
    groupAcceptInviteV4: (key: {
        remoteJid?: string | null;
    }, msg: {
        inviteCode?: string | null;
        inviteExpiration?: number | null;
        groupJid?: string | null;
    }) => Promise<string | undefined>;
    groupGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
    groupRequestParticipantsList: (jid: string) => Promise<import("whatsapp-rust-bridge").MembershipRequestResult[]>;
    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<void>;
    updateMemberLabel: (jid: string, label: string) => Promise<void>;
    sendMessage: (jid: string, content: import("../index.js").AnyMessageContent, options?: Omit<import("../index.js").MessageGenerationOptions, "waClient" | "logger" | "userJid" | "mediaInNote">) => Promise<WAMessage>;
    updateMediaMessage: (message: WAMessage) => Promise<WAMessage>;
    relayMessage: (jid: string, message: proto.IMessage, { messageId, statusJidList }?: import("../index.js").MessageRelayOptions) => Promise<WAMessage>;
    readMessages: (keys: {
        remoteJid: string;
        id: string;
        participant?: string;
    }[]) => Promise<void>;
    sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../index.js").MessageReceiptType) => Promise<void>;
    sendReceipts: (keys: import("../index.js").WAMessageKey[], type: import("../index.js").MessageReceiptType) => Promise<void>;
    requestPlaceholderResend: (messageKey: import("../index.js").WAMessageKey, _msgData?: Partial<WAMessage>) => Promise<string | undefined>;
    ev: import("../index.js").BaileysEventEmitter;
    logger: ILogger;
    ws: EventEmitter<[never]>;
    type: "md";
    user: Contact | undefined;
    waClient: WasmWhatsAppClient | undefined;
    isConnected: boolean;
    isLoggedIn: boolean;
    authState: {
        creds: {
            me: Contact | undefined;
            account: proto.IADVSignedDeviceIdentity | undefined;
            platform: string | undefined;
            registered?: boolean | undefined;
            noiseKey?: import("../index.js").KeyPair;
            pairingEphemeralKeyPair?: import("../index.js").KeyPair;
            signedIdentityKey?: import("../index.js").KeyPair;
            signedPreKey?: import("../index.js").SignedKeyPair;
            registrationId?: number;
            advSecretKey?: string;
            signalIdentities?: import("../index.js").SignalIdentity[];
            myAppStateKeyId?: string;
            firstUnuploadedPreKeyId?: number;
            nextPreKeyId?: number;
            lastAccountSyncTimestamp?: number;
            processedHistoryMessages?: Array<{
                key: {
                    remoteJid?: string;
                    id?: string;
                };
                messageTimestamp?: number;
            }>;
            accountSyncCounter?: number;
            accountSettings?: import("../index.js").AccountSettings;
            pairingCode?: string;
            lastPropHash?: string;
            routingInfo?: Buffer;
            additionalData?: Record<string, unknown>;
        };
        keys: import("../index.js").SignalKeyStore | {
            get: () => Promise<{}>;
            set: (data: Record<string, Record<string, unknown> | undefined>) => Promise<void>;
            clear: () => Promise<void>;
        };
    };
    generateMessageTag: () => string;
    sendNode: (frame: BinaryNode) => Promise<void>;
    assertSessions: (jids: string[], force?: boolean) => Promise<boolean>;
    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<any>;
    waitForMessage: <T = BinaryNode>(msgId: string, timeoutMs?: number) => Promise<T>;
    query: (node: BinaryNode, timeoutMs?: number) => Promise<BinaryNode>;
    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
    createParticipantNodes: (jids: string[], message: proto.IMessage, extraAttrs?: BinaryNode["attrs"]) => Promise<{
        nodes: BinaryNode[];
        shouldIncludeDeviceIdentity: boolean;
    }>;
    signalRepository: {
        decryptMessage: (opts: {
            jid: string;
            type: "pkmsg" | "msg";
            ciphertext: Uint8Array;
        }) => Promise<Uint8Array<ArrayBufferLike>>;
        encryptMessage: (opts: {
            jid: string;
            data: Uint8Array;
        }) => Promise<{
            type: "pkmsg" | "msg";
            ciphertext: Uint8Array;
        }>;
        decryptGroupMessage: (opts: {
            group: string;
            authorJid: string;
            msg: Uint8Array;
        }) => Promise<Uint8Array<ArrayBufferLike>>;
        encryptGroupMessage: (opts: {
            group: string;
            data: Uint8Array;
            meId: string;
        }) => Promise<{
            senderKeyDistributionMessage: Uint8Array;
            ciphertext: Uint8Array;
        }>;
        processSenderKeyDistributionMessage: () => Promise<void>;
        injectE2ESession: () => Promise<void>;
        validateSession: (jid: string) => Promise<{
            exists: boolean;
            reason?: string;
        }>;
        jidToSignalProtocolAddress: (jid: string) => string;
        migrateSession: () => Promise<{
            migrated: number;
            skipped: number;
            total: number;
        }>;
        deleteSession: (jids: string[]) => Promise<void>;
        /**
         * Bidirectional LID ↔ PN lookup. Mirrors the upstream Baileys
         * `signalRepository.lidMapping` API.
         *
         * Pure passthrough to the bridge — `client.lidForPn` / `client.pnForLid`
         * delegate to the core's `get_lid_pn_entry`, which is cache-aside as
         * of whatsapp-rust PR #565: hits the in-memory `lid_pn_cache` first
         * and falls through to `backend.get_pn_mapping` / `get_lid_mapping`
         * (so JsStoreCallbacks-backed sessions resolve every persisted
         * mapping without warm-up needing a list primitive).
         */
        lidMapping: {
            getLIDForPN: (pn: string) => Promise<string | null>;
            getPNForLID: (lid: string) => Promise<string | null>;
            /**
             * Batch variant of `getLIDForPN`. Upstream Baileys' equivalent
             * coalesces in-flight requests and de-duplicates inputs; we run
             * the lookups in parallel and return the same `LIDMapping[]`
             * shape so callers (e.g. `process-message.ts`) keep working.
             *
             * Uses `Promise.allSettled` so one bridge-side failure (e.g.
             * malformed JID, transient cache miss) doesn't reject the
             * whole batch and lose every successful lookup. Failures are
             * logged at debug and skipped.
             *
             * Returns `null` (not `[]`) when the input list is empty, to
             * mirror upstream's "absent" sentinel.
             */
            getLIDsForPNs: (pns: string[]) => Promise<LIDMapping[] | null>;
            getPNsForLIDs: (lids: string[]) => Promise<LIDMapping[] | null>;
            /**
             * No-op shim. The Rust bridge auto-learns LID↔PN mappings inside
             * `decode_message` / `usync` and persists them through
             * `JsStoreCallbacks` — upstream Baileys callers (notably
             * `process-message.ts` re-feeding mappings from `historySync`)
             * keep type-checking, but we don't need to write back.
             *
             * Logs at debug so unexpected paths stay traceable.
             */
            storeLIDPNMappings: (pairs: LIDMapping[]) => Promise<void>;
        };
    };
    /** @deprecated Pre-key management is handled by the Rust bridge. */
    uploadPreKeys: () => Promise<void>;
    /** @deprecated Pre-key management is handled by the Rust bridge. */
    uploadPreKeysToServerIfRequired: () => Promise<void>;
    end: () => Promise<void>;
    logout: (msg?: string) => Promise<void>;
    waitForConnectionUpdate: (check: (update: Partial<ConnectionState>) => boolean, timeoutMs?: number) => Promise<void>;
    setAutoReconnect: (enabled: boolean) => void;
    /**
     * Update presence either globally (`available`/`unavailable`) or per-chat
     * (`composing`/`recording`/`paused`), matching upstream Baileys' overload.
     * Chat-state updates require `toJid`; omitting it raises `Boom(400)` so the
     * caller hears about the protocol mistake instead of the bridge silently
     * sending nothing.
     */
    sendPresenceUpdate: (presence: "available" | "unavailable" | "composing" | "recording" | "paused", toJid?: string) => Promise<void>;
    /**
     * Plaintext media upload helper, source-compatible with the upstream
     * Baileys `sock.waUploadToServer(buf, { mediaType })` shape so existing
     * callers (or `prepareWAMessageMedia(msg, { upload: sock.waUploadToServer })`)
     * keep working. Delegates to the bridge's encrypt + CDN-failover upload.
     */
    waUploadToServer: (data: Uint8Array | Buffer, opts: {
        mediaType: MediaType;
    }) => Promise<UploadMediaResult>;
    fetchPrivacySettings: () => Promise<any>;
    updatePrivacySetting: (category: string, value: string) => Promise<void>;
    updateLastSeenPrivacy: (value: string) => Promise<void>;
    updateOnlinePrivacy: (value: string) => Promise<void>;
    updateProfilePicturePrivacy: (value: string) => Promise<void>;
    updateStatusPrivacy: (value: string) => Promise<void>;
    updateReadReceiptsPrivacy: (value: string) => Promise<void>;
    updateGroupsAddPrivacy: (value: string) => Promise<void>;
    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
    rejectCall: (callId: string, callFrom: string) => Promise<void>;
    fetchStatus: (...jids: string[]) => Promise<{
        jid: string;
        status?: string;
    }[]>;
    /**
     * Fetch the account's current reachout-timelock state from the server.
     *
     * The same state is also pushed proactively via the
     * `NotificationUserReachoutTimelockUpdate` MEX notification, which is
     * surfaced on `connection.update.reachoutTimeLock` automatically. Use
     * this method to query on demand (e.g. on app start, or after a 463
     * nack hints that the timelock just kicked in).
     *
     * Emits the result on `connection.update.reachoutTimeLock` as a side
     * effect for parity with the push path. Returns the same state for
     * callers that prefer awaiting.
     */
    fetchReachoutTimelock: () => Promise<ReachoutTimelockState>;
    getBusinessProfile: (jid: string) => Promise<import("whatsapp-rust-bridge").BusinessProfileResult | undefined>;
    fetchMessageHistory: (count: number, oldestMsgKey: {
        remoteJid?: string | null;
        id?: string | null;
        fromMe?: boolean | null;
    }, oldestMsgTimestamp: number) => Promise<string>;
    groupMemberAddMode: (jid: string, mode: "admin_add" | "all_member_add") => Promise<void>;
    sendStatusMessage: (message: Record<string, unknown>, recipients: string[]) => Promise<string>;
};
export default makeWASocket;
//# sourceMappingURL=index.d.ts.map