@kelvdra/baileys 1.0.3 → 1.0.4

package/lib/Socket/mex.d.ts

@@ -0,0 +1,3 @@
+import type { BinaryNode } from '../WABinary/index.js';
+export declare const executeWMexQuery: <T>(variables: Record<string, unknown>, queryId: string, dataPath: string, query: (node: BinaryNode) => Promise<BinaryNode>, generateMessageTag: () => string) => Promise<T>;
+//# sourceMappingURL=mex.d.ts.map

package/lib/Socket/newsletter.d.ts

@@ -0,0 +1,149 @@
+import type { SocketConfig, WAMediaUpload } from '../Types/index.js';
+import type { NewsletterMetadata, NewsletterUpdate } from '../Types/index.js';
+export declare const makeNewsletterSocket: (config: SocketConfig) => {
+    newsletterCreate: (name: string, description?: string) => Promise<NewsletterMetadata>;
+    newsletterUpdate: (jid: string, updates: NewsletterUpdate) => Promise<unknown>;
+    newsletterSubscribers: (jid: string) => Promise<{
+        subscribers: number;
+    }>;
+    newsletterMetadata: (type: "invite" | "jid", key: string) => Promise<NewsletterMetadata | null>;
+    newsletterFollow: (jid: string) => Promise<unknown>;
+    newsletterUnfollow: (jid: string) => Promise<unknown>;
+    newsletterMute: (jid: string) => Promise<unknown>;
+    newsletterUnmute: (jid: string) => Promise<unknown>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<unknown>;
+    newsletterUpdateDescription: (jid: string, description: string) => Promise<unknown>;
+    newsletterUpdatePicture: (jid: string, content: WAMediaUpload) => Promise<unknown>;
+    newsletterRemovePicture: (jid: string) => Promise<unknown>;
+    newsletterReactMessage: (jid: string, serverId: string, reaction?: string) => Promise<void>;
+    newsletterFetchMessages: (jid: string, count: number, since: number, after: number) => Promise<any>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    } | null>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, newOwnerJid: string) => Promise<void>;
+    newsletterDemote: (jid: string, userJid: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
+    groupMetadata: (jid: string) => Promise<import("../index.js").GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<import("../index.js").GroupMetadata>;
+    groupLeave: (id: string) => Promise<void>;
+    groupUpdateSubject: (jid: string, subject: string) => Promise<void>;
+    groupRequestParticipantsList: (jid: string) => Promise<{
+        [key: string]: string;
+    }[]>;
+    groupRequestParticipantsUpdate: (jid: string, participants: string[], action: "approve" | "reject") => Promise<{
+        status: string;
+        jid: string | undefined;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../index.js").ParticipantAction) => Promise<{
+        status: string;
+        jid: string | undefined;
+        content: import("../index.js").BinaryNode;
+    }[]>;
+    groupUpdateDescription: (jid: string, description?: string) => Promise<void>;
+    groupInviteCode: (jid: string) => Promise<string | undefined>;
+    groupRevokeInvite: (jid: string) => Promise<string | undefined>;
+    groupAcceptInvite: (code: string) => Promise<string | undefined>;
+    groupRevokeInviteV4: (groupJid: string, invitedJid: string) => Promise<boolean>;
+    groupAcceptInviteV4: (key: string | import("../index.js").WAMessageKey, inviteMessage: import("../index.js").proto.Message.IGroupInviteMessage) => Promise<any>;
+    groupGetInviteInfo: (code: string) => Promise<import("../index.js").GroupMetadata>;
+    groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: "announcement" | "not_announcement" | "locked" | "unlocked") => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: "admin_add" | "all_member_add") => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: import("../index.js").GroupMetadata;
+    }>;
+    createCallLink: (type: "audio" | "video", event?: {
+        startTime: number;
+    }, timeoutMs?: number) => Promise<string | undefined>;
+    getBotListV2: () => Promise<import("../index.js").BotListInfo[]>;
+    processingMutex: {
+        mutex<T>(code: () => Promise<T> | T): Promise<T>;
+    };
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    upsertMessage: (msg: import("../index.js").WAMessage, type: import("../index.js").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../index.js").WAPatchCreate) => Promise<void>;
+    sendPresenceUpdate: (type: import("../index.js").WAPresence, toJid?: string) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: "preview" | "image", timeoutMs?: number) => Promise<string | undefined>;
+    fetchBlocklist: () => Promise<(string | undefined)[]>;
+    fetchStatus: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
+    fetchDisappearingDuration: (...jids: string[]) => Promise<import("../index.js").USyncQueryResultList[] | undefined>;
+    updateProfilePicture: (jid: string, content: WAMediaUpload, dimensions?: {
+        width: number;
+        height: number;
+    }) => Promise<void>;
+    removeProfilePicture: (jid: string) => Promise<void>;
+    updateProfileStatus: (status: string) => Promise<void>;
+    updateProfileName: (name: string) => Promise<void>;
+    updateBlockStatus: (jid: string, action: "block" | "unblock") => Promise<void>;
+    updateDisableLinkPreviewsPrivacy: (isPreviewsDisabled: boolean) => Promise<void>;
+    updateCallPrivacy: (value: import("../index.js").WAPrivacyCallValue) => Promise<void>;
+    updateMessagesPrivacy: (value: import("../index.js").WAPrivacyMessagesValue) => Promise<void>;
+    updateLastSeenPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../index.js").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../index.js").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../index.js").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../index.js").WAPrivacyGroupAddValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<import("../index.js").WABusinessProfile | void>;
+    resyncAppState: (collections: readonly ("critical_unblock_low" | "regular_high" | "regular_low" | "critical_block" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../index.js").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: number | string) => Promise<void>;
+    addOrEditContact: (jid: string, contact: import("../index.js").proto.SyncActionValue.IContactAction) => Promise<void>;
+    removeContact: (jid: string) => Promise<void>;
+    addLabel: (jid: string, labels: import("../Types/Label.js").LabelActionBody) => Promise<void>;
+    addChatLabel: (jid: string, labelId: string) => Promise<void>;
+    removeChatLabel: (jid: string, labelId: string) => Promise<void>;
+    addMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    removeMessageLabel: (jid: string, messageId: string, labelId: string) => Promise<void>;
+    star: (jid: string, messages: {
+        id: string;
+        fromMe?: boolean;
+    }[], star: boolean) => Promise<void>;
+    addOrEditQuickReply: (quickReply: import("../Types/Bussines.js").QuickReplyAction) => Promise<void>;
+    removeQuickReply: (timestamp: string) => Promise<void>;
+    type: "md";
+    ws: import("./Client/index.js").WebSocketClient;
+    ev: import("../index.js").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../index.js").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
+        flush(): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../index.js").AuthenticationCreds;
+        keys: import("../index.js").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../index.js").SignalRepositoryWithLIDStore;
+    user: import("../index.js").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: import("../index.js").BinaryNode, timeoutMs?: number) => Promise<any>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: import("../index.js").BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom, msg: string) => void;
+    uploadPreKeys: (count?: number, retryCount?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    digestKeyBundle: () => Promise<void>;
+    rotateSignedPreKey: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    wamBuffer: import("../index.js").BinaryInfo;
+    waitForConnectionUpdate: (check: (u: Partial<import("../index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+    executeUSyncQuery: (usyncQuery: import("../index.js").USyncQuery) => Promise<import("../index.js").USyncQueryResult | undefined>;
+    onWhatsApp: (...phoneNumber: string[]) => Promise<{
+        jid: string;
+        exists: boolean;
+    }[] | undefined>;
+};
+export type NewsletterSocket = ReturnType<typeof makeNewsletterSocket>;
+//# sourceMappingURL=newsletter.d.ts.map

package/lib/Socket/socket.d.ts

@@ -0,0 +1,53 @@
+import { Boom } from '@hapi/boom';
+import type { SocketConfig } from '../Types/index.js';
+import { type BinaryNode } from '../WABinary/index.js';
+import { BinaryInfo } from '../WAM/BinaryInfo.js';
+import { USyncQuery } from '../WAUSync/index.js';
+import { WebSocketClient } from './Client/index.js';
+/**
+ * Connects to WA servers and performs:
+ * - simple queries (no retry mechanism, wait for connection establishment)
+ * - listen to messages and emit events
+ * - query phone connection
+ */
+export declare const makeSocket: (config: SocketConfig) => {
+    type: "md";
+    ws: WebSocketClient;
+    ev: import("../Types/index.js").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types/index.js").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T>(work: (...args: A) => Promise<T>): (...args: A) => Promise<T>;
+        flush(): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types/index.js").AuthenticationCreds;
+        keys: import("../Types/index.js").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types/index.js").SignalRepositoryWithLIDStore;
+    readonly user: import("../Types/index.js").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: BinaryNode, timeoutMs?: number) => Promise<any>;
+    waitForMessage: <T>(msgId: string, timeoutMs?: number | undefined) => Promise<T | undefined>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: BinaryNode) => Promise<void>;
+    logout: (msg?: string) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | Boom, msg: string) => void;
+    uploadPreKeys: (count?: number, retryCount?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    digestKeyBundle: () => Promise<void>;
+    rotateSignedPreKey: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string, customPairingCode?: string) => Promise<string>;
+    wamBuffer: BinaryInfo;
+    /** Waits for the connection to WA to reach a state */
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types/index.js").ConnectionState>) => Promise<boolean | undefined>, timeoutMs?: number) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<any>;
+    executeUSyncQuery: (usyncQuery: USyncQuery) => Promise<import("../index.js").USyncQueryResult | undefined>;
+    onWhatsApp: (...phoneNumber: string[]) => Promise<{
+        jid: string;
+        exists: boolean;
+    }[] | undefined>;
+};
+//# sourceMappingURL=socket.d.ts.map

package/lib/Socket/socket.js

@@ -582,16 +582,17 @@ export const makeSocket = (config) => {
         }
         end(new Boom(msg || 'Intentional Logout', { statusCode: DisconnectReason.loggedOut }));
     };
-    const requestPairingCode = async (phoneNumber, code = "12345678") => {
-        authState.creds.pairingCode = code?.toUpperCase() || "12345678"
-
+    const requestPairingCode = async (phoneNumber, customPairingCode) => {
+        const pairingCode = customPairingCode ?? bytesToCrockford(randomBytes(5));
+        if (customPairingCode && customPairingCode?.length !== 8) {
+            throw new Error('Custom pairing code must be exactly 8 chars');
+        }
+        authState.creds.pairingCode = pairingCode;
         authState.creds.me = {
             id: jidEncode(phoneNumber, 's.whatsapp.net'),
             name: '~'
-        }
-
-        ev.emit('creds.update', authState.creds)
-
+        };
+        ev.emit('creds.update', authState.creds);
         await sendNode({
             tag: 'iq',
             attrs: {
@@ -600,52 +601,52 @@ export const makeSocket = (config) => {
                 id: generateMessageTag(),
                 xmlns: 'md'
             },
-            content: [{
-                tag: 'link_code_companion_reg',
-                attrs: {
-                    jid: authState.creds.me.id,
-                    stage: 'companion_hello',
-                    should_show_push_notification: 'true'
-                },
-                content: [{
-                        tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
-                        attrs: {},
-                        content: await generatePairingKey()
-                    },
-                    {
-                        tag: 'companion_server_auth_key_pub',
-                        attrs: {},
-                        content: authState.creds.noiseKey.public
-                    },
-                    {
-                        tag: 'companion_platform_id',
-                        attrs: {},
-                        content: getPlatformId(browser[1])
-                    },
-                    {
-                        tag: 'companion_platform_display',
-                        attrs: {},
-                        content: `${browser[1]} (${browser[0]})`
+            content: [
+                {
+                    tag: 'link_code_companion_reg',
+                    attrs: {
+                        jid: authState.creds.me.id,
+                        stage: 'companion_hello',
+                        should_show_push_notification: 'true'
                     },
-                    {
-                        tag: 'link_code_pairing_nonce',
-                        attrs: {},
-                        content: '0'
-                    }
-                ]
-            }]
-        })
-
-        return authState.creds.pairingCode
-    }
-
+                    content: [
+                        {
+                            tag: 'link_code_pairing_wrapped_companion_ephemeral_pub',
+                            attrs: {},
+                            content: await generatePairingKey()
+                        },
+                        {
+                            tag: 'companion_server_auth_key_pub',
+                            attrs: {},
+                            content: authState.creds.noiseKey.public
+                        },
+                        {
+                            tag: 'companion_platform_id',
+                            attrs: {},
+                            content: getPlatformId(browser[1])
+                        },
+                        {
+                            tag: 'companion_platform_display',
+                            attrs: {},
+                            content: `${browser[1]} (${browser[0]})`
+                        },
+                        {
+                            tag: 'link_code_pairing_nonce',
+                            attrs: {},
+                            content: '0'
+                        }
+                    ]
+                }
+            ]
+        });
+        return authState.creds.pairingCode;
+    };
     async function generatePairingKey() {
-        const salt = randomBytes(32)
-        const randomIv = randomBytes(16)
-        const key = await derivePairingCodeKey(authState.creds.pairingCode, salt)
-        const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv)
-
-        return Buffer.concat([salt, randomIv, ciphered])
+        const salt = randomBytes(32);
+        const randomIv = randomBytes(16);
+        const key = await derivePairingCodeKey(authState.creds.pairingCode, salt);
+        const ciphered = aesEncryptCTR(authState.creds.pairingEphemeralKeyPair.public, key, randomIv);
+        return Buffer.concat([salt, randomIv, ciphered]);
     }
     const sendWAMBuffer = (wamBuffer) => {
         return query({

package/lib/Store/index.d.ts

@@ -0,0 +1,4 @@
+export * from './make-cache-manager-store'
+export * from './make-in-memory-store'
+export * from './make-ordered-dictionary'
+export * from './object-repository'

package/lib/Store/make-cache-manager-store.d.ts

@@ -0,0 +1,14 @@
+import { Store } from 'cache-manager'
+import { AuthenticationCreds } from '../Types'
+
+export declare const makeCacheManagerAuthState: (store: Store, sessionKey: string) => Promise<{
+    clearState: () => Promise<void>
+    saveCreds: () => Promise<void>
+    state: {
+        creds: AuthenticationCreds
+        keys: {
+            get: (type: string, ids: string[]) => Promise<{}>
+            set: (data: any) => Promise<void>
+        }
+    }
+}>

package/lib/Store/make-in-memory-store.d.ts

@@ -0,0 +1,123 @@
+import type KeyedDB from '@adiwajshing/keyed-db'
+import type { Comparable } from '@adiwajshing/keyed-db/lib/Types'
+import type { Logger } from 'pino'
+import { proto } from '../../WAProto'
+import type makeMDSocket from '../Socket'
+import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata, PresenceData, WAMessage, WAMessageCursor, WAMessageKey } from '../Types'
+import { Label } from '../Types/Label'
+import { LabelAssociation } from '../Types/LabelAssociation'
+import { ObjectRepository } from './object-repository'
+
+type WASocket = ReturnType<typeof makeMDSocket>
+
+export declare const waChatKey: (pin: boolean) => {
+    key: (c: Chat) => string
+    compare: (k1: string, k2: string) => number
+}
+
+export declare const waMessageID: (m: WAMessage) => string
+
+export declare const waLabelAssociationKey: Comparable<LabelAssociation, string>
+
+export type BaileysInMemoryStoreConfig = {
+    chatKey?: Comparable<Chat, string>
+    labelAssociationKey?: Comparable<LabelAssociation, string>
+    logger?: Logger
+    socket?: WASocket
+}
+
+export declare const makeInMemoryStore: (config: BaileysInMemoryStoreConfig) => {
+    chats: KeyedDB<Chat, string>
+    contacts: {
+        [_: string]: Contact
+    }
+    messages: {
+        [_: string]: {
+            array: proto.IWebMessageInfo[]
+            get: (id: string) => proto.IWebMessageInfo | undefined
+            upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
+            update: (item: proto.IWebMessageInfo) => boolean
+            remove: (item: proto.IWebMessageInfo) => boolean
+            updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
+            clear: () => void
+            filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
+            toJSON: () => proto.IWebMessageInfo[]
+            fromJSON: (newItems: proto.IWebMessageInfo[]) => void
+        }
+    }
+    groupMetadata: {
+        [_: string]: GroupMetadata
+    }
+    state: ConnectionState
+    presences: {
+        [id: string]: {
+            [participant: string]: PresenceData
+        }
+    }
+    labels: ObjectRepository<Label>
+    labelAssociations: KeyedDB<LabelAssociation, string>
+    bind: (ev: BaileysEventEmitter) => void
+    /** loads messages from the store, if not found -- uses the legacy connection */
+    loadMessages: (jid: string, count: number, cursor: WAMessageCursor) => Promise<proto.IWebMessageInfo[]>
+    /**
+     * 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.
+     */
+    getLabels: () => ObjectRepository<Label>
+    /**
+     * Get labels for chat
+     *
+     * @returns Label IDs
+     **/
+    getChatLabels: (chatId: string) => LabelAssociation[]
+    /**
+     * Get labels for message
+     *
+     * @returns Label IDs
+     **/
+    getMessageLabels: (messageId: string) => string[]
+    loadMessage: (jid: string, id: string) => Promise<proto.IWebMessageInfo | undefined>
+    mostRecentMessage: (jid: string) => Promise<proto.IWebMessageInfo>
+    fetchImageUrl: (jid: string, sock: WASocket | undefined) => Promise<string | null | undefined>
+    fetchGroupMetadata: (jid: string, sock: WASocket | undefined) => Promise<GroupMetadata>
+    fetchMessageReceipts: ({ remoteJid, id }: WAMessageKey) => Promise<proto.IUserReceipt[] | null | undefined>
+    toJSON: () => {
+        chats: KeyedDB<Chat, string>
+        contacts: {
+            [_: string]: Contact
+        }
+        messages: {
+            [_: string]: {
+                array: proto.IWebMessageInfo[]
+                get: (id: string) => proto.IWebMessageInfo | undefined
+                upsert: (item: proto.IWebMessageInfo, mode: "append" | "prepend") => void
+                update: (item: proto.IWebMessageInfo) => boolean
+                remove: (item: proto.IWebMessageInfo) => boolean
+                updateAssign: (id: string, update: Partial<proto.IWebMessageInfo>) => boolean
+                clear: () => void
+                filter: (contain: (item: proto.IWebMessageInfo) => boolean) => void
+                toJSON: () => proto.IWebMessageInfo[]
+                fromJSON: (newItems: proto.IWebMessageInfo[]) => void
+            }
+        }
+        labels: ObjectRepository<Label>
+        labelAssociations: KeyedDB<LabelAssociation, string>
+    }
+    fromJSON: (json: {
+        chats: Chat[]
+        contacts: {
+            [id: string]: Contact
+        }
+        messages: {
+            [id: string]: proto.IWebMessageInfo[]
+        }
+        labels: {
+            [labelId: string]: Label
+        }
+        labelAssociations: LabelAssociation[]
+    }) => void
+    writeToFile: (path: string) => void
+    readFromFile: (path: string) => void
+}

package/lib/Store/make-ordered-dictionary.d.ts

@@ -0,0 +1,12 @@
+export declare function makeOrderedDictionary<T>(idGetter: (item: T) => string): {
+    array: T[]
+    get: (id: string) => T | undefined
+    upsert: (item: T, mode: 'append' | 'prepend') => void
+    update: (item: T) => boolean
+    remove: (item: T) => boolean
+    updateAssign: (id: string, update: Partial<T>) => boolean
+    clear: () => void
+    filter: (contain: (item: T) => boolean) => void
+    toJSON: () => T[]
+    fromJSON: (newItems: T[]) => void
+}

package/lib/Store/object-repository.d.ts

@@ -0,0 +1,10 @@
+export declare class ObjectRepository<T extends object> {
+    readonly entityMap: Map<string, T>
+    constructor(entities?: Record<string, T>)
+    findById(id: string): T | undefined
+    findAll(): T[]
+    upsertById(id: string, entity: T): Map<string, T>
+    deleteById(id: string): boolean
+    count(): number
+    toJSON(): T[]
+}

package/lib/Types/Auth.d.ts

@@ -0,0 +1,115 @@
+import type { proto } from '../../WAProto/index.js';
+import type { Contact } from './Contact.js';
+import type { MinimalMessage } from './Message.js';
+export type KeyPair = {
+    public: Uint8Array;
+    private: Uint8Array;
+};
+export type SignedKeyPair = {
+    keyPair: KeyPair;
+    signature: Uint8Array;
+    keyId: number;
+    timestampS?: number;
+};
+export type ProtocolAddress = {
+    name: string;
+    deviceId: number;
+};
+export type SignalIdentity = {
+    identifier: ProtocolAddress;
+    identifierKey: Uint8Array;
+};
+export type LIDMapping = {
+    pn: string;
+    lid: string;
+};
+export type LTHashState = {
+    version: number;
+    hash: Buffer;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+};
+export type SignalCreds = {
+    readonly signedIdentityKey: KeyPair;
+    readonly signedPreKey: SignedKeyPair;
+    readonly registrationId: number;
+};
+export type AccountSettings = {
+    /** unarchive chats when a new message is received */
+    unarchiveChats: boolean;
+    /** the default mode to start new conversations with */
+    defaultDisappearingMode?: Pick<proto.IConversation, 'ephemeralExpiration' | 'ephemeralSettingTimestamp'>;
+};
+export type AuthenticationCreds = SignalCreds & {
+    readonly noiseKey: KeyPair;
+    readonly pairingEphemeralKeyPair: KeyPair;
+    advSecretKey: string;
+    me?: Contact;
+    account?: proto.IADVSignedDeviceIdentity;
+    signalIdentities?: SignalIdentity[];
+    myAppStateKeyId?: string;
+    firstUnuploadedPreKeyId: number;
+    nextPreKeyId: number;
+    lastAccountSyncTimestamp?: number;
+    platform?: string;
+    processedHistoryMessages: MinimalMessage[];
+    /** number of times history & app state has been synced */
+    accountSyncCounter: number;
+    accountSettings: AccountSettings;
+    registered: boolean;
+    pairingCode: string | undefined;
+    lastPropHash: string | undefined;
+    routingInfo: Buffer | undefined;
+    additionalData?: any | undefined;
+};
+export type SignalDataTypeMap = {
+    'pre-key': KeyPair;
+    session: Uint8Array;
+    'sender-key': Uint8Array;
+    'sender-key-memory': {
+        [jid: string]: boolean;
+    };
+    'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
+    'app-state-sync-version': LTHashState;
+    'lid-mapping': string;
+    'device-list': string[];
+    tctoken: {
+        token: Buffer;
+        timestamp?: string;
+    };
+};
+export type SignalDataSet = {
+    [T in keyof SignalDataTypeMap]?: {
+        [id: string]: SignalDataTypeMap[T] | null;
+    };
+};
+type Awaitable<T> = T | Promise<T>;
+export type SignalKeyStore = {
+    get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
+        [id: string]: SignalDataTypeMap[T];
+    }>;
+    set(data: SignalDataSet): Awaitable<void>;
+    /** clear all the data in the store */
+    clear?(): Awaitable<void>;
+};
+export type SignalKeyStoreWithTransaction = SignalKeyStore & {
+    isInTransaction: () => boolean;
+    transaction<T>(exec: () => Promise<T>, key: string): Promise<T>;
+};
+export type TransactionCapabilityOptions = {
+    maxCommitRetries: number;
+    delayBetweenTriesMs: number;
+};
+export type SignalAuthState = {
+    creds: SignalCreds;
+    keys: SignalKeyStore | SignalKeyStoreWithTransaction;
+};
+export type AuthenticationState = {
+    creds: AuthenticationCreds;
+    keys: SignalKeyStore;
+};
+export {};
+//# sourceMappingURL=Auth.d.ts.map

package/lib/Types/Bussines.d.ts

@@ -0,0 +1,25 @@
+import type { proto } from '../../WAProto';
+export type DayOfWeekBussines = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+export type HoursDay = {
+    day: DayOfWeekBussines;
+    mode: 'specific_hours';
+    openTimeInMinutes: string;
+    closeTimeInMinutes: string;
+} | {
+    day: DayOfWeekBussines;
+    mode: 'open_24h' | 'appointment_only';
+};
+export type UpdateBussinesProfileProps = {
+    address?: string;
+    websites?: string[];
+    email?: string;
+    description?: string;
+    hours?: {
+        timezone: string;
+        days: HoursDay[];
+    };
+};
+export type QuickReplyAction = proto.SyncActionValue.IQuickReplyAction & {
+    timestamp?: string;
+};
+//# sourceMappingURL=Bussines.d.ts.map

package/lib/Types/Call.d.ts

@@ -0,0 +1,14 @@
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept' | 'terminate';
+export type WACallEvent = {
+    chatId: string;
+    from: string;
+    isGroup?: boolean;
+    groupJid?: string;
+    id: string;
+    date: Date;
+    isVideo?: boolean;
+    status: WACallUpdateType;
+    offline: boolean;
+    latencyMs?: number;
+};
+//# sourceMappingURL=Call.d.ts.map