Function makeMongoStore

Returns {
    bind: ((ev) => void);
    chats: Collection<Chat>;
    contacts: Collection<Contact>;
    fetchGroupMetadata: ((jid, sock) => Promise<GroupMetadata>);
    fetchImageUrl: ((jid, sock) => Promise<undefined | null | string>);
    fetchMessageReceipts: ((__namedParameters) => Promise<undefined | null | IUserReceipt[]>);
    fromJSON: ((json) => Promise<void>);
    getChatById: ((jid) => Promise<null | Chat>);
    getChatLabels: ((chatId) => Promise<null | WithId<LabelAssociation>>);
    getContactInfo: ((jid, socket) => Promise<null | Partial<Contact>>);
    getLabels: (() => ObjectRepository<Label>);
    getMessageLabels: ((messageId) => Promise<FindCursor<string>>);
    groupMetadata: {
        [_: string]: GroupMetadata;
    };
    labelAssociations: Collection<LabelAssociation>;
    labels: ObjectRepository<Label>;
    loadMessage: ((jid, id) => Promise<undefined | IWebMessageInfo>);
    loadMessages: ((jid, count, cursor) => Promise<IWebMessageInfo[]>);
    messages: {
        [_: string]: ReturnType<typeof makeMessagesDictionary>;
    };
    mostRecentMessage: ((jid) => Promise<IWebMessageInfo>);
    presences: {
        [id: string]: {
            [participant: string]: PresenceData;
        };
    };
    state: ConnectionState;
    toJSON: (() => {
        chats: Collection<Chat>;
        contacts: Collection<Contact>;
        labelAssociations: Collection<LabelAssociation>;
        labels: ObjectRepository<Label>;
        messages: {
            [_: string]: ReturnType<typeof makeMessagesDictionary>;
        };
    });
}

• bind: ((ev) => void)

  • • (ev): void

    • Parameters

      • ev: BaileysEventEmitter

      Returns void

• chats: Collection<Chat>

• contacts: Collection<Contact>

• fetchGroupMetadata: ((jid, sock) => Promise<GroupMetadata>)

  • • (jid, sock): Promise<GroupMetadata>

    • Parameters

      • jid: string

      • sock: undefined | {
            addChatLabel: ((jid, labelId) => Promise<void>);
            addMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            appPatch: ((patchCreate) => Promise<void>);
            assertSessions: ((jids, force) => Promise<boolean>);
            authState: {
                creds: AuthenticationCreds;
                keys: SignalKeyStoreWithTransaction;
            };
            chatModify: ((mod, jid) => Promise<void>);
            cleanDirtyBits: ((type, fromTimestamp?) => Promise<void>);
            end: ((error) => void);
            ev: BaileysBufferableEventEmitter;
            fetchBlocklist: (() => Promise<string[]>);
            fetchPrivacySettings: ((force?) => Promise<{
                [_: string]: string;
            }>);
            fetchStatus: ((jid) => Promise<undefined | {
                setAt: Date;
                status: undefined | string;
            }>);
            generateMessageTag: (() => string);
            getBusinessProfile: ((jid) => Promise<void | WABusinessProfile>);
            getCatalog: ((__namedParameters) => Promise<{
                nextPageCursor: undefined | string;
                products: Product[];
            }>);
            getCollections: ((jid?, limit?) => Promise<{
                collections: CatalogCollection[];
            }>);
            getOrderDetails: ((orderId, tokenBase64) => Promise<OrderDetails>);
            getPrivacyTokens: ((jids) => Promise<BinaryNode>);
            groupAcceptInvite: ((code) => Promise<undefined | string>);
            groupAcceptInviteV4: ((...args) => Promise<string>);
            groupCreate: ((subject, participants) => Promise<GroupMetadata>);
            groupFetchAllParticipating: (() => Promise<{
                [_: string]: GroupMetadata;
            }>);
            groupGetInviteInfo: ((code) => Promise<GroupMetadata>);
            groupInviteCode: ((jid) => Promise<undefined | string>);
            groupLeave: ((id) => Promise<void>);
            groupMetadata: ((jid) => Promise<GroupMetadata>);
            groupParticipantsUpdate: ((jid, participants, action) => Promise<{
                content: BinaryNode;
                jid: string;
                status: string;
            }[]>);
            groupRequestParticipantsList: ((jid) => Promise<{
                [key: string]: string;
            }[]>);
            groupRequestParticipantsUpdate: ((jid, participants, action) => Promise<{
                jid: string;
                status: string;
            }[]>);
            groupRevokeInvite: ((jid) => Promise<undefined | string>);
            groupSettingUpdate: ((jid, setting) => Promise<void>);
            groupToggleEphemeral: ((jid, ephemeralExpiration) => Promise<void>);
            groupUpdateDescription: ((jid, description?) => Promise<void>);
            groupUpdateSubject: ((jid, subject) => Promise<void>);
            logout: ((msg?) => Promise<void>);
            onUnexpectedError: ((err, msg) => void);
            onWhatsApp: ((...jids) => Promise<{
                exists: boolean;
                jid: string;
            }[]>);
            presenceSubscribe: ((toJid, tcToken?) => Promise<void>);
            processingMutex: {
                mutex<T>(code) => Promise<T>;
            };
            productCreate: ((create) => Promise<Product>);
            productDelete: ((productIds) => Promise<{
                deleted: number;
            }>);
            productUpdate: ((productId, update) => Promise<Product>);
            profilePictureUrl: ((jid, type?, timeoutMs?) => Promise<undefined | string>);
            query: ((node, timeoutMs?) => Promise<BinaryNode>);
            readMessages: ((keys) => Promise<void>);
            refreshMediaConn: ((forceGet?) => Promise<MediaConnInfo>);
            register: ((code) => Promise<ExistsResponse>);
            rejectCall: ((callId, callFrom) => Promise<void>);
            relayMessage: ((jid, message, __namedParameters) => Promise<string>);
            removeChatLabel: ((jid, labelId) => Promise<void>);
            removeMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            removeProfilePicture: ((jid) => Promise<void>);
            requestPairingCode: ((phoneNumber) => Promise<string>);
            requestRegistrationCode: ((registrationOptions?) => Promise<ExistsResponse>);
            resyncAppState: ((...args) => Promise<void>);
            sendMessage: ((jid, content, options?) => Promise<undefined | WebMessageInfo>);
            sendMessageAck: ((__namedParameters) => Promise<void>);
            sendNode: ((frame) => Promise<void>);
            sendPresenceUpdate: ((type, toJid?) => Promise<void>);
            sendRawMessage: ((data) => Promise<void>);
            sendReceipt: ((jid, participant, messageIds, type) => Promise<void>);
            sendReceipts: ((keys, type) => Promise<void>);
            sendRetryRequest: ((node, forceIncludeKeys?) => Promise<void>);
            signalRepository: SignalRepository;
            type: "md";
            updateBlockStatus: ((jid, action) => Promise<void>);
            updateDefaultDisappearingMode: ((duration) => Promise<void>);
            updateGroupsAddPrivacy: ((value) => Promise<void>);
            updateLastSeenPrivacy: ((value) => Promise<void>);
            updateMediaMessage: ((message) => Promise<IWebMessageInfo>);
            updateOnlinePrivacy: ((value) => Promise<void>);
            updateProfileName: ((name) => Promise<void>);
            updateProfilePicture: ((jid, content) => Promise<void>);
            updateProfilePicturePrivacy: ((value) => Promise<void>);
            updateProfileStatus: ((status) => Promise<void>);
            updateReadReceiptsPrivacy: ((value) => Promise<void>);
            updateStatusPrivacy: ((value) => Promise<void>);
            uploadPreKeys: ((count?) => Promise<void>);
            uploadPreKeysToServerIfRequired: (() => Promise<void>);
            upsertMessage: ((...args) => Promise<void>);
            user: undefined | Contact;
            waUploadToServer: WAMediaUploadFunction;
            waitForConnectionUpdate: ((check, timeoutMs?) => Promise<void>);
            waitForMessage: (<T>(msgId, timeoutMs?) => Promise<T>);
            waitForSocketOpen: (() => Promise<void>);
            ws: any;
        }

      Returns Promise<GroupMetadata>

• fetchImageUrl: ((jid, sock) => Promise<undefined | null | string>)

  • • (jid, sock): Promise<undefined | null | string>

    • Parameters

      • jid: string

      • sock: undefined | {
            addChatLabel: ((jid, labelId) => Promise<void>);
            addMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            appPatch: ((patchCreate) => Promise<void>);
            assertSessions: ((jids, force) => Promise<boolean>);
            authState: {
                creds: AuthenticationCreds;
                keys: SignalKeyStoreWithTransaction;
            };
            chatModify: ((mod, jid) => Promise<void>);
            cleanDirtyBits: ((type, fromTimestamp?) => Promise<void>);
            end: ((error) => void);
            ev: BaileysBufferableEventEmitter;
            fetchBlocklist: (() => Promise<string[]>);
            fetchPrivacySettings: ((force?) => Promise<{
                [_: string]: string;
            }>);
            fetchStatus: ((jid) => Promise<undefined | {
                setAt: Date;
                status: undefined | string;
            }>);
            generateMessageTag: (() => string);
            getBusinessProfile: ((jid) => Promise<void | WABusinessProfile>);
            getCatalog: ((__namedParameters) => Promise<{
                nextPageCursor: undefined | string;
                products: Product[];
            }>);
            getCollections: ((jid?, limit?) => Promise<{
                collections: CatalogCollection[];
            }>);
            getOrderDetails: ((orderId, tokenBase64) => Promise<OrderDetails>);
            getPrivacyTokens: ((jids) => Promise<BinaryNode>);
            groupAcceptInvite: ((code) => Promise<undefined | string>);
            groupAcceptInviteV4: ((...args) => Promise<string>);
            groupCreate: ((subject, participants) => Promise<GroupMetadata>);
            groupFetchAllParticipating: (() => Promise<{
                [_: string]: GroupMetadata;
            }>);
            groupGetInviteInfo: ((code) => Promise<GroupMetadata>);
            groupInviteCode: ((jid) => Promise<undefined | string>);
            groupLeave: ((id) => Promise<void>);
            groupMetadata: ((jid) => Promise<GroupMetadata>);
            groupParticipantsUpdate: ((jid, participants, action) => Promise<{
                content: BinaryNode;
                jid: string;
                status: string;
            }[]>);
            groupRequestParticipantsList: ((jid) => Promise<{
                [key: string]: string;
            }[]>);
            groupRequestParticipantsUpdate: ((jid, participants, action) => Promise<{
                jid: string;
                status: string;
            }[]>);
            groupRevokeInvite: ((jid) => Promise<undefined | string>);
            groupSettingUpdate: ((jid, setting) => Promise<void>);
            groupToggleEphemeral: ((jid, ephemeralExpiration) => Promise<void>);
            groupUpdateDescription: ((jid, description?) => Promise<void>);
            groupUpdateSubject: ((jid, subject) => Promise<void>);
            logout: ((msg?) => Promise<void>);
            onUnexpectedError: ((err, msg) => void);
            onWhatsApp: ((...jids) => Promise<{
                exists: boolean;
                jid: string;
            }[]>);
            presenceSubscribe: ((toJid, tcToken?) => Promise<void>);
            processingMutex: {
                mutex<T>(code) => Promise<T>;
            };
            productCreate: ((create) => Promise<Product>);
            productDelete: ((productIds) => Promise<{
                deleted: number;
            }>);
            productUpdate: ((productId, update) => Promise<Product>);
            profilePictureUrl: ((jid, type?, timeoutMs?) => Promise<undefined | string>);
            query: ((node, timeoutMs?) => Promise<BinaryNode>);
            readMessages: ((keys) => Promise<void>);
            refreshMediaConn: ((forceGet?) => Promise<MediaConnInfo>);
            register: ((code) => Promise<ExistsResponse>);
            rejectCall: ((callId, callFrom) => Promise<void>);
            relayMessage: ((jid, message, __namedParameters) => Promise<string>);
            removeChatLabel: ((jid, labelId) => Promise<void>);
            removeMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            removeProfilePicture: ((jid) => Promise<void>);
            requestPairingCode: ((phoneNumber) => Promise<string>);
            requestRegistrationCode: ((registrationOptions?) => Promise<ExistsResponse>);
            resyncAppState: ((...args) => Promise<void>);
            sendMessage: ((jid, content, options?) => Promise<undefined | WebMessageInfo>);
            sendMessageAck: ((__namedParameters) => Promise<void>);
            sendNode: ((frame) => Promise<void>);
            sendPresenceUpdate: ((type, toJid?) => Promise<void>);
            sendRawMessage: ((data) => Promise<void>);
            sendReceipt: ((jid, participant, messageIds, type) => Promise<void>);
            sendReceipts: ((keys, type) => Promise<void>);
            sendRetryRequest: ((node, forceIncludeKeys?) => Promise<void>);
            signalRepository: SignalRepository;
            type: "md";
            updateBlockStatus: ((jid, action) => Promise<void>);
            updateDefaultDisappearingMode: ((duration) => Promise<void>);
            updateGroupsAddPrivacy: ((value) => Promise<void>);
            updateLastSeenPrivacy: ((value) => Promise<void>);
            updateMediaMessage: ((message) => Promise<IWebMessageInfo>);
            updateOnlinePrivacy: ((value) => Promise<void>);
            updateProfileName: ((name) => Promise<void>);
            updateProfilePicture: ((jid, content) => Promise<void>);
            updateProfilePicturePrivacy: ((value) => Promise<void>);
            updateProfileStatus: ((status) => Promise<void>);
            updateReadReceiptsPrivacy: ((value) => Promise<void>);
            updateStatusPrivacy: ((value) => Promise<void>);
            uploadPreKeys: ((count?) => Promise<void>);
            uploadPreKeysToServerIfRequired: (() => Promise<void>);
            upsertMessage: ((...args) => Promise<void>);
            user: undefined | Contact;
            waUploadToServer: WAMediaUploadFunction;
            waitForConnectionUpdate: ((check, timeoutMs?) => Promise<void>);
            waitForMessage: (<T>(msgId, timeoutMs?) => Promise<T>);
            waitForSocketOpen: (() => Promise<void>);
            ws: any;
        }

      Returns Promise<undefined | null | string>

• fetchMessageReceipts: ((__namedParameters) => Promise<undefined | null | IUserReceipt[]>)

  • • (__namedParameters): Promise<undefined | null | IUserReceipt[]>

    • Parameters

      • __namedParameters: proto.IMessageKey

      Returns Promise<undefined | null | IUserReceipt[]>

• fromJSON: ((json) => Promise<void>)

  • • (json): Promise<void>

    • Parameters

      • json: {
            chats: Chat[];
            contacts: {
                [id: string]: Contact;
            };
            labelAssociations: LabelAssociation[];
            labels: {
                [labelId: string]: Label;
            };
            messages: {
                [id: string]: WAMessage[];
            };
        }

        • chats: Chat[]

        • contacts: {
              [id: string]: Contact;
          }

          • [id: string]: Contact

        • labelAssociations: LabelAssociation[]

        • labels: {
              [labelId: string]: Label;
          }

          • [labelId: string]: Label

        • messages: {
              [id: string]: WAMessage[];
          }

          • [id: string]: WAMessage[]

      Returns Promise<void>

• getChatById: ((jid) => Promise<null | Chat>)

  • • (jid): Promise<null | Chat>

    • Retrieves a chat object by its ID.

      Parameters

      • jid: string

        The ID of the chat.

      Returns Promise<null | Chat>

      A promise that resolves to the chat object if found, or null if not found.

• getChatLabels: ((chatId) => Promise<null | WithId<LabelAssociation>>)

  • • (chatId): Promise<null | WithId<LabelAssociation>>

    • Get labels for chat

      Parameters

      • chatId: string

      Returns Promise<null | WithId<LabelAssociation>>

      Label IDs

• getContactInfo: ((jid, socket) => Promise<null | Partial<Contact>>)

  • • (jid, socket): Promise<null | Partial<Contact>>

    • Parameters

      • jid: string

      • socket: {
            addChatLabel: ((jid, labelId) => Promise<void>);
            addMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            appPatch: ((patchCreate) => Promise<void>);
            assertSessions: ((jids, force) => Promise<boolean>);
            authState: {
                creds: AuthenticationCreds;
                keys: SignalKeyStoreWithTransaction;
            };
            chatModify: ((mod, jid) => Promise<void>);
            cleanDirtyBits: ((type, fromTimestamp?) => Promise<void>);
            end: ((error) => void);
            ev: BaileysBufferableEventEmitter;
            fetchBlocklist: (() => Promise<string[]>);
            fetchPrivacySettings: ((force?) => Promise<{
                [_: string]: string;
            }>);
            fetchStatus: ((jid) => Promise<undefined | {
                setAt: Date;
                status: undefined | string;
            }>);
            generateMessageTag: (() => string);
            getBusinessProfile: ((jid) => Promise<void | WABusinessProfile>);
            getCatalog: ((__namedParameters) => Promise<{
                nextPageCursor: undefined | string;
                products: Product[];
            }>);
            getCollections: ((jid?, limit?) => Promise<{
                collections: CatalogCollection[];
            }>);
            getOrderDetails: ((orderId, tokenBase64) => Promise<OrderDetails>);
            getPrivacyTokens: ((jids) => Promise<BinaryNode>);
            groupAcceptInvite: ((code) => Promise<undefined | string>);
            groupAcceptInviteV4: ((...args) => Promise<string>);
            groupCreate: ((subject, participants) => Promise<GroupMetadata>);
            groupFetchAllParticipating: (() => Promise<{
                [_: string]: GroupMetadata;
            }>);
            groupGetInviteInfo: ((code) => Promise<GroupMetadata>);
            groupInviteCode: ((jid) => Promise<undefined | string>);
            groupLeave: ((id) => Promise<void>);
            groupMetadata: ((jid) => Promise<GroupMetadata>);
            groupParticipantsUpdate: ((jid, participants, action) => Promise<{
                content: BinaryNode;
                jid: string;
                status: string;
            }[]>);
            groupRequestParticipantsList: ((jid) => Promise<{
                [key: string]: string;
            }[]>);
            groupRequestParticipantsUpdate: ((jid, participants, action) => Promise<{
                jid: string;
                status: string;
            }[]>);
            groupRevokeInvite: ((jid) => Promise<undefined | string>);
            groupSettingUpdate: ((jid, setting) => Promise<void>);
            groupToggleEphemeral: ((jid, ephemeralExpiration) => Promise<void>);
            groupUpdateDescription: ((jid, description?) => Promise<void>);
            groupUpdateSubject: ((jid, subject) => Promise<void>);
            logout: ((msg?) => Promise<void>);
            onUnexpectedError: ((err, msg) => void);
            onWhatsApp: ((...jids) => Promise<{
                exists: boolean;
                jid: string;
            }[]>);
            presenceSubscribe: ((toJid, tcToken?) => Promise<void>);
            processingMutex: {
                mutex<T>(code) => Promise<T>;
            };
            productCreate: ((create) => Promise<Product>);
            productDelete: ((productIds) => Promise<{
                deleted: number;
            }>);
            productUpdate: ((productId, update) => Promise<Product>);
            profilePictureUrl: ((jid, type?, timeoutMs?) => Promise<undefined | string>);
            query: ((node, timeoutMs?) => Promise<BinaryNode>);
            readMessages: ((keys) => Promise<void>);
            refreshMediaConn: ((forceGet?) => Promise<MediaConnInfo>);
            register: ((code) => Promise<ExistsResponse>);
            rejectCall: ((callId, callFrom) => Promise<void>);
            relayMessage: ((jid, message, __namedParameters) => Promise<string>);
            removeChatLabel: ((jid, labelId) => Promise<void>);
            removeMessageLabel: ((jid, messageId, labelId) => Promise<void>);
            removeProfilePicture: ((jid) => Promise<void>);
            requestPairingCode: ((phoneNumber) => Promise<string>);
            requestRegistrationCode: ((registrationOptions?) => Promise<ExistsResponse>);
            resyncAppState: ((...args) => Promise<void>);
            sendMessage: ((jid, content, options?) => Promise<undefined | WebMessageInfo>);
            sendMessageAck: ((__namedParameters) => Promise<void>);
            sendNode: ((frame) => Promise<void>);
            sendPresenceUpdate: ((type, toJid?) => Promise<void>);
            sendRawMessage: ((data) => Promise<void>);
            sendReceipt: ((jid, participant, messageIds, type) => Promise<void>);
            sendReceipts: ((keys, type) => Promise<void>);
            sendRetryRequest: ((node, forceIncludeKeys?) => Promise<void>);
            signalRepository: SignalRepository;
            type: "md";
            updateBlockStatus: ((jid, action) => Promise<void>);
            updateDefaultDisappearingMode: ((duration) => Promise<void>);
            updateGroupsAddPrivacy: ((value) => Promise<void>);
            updateLastSeenPrivacy: ((value) => Promise<void>);
            updateMediaMessage: ((message) => Promise<IWebMessageInfo>);
            updateOnlinePrivacy: ((value) => Promise<void>);
            updateProfileName: ((name) => Promise<void>);
            updateProfilePicture: ((jid, content) => Promise<void>);
            updateProfilePicturePrivacy: ((value) => Promise<void>);
            updateProfileStatus: ((status) => Promise<void>);
            updateReadReceiptsPrivacy: ((value) => Promise<void>);
            updateStatusPrivacy: ((value) => Promise<void>);
            uploadPreKeys: ((count?) => Promise<void>);
            uploadPreKeysToServerIfRequired: (() => Promise<void>);
            upsertMessage: ((...args) => Promise<void>);
            user: undefined | Contact;
            waUploadToServer: WAMediaUploadFunction;
            waitForConnectionUpdate: ((check, timeoutMs?) => Promise<void>);
            waitForMessage: (<T>(msgId, timeoutMs?) => Promise<T>);
            waitForSocketOpen: (() => Promise<void>);
            ws: any;
        }

        • addChatLabel: ((jid, labelId) => Promise<void>)

          • • (jid, labelId): Promise<void>

            • Adds label for the chats

              Parameters

              • jid: string

              • labelId: string

              Returns Promise<void>

        • addMessageLabel: ((jid, messageId, labelId) => Promise<void>)

          • • (jid, messageId, labelId): Promise<void>

            • Adds label for the message

              Parameters

              • jid: string

              • messageId: string

              • labelId: string

              Returns Promise<void>

        • appPatch: ((patchCreate) => Promise<void>)

          • • (patchCreate): Promise<void>

            • Parameters

              • patchCreate: WAPatchCreate

              Returns Promise<void>

        • assertSessions: ((jids, force) => Promise<boolean>)

          • • (jids, force): Promise<boolean>

            • Parameters

              • jids: string[]

              • force: boolean

              Returns Promise<boolean>

        • authState: {
              creds: AuthenticationCreds;
              keys: SignalKeyStoreWithTransaction;
          }

          • creds: AuthenticationCreds

          • keys: SignalKeyStoreWithTransaction

        • chatModify: ((mod, jid) => Promise<void>)

          • • (mod, jid): Promise<void>

            • modify a chat -- mark unread, read etc. lastMessages must be sorted in reverse chronologically requires the last messages till the last message received; required for archive & unread

              Parameters

              • mod: ChatModification

              • jid: string

              Returns Promise<void>

        • cleanDirtyBits: ((type, fromTimestamp?) => Promise<void>)

          • • (type, fromTimestamp?): Promise<void>

            • Parameters

              • type: "account_sync" | "groups"

              • Optional fromTimestamp: string | number

              Returns Promise<void>

        • end: ((error) => void)

          • • (error): void

            • Parameters

              • error: undefined | Error

              Returns void

        • ev: BaileysBufferableEventEmitter

        • fetchBlocklist: (() => Promise<string[]>)

          • • (): Promise<string[]>

            • Returns Promise<string[]>

        • fetchPrivacySettings: ((force?) => Promise<{
              [_: string]: string;
          }>)

          • • (force?): Promise<{
                  [_: string]: string;
              }>

            • Parameters

              • force: boolean = false

              Returns Promise<{
                  [_: string]: string;
              }>

        • fetchStatus: ((jid) => Promise<undefined | {
              setAt: Date;
              status: undefined | string;
          }>)

          • • (jid): Promise<undefined | {
                  setAt: Date;
                  status: undefined | string;
              }>

            • Parameters

              • jid: string

              Returns Promise<undefined | {
                  setAt: Date;
                  status: undefined | string;
              }>

        • generateMessageTag: (() => string)

          • • (): string

            • Returns string

        • getBusinessProfile: ((jid) => Promise<void | WABusinessProfile>)

          • • (jid): Promise<void | WABusinessProfile>

            • Parameters

              • jid: string

              Returns Promise<void | WABusinessProfile>

        • getCatalog: ((__namedParameters) => Promise<{
              nextPageCursor: undefined | string;
              products: Product[];
          }>)

          • • (__namedParameters): Promise<{
                  nextPageCursor: undefined | string;
                  products: Product[];
              }>

            • Parameters

              • __namedParameters: GetCatalogOptions

              Returns Promise<{
                  nextPageCursor: undefined | string;
                  products: Product[];
              }>

        • getCollections: ((jid?, limit?) => Promise<{
              collections: CatalogCollection[];
          }>)

          • • (jid?, limit?): Promise<{
                  collections: CatalogCollection[];
              }>

            • Parameters

              • Optional jid: string

              • limit: number = 51

              Returns Promise<{
                  collections: CatalogCollection[];
              }>

        • getOrderDetails: ((orderId, tokenBase64) => Promise<OrderDetails>)

          • • (orderId, tokenBase64): Promise<OrderDetails>

            • Parameters

              • orderId: string

              • tokenBase64: string

              Returns Promise<OrderDetails>

        • getPrivacyTokens: ((jids) => Promise<BinaryNode>)

          • • (jids): Promise<BinaryNode>

            • Parameters

              • jids: string[]

              Returns Promise<BinaryNode>

        • groupAcceptInvite: ((code) => Promise<undefined | string>)

          • • (code): Promise<undefined | string>

            • Parameters

              • code: string

              Returns Promise<undefined | string>

        • groupAcceptInviteV4: ((...args) => Promise<string>)

          • • (...args): Promise<string>

            • accept a GroupInviteMessage

              Parameters

              • Rest ...args: [key: string | proto.IMessageKey, inviteMessage: IGroupInviteMessage]

              Returns Promise<string>

        • groupCreate: ((subject, participants) => Promise<GroupMetadata>)

          • • (subject, participants): Promise<GroupMetadata>

            • Parameters

              • subject: string

              • participants: string[]

              Returns Promise<GroupMetadata>

        • groupFetchAllParticipating: (() => Promise<{
              [_: string]: GroupMetadata;
          }>)

          • • (): Promise<{
                  [_: string]: GroupMetadata;
              }>

            • Returns Promise<{
                  [_: string]: GroupMetadata;
              }>

        • groupGetInviteInfo: ((code) => Promise<GroupMetadata>)

          • • (code): Promise<GroupMetadata>

            • Parameters

              • code: string

              Returns Promise<GroupMetadata>

        • groupInviteCode: ((jid) => Promise<undefined | string>)

          • • (jid): Promise<undefined | string>

            • Parameters

              • jid: string

              Returns Promise<undefined | string>

        • groupLeave: ((id) => Promise<void>)

          • • (id): Promise<void>

            • Parameters

              • id: string

              Returns Promise<void>

        • groupMetadata: ((jid) => Promise<GroupMetadata>)

          • • (jid): Promise<GroupMetadata>

            • Parameters

              • jid: string

              Returns Promise<GroupMetadata>

        • groupParticipantsUpdate: ((jid, participants, action) => Promise<{
              content: BinaryNode;
              jid: string;
              status: string;
          }[]>)

          • • (jid, participants, action): Promise<{
                  content: BinaryNode;
                  jid: string;
                  status: string;
              }[]>

            • Parameters

              • jid: string

              • participants: string[]

              • action: ParticipantAction

              Returns Promise<{
                  content: BinaryNode;
                  jid: string;
                  status: string;
              }[]>

        • groupRequestParticipantsList: ((jid) => Promise<{
              [key: string]: string;
          }[]>)

          • • (jid): Promise<{
                  [key: string]: string;
              }[]>

            • Parameters

              • jid: string

              Returns Promise<{
                  [key: string]: string;
              }[]>

        • groupRequestParticipantsUpdate: ((jid, participants, action) => Promise<{
              jid: string;
              status: string;
          }[]>)

          • • (jid, participants, action): Promise<{
                  jid: string;
                  status: string;
              }[]>

            • Parameters

              • jid: string

              • participants: string[]

              • action: "reject" | "approve"

              Returns Promise<{
                  jid: string;
                  status: string;
              }[]>

        • groupRevokeInvite: ((jid) => Promise<undefined | string>)

          • • (jid): Promise<undefined | string>

            • Parameters

              • jid: string

              Returns Promise<undefined | string>

        • groupSettingUpdate: ((jid, setting) => Promise<void>)

          • • (jid, setting): Promise<void>

            • Parameters

              • jid: string

              • setting: "announcement" | "locked" | "not_announcement" | "unlocked"

              Returns Promise<void>

        • groupToggleEphemeral: ((jid, ephemeralExpiration) => Promise<void>)

          • • (jid, ephemeralExpiration): Promise<void>

            • Parameters

              • jid: string

              • ephemeralExpiration: number

              Returns Promise<void>

        • groupUpdateDescription: ((jid, description?) => Promise<void>)

          • • (jid, description?): Promise<void>

            • Parameters

              • jid: string

              • Optional description: string

              Returns Promise<void>

        • groupUpdateSubject: ((jid, subject) => Promise<void>)

          • • (jid, subject): Promise<void>

            • Parameters

              • jid: string

              • subject: string

              Returns Promise<void>

        • logout: ((msg?) => Promise<void>)

          • • (msg?): Promise<void>

            • logout & invalidate connection

              Parameters

              • Optional msg: string

              Returns Promise<void>

        • onUnexpectedError: ((err, msg) => void)

          • • (err, msg): void

            • log & process any unexpected errors

              Parameters

              • err: Error | Boom<any>

              • msg: string

              Returns void

        • onWhatsApp: ((...jids) => Promise<{
              exists: boolean;
              jid: string;
          }[]>)

          • • (...jids): Promise<{
                  exists: boolean;
                  jid: string;
              }[]>

            • Parameters

              • Rest ...jids: string[]

              Returns Promise<{
                  exists: boolean;
                  jid: string;
              }[]>

        • presenceSubscribe: ((toJid, tcToken?) => Promise<void>)

          • • (toJid, tcToken?): Promise<void>

            • Parameters

              • toJid: string

                the jid to subscribe to

              • Optional tcToken: Buffer

                token for subscription, use if present

              Returns Promise<void>

        • processingMutex: {
              mutex<T>(code) => Promise<T>;
          }

          • mutex:function

            • mutex<T>(code): Promise<T>

            • Type Parameters

              • T

              Parameters

              • code: (() => T | Promise<T>)

                • • (): T | Promise<T>

                  • Returns T | Promise<T>

              Returns Promise<T>

        • productCreate: ((create) => Promise<Product>)

          • • (create): Promise<Product>

            • Parameters

              • create: ProductCreate

              Returns Promise<Product>

        • productDelete: ((productIds) => Promise<{
              deleted: number;
          }>)

          • • (productIds): Promise<{
                  deleted: number;
              }>

            • Parameters

              • productIds: string[]

              Returns Promise<{
                  deleted: number;
              }>

        • productUpdate: ((productId, update) => Promise<Product>)

          • • (productId, update): Promise<Product>

            • Parameters

              • productId: string

              • update: ProductUpdate

              Returns Promise<Product>

        • profilePictureUrl: ((jid, type?, timeoutMs?) => Promise<undefined | string>)

          • • (jid, type?, timeoutMs?): Promise<undefined | string>

            • fetch the profile picture of a user/group type = "preview" for a low res picture type = "image for the high res picture"

              Parameters

              • jid: string

              • type: "image" | "preview" = 'preview'

              • Optional timeoutMs: number

              Returns Promise<undefined | string>

        • query: ((node, timeoutMs?) => Promise<BinaryNode>)

          • • (node, timeoutMs?): Promise<BinaryNode>

            • send a query, and wait for its response. auto-generates message ID if not provided

              Parameters

              • node: BinaryNode

              • Optional timeoutMs: number

              Returns Promise<BinaryNode>

        • readMessages: ((keys) => Promise<void>)

          • • (keys): Promise<void>

            • Bulk read messages. Keys can be from different chats & participants

              Parameters

              • keys: proto.IMessageKey[]

              Returns Promise<void>

        • refreshMediaConn: ((forceGet?) => Promise<MediaConnInfo>)

          • • (forceGet?): Promise<MediaConnInfo>

            • Parameters

              • forceGet: boolean = false

              Returns Promise<MediaConnInfo>

        • register: ((code) => Promise<ExistsResponse>)

          • • (code): Promise<ExistsResponse>

            • Parameters

              • code: string

              Returns Promise<ExistsResponse>

        • rejectCall: ((callId, callFrom) => Promise<void>)

          • • (callId, callFrom): Promise<void>

            • Parameters

              • callId: string

              • callFrom: string

              Returns Promise<void>

        • relayMessage: ((jid, message, __namedParameters) => Promise<string>)

          • • (jid, message, __namedParameters): Promise<string>

            • Parameters

              • jid: string

              • message: IMessage

              • __namedParameters: MessageRelayOptions

              Returns Promise<string>

        • removeChatLabel: ((jid, labelId) => Promise<void>)

          • • (jid, labelId): Promise<void>

            • Removes label for the chat

              Parameters

              • jid: string

              • labelId: string

              Returns Promise<void>

        • removeMessageLabel: ((jid, messageId, labelId) => Promise<void>)

          • • (jid, messageId, labelId): Promise<void>

            • Removes label for the message

              Parameters

              • jid: string

              • messageId: string

              • labelId: string

              Returns Promise<void>

        • removeProfilePicture: ((jid) => Promise<void>)

          • • (jid): Promise<void>

            • remove the profile picture for yourself or a group

              Parameters

              • jid: string

              Returns Promise<void>

        • requestPairingCode: ((phoneNumber) => Promise<string>)

          • • (phoneNumber): Promise<string>

            • Parameters

              • phoneNumber: string

              Returns Promise<string>

        • requestRegistrationCode: ((registrationOptions?) => Promise<ExistsResponse>)

          • • (registrationOptions?): Promise<ExistsResponse>

            • Parameters

              • Optional registrationOptions: RegistrationOptions

              Returns Promise<ExistsResponse>

        • resyncAppState: ((...args) => Promise<void>)

          • • (...args): Promise<void>

            • Parameters

              • Rest ...args: [collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean]

              Returns Promise<void>

        • sendMessage: ((jid, content, options?) => Promise<undefined | WebMessageInfo>)

          • • (jid, content, options?): Promise<undefined | WebMessageInfo>

            • Parameters

              • jid: string

              • content: AnyMessageContent

              • options: MiscMessageGenerationOptions = {}

              Returns Promise<undefined | WebMessageInfo>

        • sendMessageAck: ((__namedParameters) => Promise<void>)

          • • (__namedParameters): Promise<void>

            • Parameters

              • __namedParameters: BinaryNode

              Returns Promise<void>

        • sendNode: ((frame) => Promise<void>)

          • • (frame): Promise<void>

            • send a binary node

              Parameters

              • frame: BinaryNode

              Returns Promise<void>

        • sendPresenceUpdate: ((type, toJid?) => Promise<void>)

          • • (type, toJid?): Promise<void>

            • Parameters

              • type: WAPresence

              • Optional toJid: string

              Returns Promise<void>

        • sendRawMessage: ((data) => Promise<void>)

          • • (data): Promise<void>

            • send a raw buffer

              Parameters

              • data: Uint8Array | Buffer

              Returns Promise<void>

        • sendReceipt: ((jid, participant, messageIds, type) => Promise<void>)

          • • (jid, participant, messageIds, type): Promise<void>

            • generic send receipt function used for receipts of phone call, read, delivery etc.

              Parameters

              • jid: string

              • participant: undefined | string

              • messageIds: string[]

              • type: MessageReceiptType

              Returns Promise<void>

        • sendReceipts: ((keys, type) => Promise<void>)

          • • (keys, type): Promise<void>

            • Correctly bulk send receipts to multiple chats, participants

              Parameters

              • keys: proto.IMessageKey[]

              • type: MessageReceiptType

              Returns Promise<void>

        • sendRetryRequest: ((node, forceIncludeKeys?) => Promise<void>)

          • • (node, forceIncludeKeys?): Promise<void>

            • Parameters

              • node: BinaryNode

              • forceIncludeKeys: boolean = false

              Returns Promise<void>

        • signalRepository: SignalRepository

        • type: "md"

        • updateBlockStatus: ((jid, action) => Promise<void>)

          • • (jid, action): Promise<void>

            • Parameters

              • jid: string

              • action: "block" | "unblock"

              Returns Promise<void>

        • updateDefaultDisappearingMode: ((duration) => Promise<void>)

          • • (duration): Promise<void>

            • Parameters

              • duration: number

              Returns Promise<void>

        • updateGroupsAddPrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAPrivacyValue

              Returns Promise<void>

        • updateLastSeenPrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAPrivacyValue

              Returns Promise<void>

        • updateMediaMessage: ((message) => Promise<IWebMessageInfo>)

          • • (message): Promise<IWebMessageInfo>

            • Parameters

              • message: IWebMessageInfo

              Returns Promise<IWebMessageInfo>

        • updateOnlinePrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAPrivacyOnlineValue

              Returns Promise<void>

        • updateProfileName: ((name) => Promise<void>)

          • • (name): Promise<void>

            • Parameters

              • name: string

              Returns Promise<void>

        • updateProfilePicture: ((jid, content) => Promise<void>)

          • • (jid, content): Promise<void>

            • update the profile picture for yourself or a group

              Parameters

              • jid: string

              • content: WAMediaUpload

              Returns Promise<void>

        • updateProfilePicturePrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAPrivacyValue

              Returns Promise<void>

        • updateProfileStatus: ((status) => Promise<void>)

          • • (status): Promise<void>

            • update the profile status for yourself

              Parameters

              • status: string

              Returns Promise<void>

        • updateReadReceiptsPrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAReadReceiptsValue

              Returns Promise<void>

        • updateStatusPrivacy: ((value) => Promise<void>)

          • • (value): Promise<void>

            • Parameters

              • value: WAPrivacyValue

              Returns Promise<void>

        • uploadPreKeys: ((count?) => Promise<void>)

          • • (count?): Promise<void>

            • generates and uploads a set of pre-keys to the server

              Parameters

              • count: number = INITIAL_PREKEY_COUNT

              Returns Promise<void>

        • uploadPreKeysToServerIfRequired: (() => Promise<void>)

          • • (): Promise<void>

            • Returns Promise<void>

        • upsertMessage: ((...args) => Promise<void>)

          • • (...args): Promise<void>

            • Parameters

              • Rest ...args: [msg: IWebMessageInfo, type: MessageUpsertType]

              Returns Promise<void>

        • user: undefined | Contact

        • waUploadToServer: WAMediaUploadFunction

        • waitForConnectionUpdate: ((check, timeoutMs?) => Promise<void>)

          • • (check, timeoutMs?): Promise<void>

            • Waits for the connection to WA to reach a state

              Parameters

              • check: ((u) => undefined | boolean)

                • • (u): undefined | boolean

                  • Parameters

                    • u: Partial<ConnectionState>

                    Returns undefined | boolean

              • Optional timeoutMs: number

              Returns Promise<void>

        • waitForMessage: (<T>(msgId, timeoutMs?) => Promise<T>)

          • • <T>(msgId, timeoutMs?): Promise<T>

            • Wait for a message with a certain tag to be received

              Type Parameters

              • T

              Parameters

              • msgId: string

                the message tag to await

              • timeoutMs: undefined | number = defaultQueryTimeoutMs

                timeout after which the promise will reject

              Returns Promise<T>

        • waitForSocketOpen: (() => Promise<void>)

          • • (): Promise<void>

            • Returns Promise<void>

        • ws: any

      Returns Promise<null | Partial<Contact>>

• getLabels: (() => ObjectRepository<Label>)

  • • (): ObjectRepository<Label>

    • Get all available labels for profile

      Keep in mind that the list is formed from predefined tags and tags that were "caught" during their editing.

      Returns ObjectRepository<Label>

• getMessageLabels: ((messageId) => Promise<FindCursor<string>>)

  • • (messageId): Promise<FindCursor<string>>

    • Get labels for message

      Parameters

      • messageId: string

      Returns Promise<FindCursor<string>>

      Label IDs

• groupMetadata: {
      [_: string]: GroupMetadata;
  }

  • [_: string]: GroupMetadata

• labelAssociations: Collection<LabelAssociation>

• labels: ObjectRepository<Label>

• loadMessage: ((jid, id) => Promise<undefined | IWebMessageInfo>)

  • • (jid, id): Promise<undefined | IWebMessageInfo>

    • Parameters

      • jid: string

      • id: string

      Returns Promise<undefined | IWebMessageInfo>

• loadMessages: ((jid, count, cursor) => Promise<IWebMessageInfo[]>)

  • • (jid, count, cursor): Promise<IWebMessageInfo[]>

    • loads messages from the store, if not found -- uses the legacy connection

      Parameters

      • jid: string

      • count: number

      • cursor: WAMessageCursor

      Returns Promise<IWebMessageInfo[]>

• messages: {
      [_: string]: ReturnType<typeof makeMessagesDictionary>;
  }

  • [_: string]: ReturnType<typeof makeMessagesDictionary>

• mostRecentMessage: ((jid) => Promise<IWebMessageInfo>)

  • • (jid): Promise<IWebMessageInfo>

    • Parameters

      • jid: string

      Returns Promise<IWebMessageInfo>

• presences: {
      [id: string]: {
          [participant: string]: PresenceData;
      };
  }

  • [id: string]: {
        [participant: string]: PresenceData;
    }

    • [participant: string]: PresenceData

• state: ConnectionState

• toJSON: (() => {
      chats: Collection<Chat>;
      contacts: Collection<Contact>;
      labelAssociations: Collection<LabelAssociation>;
      labels: ObjectRepository<Label>;
      messages: {
          [_: string]: ReturnType<typeof makeMessagesDictionary>;
      };
  })

  • • (): {
          chats: Collection<Chat>;
          contacts: Collection<Contact>;
          labelAssociations: Collection<LabelAssociation>;
          labels: ObjectRepository<Label>;
          messages: {
              [_: string]: ReturnType<typeof makeMessagesDictionary>;
          };
      }

    • Returns {
          chats: Collection<Chat>;
          contacts: Collection<Contact>;
          labelAssociations: Collection<LabelAssociation>;
          labels: ObjectRepository<Label>;
          messages: {
              [_: string]: ReturnType<typeof makeMessagesDictionary>;
          };
      }

      • chats: Collection<Chat>

      • contacts: Collection<Contact>

      • labelAssociations: Collection<LabelAssociation>

      • labels: ObjectRepository<Label>

      • messages: {
            [_: string]: ReturnType<typeof makeMessagesDictionary>;
        }

        • [_: string]: ReturnType<typeof makeMessagesDictionary>