@hansaka02/baileys 7.3.2 → 7.3.4

package/lib/Types/Signal.d.ts

@@ -1,98 +0,0 @@
-import { proto } from '../../WAProto'
-import { LIDMappingStore } from '../Signal/lid-mapping'
-
-type DecryptGroupSignalOpts = {
-    group: string
-    authorJid: string
-    msg: Uint8Array
-}
-
-type EncryptMessageWithWireOpts = {
-    encryptionJid: string
-    wireJid: string
-    data: Uint8Array
-}
-
-type ProcessSenderKeyDistributionMessageOpts = {
-    item: proto.Message.ISenderKeyDistributionMessage
-    authorJid: string
-}
-
-type DecryptSignalProtoOpts = {
-    jid: string
-    type: 'pkmsg' | 'msg'
-    ciphertext: Uint8Array
-}
-
-type EncryptMessageOpts = {
-    jid: string
-    data: Uint8Array
-}
-
-type EncryptGroupMessageOpts = {
-    group: string
-    data: Uint8Array
-    meId: string
-}
-
-type PreKey = {
-    keyId: number
-    publicKey: Uint8Array
-}
-
-type SignedPreKey = PreKey & {
-    signature: Uint8Array
-}
-
-type E2ESession = {
-    registrationId: number
-    identityKey: Uint8Array
-    signedPreKey: SignedPreKey
-    preKey: PreKey
-}
-
-type E2ESessionOpts = {
-    jid: string
-    session: E2ESession
-}
-
-export type SignalRepository = {
-    decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>
-    processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>
-    decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>
-    encryptMessage(opts: EncryptMessageOpts): Promise<{
-        type: 'pkmsg' | 'msg'
-        ciphertext: Uint8Array
-    }>
-    encryptMessageWithWire(opts: EncryptMessageWithWireOpts): Promise<{
-        type: 'pkmsg' | 'msg'
-        ciphertext: Uint8Array
-        wireJid: string
-    }>
-    encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
-        senderKeyDistributionMessage: Uint8Array
-        ciphertext: Uint8Array
-    }>
-    injectE2ESession(opts: E2ESessionOpts): Promise<void>
-    validateSession(jid: string): Promise<{
-        exists: boolean
-        reason?: string
-    }>
-    jidToSignalProtocolAddress(jid: string): string
-    migrateSession(fromJids: string[], toJid: string): Promise<{
-        migrated: number
-        skipped: number
-        total: number
-    }>
-    validateSession(jid: string): Promise<{
-        exists: boolean
-        reason?: string
-    }>
-    deleteSession(jids: string[]): Promise<void>
-}
-
-export interface SignalRepositoryWithLIDStore extends SignalRepository {
-    lidMapping: LIDMappingStore
-}
-
-export {}

package/lib/Types/Socket.d.ts

@@ -1,141 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import type { Agent } from 'https'
-import { ILogger } from '../Utils/logger'
-import type { URL } from 'url'
-import { proto } from '../../WAProto'
-import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth'
-import { GroupMetadata } from './GroupMetadata'
-import { MediaConnInfo } from './Message'
-import { SignalRepositoryWithLIDStore } from './Signal'
-
-export type WAVersion = [number, number, number]
-
-export type WABrowserDescription = [string, string, string]
-
-export type CacheStore = {
-    /** get a cached key and change the stats */
-    get<T>(key: string): Promise<T> | T | undefined
-    /** set a key in the cache */
-    set<T>(key: string, value: T): Promise<void> | void | number | boolean
-    /** delete a key from the cache */
-    del(key: string): void | Promise<void> | number | boolean
-    /** flush all data */
-    flushAll(): void | Promise<void>
-}
-
-export type PossiblyExtendedCacheStore = CacheStore & {
-    mget?: <T>(keys: string[]) => Promise<Record<string, T | undefined>>
-    mset?: <T>(entries: {
-        key: string
-        value: T
-    }[]) => Promise<void> | void | number | boolean
-    mdel?: (keys: string[]) => void | Promise<void> | number | boolean
-}
-
-export type PatchedMessageWithRecipientJID = proto.IMessage & {
-    recipientJid?: string
-}
-
-export type SocketConfig = {
-    /** the WS url to connect to WA */
-    waWebSocketUrl: string | URL
-    /** Fails the connection if the socket times out in this interval */
-    connectTimeoutMs: number
-    /** Default timeout for queries, undefined for no timeout */
-    defaultQueryTimeoutMs: number | undefined
-    /** ping-pong interval for WS connection */
-    keepAliveIntervalMs: number
-    /** should baileys use the mobile api instead of the multi device api
-     * @deprecated This feature has been removed
-    */
-    mobile?: boolean
-    /** proxy agent */
-    agent?: Agent
-    /** logger */
-    logger: ILogger
-    /** version to connect with */
-    version: WAVersion
-    /** override browser config */
-    browser: WABrowserDescription
-    /** agent used for fetch requests -- uploading/downloading media */
-    fetchAgent?: Agent
-    /** should the QR be printed in the terminal */
-    printQRInTerminal: boolean
-    /** should events be emitted for actions done by this socket connection */
-    emitOwnEvents: boolean
-    /** custom upload hosts to upload media to */
-    customUploadHosts: MediaConnInfo['hosts']
-    /** time to wait between sending new retry requests */
-    retryRequestDelayMs: number
-    /** max retry count */
-    maxMsgRetryCount: number
-    /** time to wait for the generation of the next QR in ms */
-    qrTimeout?: number
-    /** provide an auth state object to maintain the auth state */
-    auth: AuthenticationState
-    /** manage history processing with this control by default will sync up everything */
-    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean
-    /** transaction capability options for SignalKeyStore */
-    transactionOpts: TransactionCapabilityOptions
-    /** marks the client as online whenever the socket successfully connects */
-    markOnlineOnConnect: boolean
-    /** alphanumeric country code (USA -> US) for the number used */
-    countryCode: string
-    /** provide a cache to store media, so does not have to be re-uploaded */
-    mediaCache?: CacheStore
-    /**
-     * map to store the retry counts for failed messages
-     * used to determine whether to retry a message or not */
-    msgRetryCounterCache?: CacheStore
-    /** provide a cache to store a user's device list */
-    userDevicesCache?: PossiblyExtendedCacheStore
-    /** cache to store call offers */
-    callOfferCache?: CacheStore
-    /** cache to track placeholder resends */
-    placeholderResendCache?: CacheStore
-    /** width for link preview images */
-    linkPreviewImageThumbnailWidth: number
-    /** Should Baileys ask the phone for full history, will be received async */
-    syncFullHistory: boolean
-    /** Should baileys fire init queries automatically, default true */
-    fireInitQueries: boolean
-    /**
-     * generate a high quality link preview,
-     * entails uploading the jpegThumbnail to WA
-     * */
-    generateHighQualityLinkPreview: boolean
-    /** Enable automatic session recreation for failed messages */
-    enableAutoSessionRecreation: boolean
-    /** Enable recent message caching for retry handling */
-    enableRecentMessageCache: boolean
-    /**
-     * Returns if a jid should be ignored,
-     * no event for that jid will be triggered.
-     * Messages from that jid will also not be decrypted
-     * */
-    shouldIgnoreJid: (jid: string) => boolean | undefined
-    /**
-     * Optionally patch the message before sending out
-     * */
-    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids?: string[]) => Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> | PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID
-    /** verify app state MACs */
-    appStateMacVerification: {
-        patch: boolean
-        snapshot: boolean
-    }
-    /** options for axios */
-    options: AxiosRequestConfig<{}>
-    /**
-     * fetch a message from your store
-     * implement this so that messages failed to send
-     * (solves the "this message can take a while" issue) can be retried
-     * */
-    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>
-    /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
-    cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>
-    makeSignalRepository: (auth: SignalAuthState, onWhatsAppFunc?: (...jids: string[]) => Promise<{
-        jid: string
-        exists: boolean
-        lid: string
-    }[] | undefined>) => SignalRepositoryWithLIDStore
-}

package/lib/Types/State.d.ts

@@ -1,41 +0,0 @@
-import { Boom } from '@hapi/boom'
-import { Contact } from './Contact'
-
-export declare const enum SyncState {
-    /** The socket is connecting, but we haven't received pending notifications yet. */
-    Connecting = 0,
-    /** Pending notifications received. Buffering events until we decide whether to sync or not. */
-    AwaitingInitialSync = 1,
-    /** The initial app state sync (history, etc.) is in progress. Buffering continues. */
-    Syncing = 2,
-    /** Initial sync is complete, or was skipped. The socket is fully operational and events are processed in real-time. */
-    Online = 3
-}
-
-export type WAConnectionState = 'open' | 'connecting' | 'close'
-
-export type ConnectionState = {
-    /** connection is now open, connecting or closed */
-    connection: WAConnectionState
-    /** the error that caused the connection to close */
-    lastDisconnect?: {
-        error: Boom | Error | undefined
-        date: Date
-    }
-    /** is this a new login */
-    isNewLogin?: boolean
-    /** the current QR code */
-    qr?: string
-    /** has the device received all pending notifications while it was offline */
-    receivedPendingNotifications?: boolean
-    /** legacy connection options */
-    legacy?: {
-        phoneConnected: boolean
-        user?: Contact
-    }
-    /**
-     * if the client is shown as an active, online client.
-     * If this is false, the primary phone and other devices will receive notifs
-     * */
-    isOnline?: boolean
-}

package/lib/Types/USync.d.ts

@@ -1,26 +0,0 @@
-import { BinaryNode } from '../WABinary'
-import { USyncUser } from '../WAUSync'
-
-/**
- * Defines the interface for a USyncQuery protocol
- */
-export interface USyncQueryProtocol {
-    /**
-     * The name of the protocol
-     */
-    name: string
-    /**
-     * Defines what goes inside the query part of a USyncQuery
-     */
-    getQueryElement: () => BinaryNode
-    /**
-     * Defines what goes inside the user part of a USyncQuery
-     */
-    getUserElement: (user: USyncUser) => BinaryNode | null
-    /**
-     * Parse the result of the query
-     * @param data Data from the result
-     * @returns Whatever the protocol is supposed to return
-     */
-    parser: (data: BinaryNode) => unknown
-}

package/lib/Types/index.d.ts

@@ -1,80 +0,0 @@
-export * from './Auth'
-export * from './Bussines'
-export * from './Chat'
-export * from './Contact'
-export * from './GroupMetadata'
-export * from './State'
-export * from './MexUpdates'
-export * from './Message'
-export * from './Newsletter'
-export * from './Socket'
-export * from './Events'
-export * from './Product'
-export * from './Call'
-export * from './Signal'
-
-import { AuthenticationState } from './Auth'
-import { SocketConfig } from './Socket'
-
-export type UserFacingSocketConfig = Partial<SocketConfig> & {
-    auth: AuthenticationState
-}
-
-export type BrowsersMap = {
-    ubuntu(browser: string): [string, string, string]
-    macOS(browser: string): [string, string, string]
-    windows(browser: string): [string, string, string]
-    linux(browser: string): [string, string, string]
-    android(browser: string): [string, string, string]
-    iOS(browser: string): [string, string, string]
-    baileys(browser: string): [string, string, string]
-    kaiOS(browser: string): [string, string, string]
-    chromeOS(browser: string): [string, string, string]
-    appropriate(browser: string): [string, string, string]
-    custom(platform: string, browser: string, version: string): [string, string, string]
-}
-
-export declare const enum DisconnectReason {
-    connectionClosed = 428,
-    connectionLost = 408,
-    connectionReplaced = 440,
-    timedOut = 408,
-    loggedOut = 401,
-    badSession = 500,
-    restartRequired = 515,
-    multideviceMismatch = 411,
-    forbidden = 403,
-    unavailableService = 503
-}
-
-export type WAInitResponse = {
-    ref: string
-    ttl: number
-    status: 200
-}
-
-export type WABusinessHoursConfig = {
-    day_of_week: string
-    mode: string
-    open_time?: number
-    close_time?: number
-}
-
-export type WABusinessProfile = {
-    description: string
-    email: string | undefined
-    business_hours: {
-        timezone?: string
-        config?: WABusinessHoursConfig[]
-        business_config?: WABusinessHoursConfig[]
-    }
-    website: string[]
-    category?: string
-    wid?: string
-    address?: string
-}
-
-export type CurveKeyPair = {
-    private: Uint8Array
-    public: Uint8Array
-}

package/lib/Utils/auth-utils.d.ts

@@ -1,21 +0,0 @@
-import type { AuthenticationCreds, CacheStore, SignalKeyStore, SignalKeyStoreWithTransaction, TransactionCapabilityOptions } from '../Types'
-import { ILogger } from './logger'
-
-/**
- * Adds caching capability to a SignalKeyStore
- * @param store the store to add caching to
- * @param logger to log trace events
- * @param _cache cache store to use
- */
-export declare function makeCacheableSignalKeyStore(store: SignalKeyStore, logger?: ILogger, _cache?: CacheStore): SignalKeyStore
-
-/**
- * Adds DB like transaction capability (https://en.wikipedia.org/wiki/Database_transaction) to the SignalKeyStore,
- * this allows batch read & write operations & improves the performance of the lib
- * @param state the key store to apply this capability to
- * @param logger logger to log events
- * @returns SignalKeyStore with transaction capability
- */
-export declare const addTransactionCapability: (state: SignalKeyStore, logger?: ILogger, { maxCommitRetries, delayBetweenTriesMs }: TransactionCapabilityOptions) => SignalKeyStoreWithTransaction
-
-export declare const initAuthCreds: () => AuthenticationCreds

package/lib/Utils/baileys-event-stream.d.ts

@@ -1,18 +0,0 @@
-import type { BaileysEventEmitter } from '../Types'
-
-/**
- * Captures events from a baileys event emitter & stores them in a file
- * @param ev The event emitter to read events from
- * @param filename File to save to
- */
-export declare const captureEventStream: (ev: BaileysEventEmitter, filename: string) => void
-
-/**
- * Read event file and emit events from there
- * @param filename filename containing event data
- * @param delayIntervalMs delay between each event emit
- */
-export declare const readAndEmitEventStream: (filename: string, delayIntervalMs?: number) => {
-    ev: BaileysEventEmitter
-    task: Promise<void>
-}

package/lib/Utils/business.d.ts

@@ -1,29 +0,0 @@
-import { CatalogCollection, OrderDetails, Product, ProductCreate, ProductUpdate, WAMediaUpload, WAMediaUploadFunction } from '../Types'
-import { BinaryNode } from '../WABinary'
-
-export declare const parseCatalogNode: (node: BinaryNode) => {
-    products: Product[]
-    nextPageCursor: string | undefined
-}
-
-export declare const parseCollectionsNode: (node: BinaryNode) => {
-    collections: CatalogCollection[]
-}
-
-export declare const parseOrderDetailsNode: (node: BinaryNode) => OrderDetails
-
-export declare const toProductNode: (productId: string | undefined, product: ProductCreate | ProductUpdate) => BinaryNode
-
-export declare const parseProductNode: (productNode: BinaryNode) => Product
-
-/**
- * Uploads images not already uploaded to WA's servers
- */
-export declare function uploadingNecessaryImagesOfProduct<T extends ProductUpdate | ProductCreate>(product: T, waUploadToServer: WAMediaUploadFunction, timeoutMs?: number): Promise<T>
-
-/**
- * Uploads images not already uploaded to WA's servers
- */
-export declare const uploadingNecessaryImages: (images: WAMediaUpload[], waUploadToServer: WAMediaUploadFunction, timeoutMs?: number) => Promise<{
-    url: string
-}[]>

package/lib/Utils/chat-utils.d.ts

@@ -1,82 +0,0 @@
-import { AxiosRequestConfig } from 'axios'
-import { proto } from '../../WAProto'
-import { BaileysEventEmitter, ChatModification, ChatMutation, Contact, InitialAppStateSyncOptions, LTHashState, WAPatchCreate, WAPatchName } from '../Types'
-import { BinaryNode } from '../WABinary'
-import { ILogger } from './logger'
-
-type FetchAppStateSyncKey = (keyId: string) => Promise<proto.Message.IAppStateSyncKeyData | null | undefined>
-
-export type ChatMutationMap = {
-    [index: string]: ChatMutation
-}
-
-export declare const newLTHashState: () => LTHashState
-
-export declare const encodeSyncdPatch: ({ type, index, syncAction, apiVersion, operation }: WAPatchCreate, myAppStateKeyId: string, state: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey) => Promise<{
-    patch: proto.ISyncdPatch
-    state: LTHashState
-}>
-
-export declare const decodeSyncdMutations: (msgMutations: (proto.ISyncdMutation | proto.ISyncdRecord)[], initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: Buffer
-    indexValueMap: {
-        [indexMacBase64: string]: {
-            valueMac: Uint8Array | Buffer
-        }
-    }
-}>
-
-export declare const decodeSyncdPatch: (msg: proto.ISyncdPatch, name: WAPatchName, initialState: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, onMutation: (mutation: ChatMutation) => void, validateMacs: boolean) => Promise<{
-    hash: Buffer
-    indexValueMap: {
-        [indexMacBase64: string]: {
-            valueMac: Uint8Array | Buffer
-        }
-    }
-}>
-
-export declare const extractSyncdPatches: (result: BinaryNode, options: AxiosRequestConfig<{}>) => Promise<{
-    critical_block: {
-        patches: proto.ISyncdPatch[]
-        hasMorePatches: boolean
-        snapshot?: proto.ISyncdSnapshot | undefined
-    }
-    critical_unblock_low: {
-        patches: proto.ISyncdPatch[]
-        hasMorePatches: boolean
-        snapshot?: proto.ISyncdSnapshot | undefined
-    }
-    regular_high: {
-        patches: proto.ISyncdPatch[]
-        hasMorePatches: boolean
-        snapshot?: proto.ISyncdSnapshot | undefined
-    }
-    regular_low: {
-        patches: proto.ISyncdPatch[]
-        hasMorePatches: boolean
-        snapshot?: proto.ISyncdSnapshot | undefined
-    }
-    regular: {
-        patches: proto.ISyncdPatch[]
-        hasMorePatches: boolean
-        snapshot?: proto.ISyncdSnapshot | undefined
-    }
-}>
-
-export declare const downloadExternalBlob: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<Buffer>
-export declare const downloadExternalPatch: (blob: proto.IExternalBlobReference, options: AxiosRequestConfig<{}>) => Promise<proto.SyncdMutations>
-export declare const decodeSyncdSnapshot: (name: WAPatchName, snapshot: proto.ISyncdSnapshot, getAppStateSyncKey: FetchAppStateSyncKey, minimumVersionNumber: number | undefined, validateMacs?: boolean) => Promise<{
-    state: LTHashState
-    mutationMap: ChatMutationMap
-}>
-
-export declare const decodePatches: (name: WAPatchName, syncds: proto.ISyncdPatch[], initial: LTHashState, getAppStateSyncKey: FetchAppStateSyncKey, options: AxiosRequestConfig<{}>, minimumVersionNumber?: number, logger?: ILogger, validateMacs?: boolean) => Promise<{
-    state: LTHashState
-    mutationMap: ChatMutationMap
-}>
-
-export declare const chatModificationToAppPatch: (mod: ChatModification, jid: string) => WAPatchCreate
-
-export declare const processSyncAction: (syncAction: ChatMutation, ev: BaileysEventEmitter, me: Contact, initialSyncOpts?: InitialAppStateSyncOptions, logger?: ILogger) => void
-
-export {}

package/lib/Utils/crypto.d.ts

@@ -1,56 +0,0 @@
-import { KeyPair } from '../Types'
-
-/** prefix version byte to the pub keys, required for some curve crypto functions */
-export declare const generateSignalPubKey: (pubKey: Uint8Array | Buffer) => Uint8Array | Buffer
-
-export declare const Curve: {
-    generateKeyPair: () => KeyPair
-    sharedKey: (privateKey: Uint8Array, publicKey: Uint8Array) => Buffer
-    sign: (privateKey: Uint8Array, buf: Uint8Array) => any
-    verify: (pubKey: Uint8Array, message: Uint8Array, signature: Uint8Array) => boolean
-}
-
-export declare const signedKeyPair: (identityKeyPair: KeyPair, keyId: number) => {
-    keyPair: KeyPair
-    signature: any
-    keyId: number
-}
-
-/**
- * encrypt AES 256 GCM
- * where the tag tag is suffixed to the ciphertext
- * */
-export declare function aesEncryptGCM(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer
-
-/**
- * decrypt AES 256 GCM
- * where the auth tag is suffixed to the ciphertext
- * */
-export declare function aesDecryptGCM(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array, additionalData: Uint8Array): Buffer
-
-export declare function aesEncryptCTR(plaintext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer
-
-export declare function aesDecryptCTR(ciphertext: Uint8Array, key: Uint8Array, iv: Uint8Array): Buffer
-
-/** decrypt AES 256 CBC where the IV is prefixed to the buffer */
-export declare function aesDecrypt(buffer: Buffer, key: Buffer): Buffer
-/** decrypt AES 256 CBC */
-
-export declare function aesDecryptWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer
-
-export declare function aesEncrypt(buffer: Buffer | Uint8Array, key: Buffer): Buffer
-
-export declare function aesEncrypWithIV(buffer: Buffer, key: Buffer, IV: Buffer): Buffer
-
-export declare function hmacSign(buffer: Buffer | Uint8Array, key: Buffer | Uint8Array, variant?: 'sha256' | 'sha512'): Buffer
-
-export declare function sha256(buffer: Buffer): Buffer
-
-export declare function md5(buffer: Buffer): Buffer
-
-export declare function hkdf(buffer: Uint8Array | Buffer, expandedLength: number, info: {
-    salt?: Buffer
-    info?: string
-}): Promise<Buffer>
-
-export declare function derivePairingCodeKey(pairingCode: string, salt: Buffer): Promise<Buffer>

package/lib/Utils/decode-wa-message.d.ts

@@ -1,53 +0,0 @@
-import { proto } from '../../WAProto'
-import { SignalRepository } from '../Types'
-import { BinaryNode } from '../WABinary'
-import { ILogger } from './logger'
-
-export declare const NO_MESSAGE_FOUND_ERROR_TEXT = "Message absent from node"
-
-export declare const MISSING_KEYS_ERROR_TEXT = "Key used already or never filled"
-
-export declare const DECRYPTION_RETRY_CONFIG: {
-    maxRetries: number
-    baseDelayMs: number
-    sessionRecordErrors: string[]
-}
-
-export declare const NACK_REASONS: {
-    ParsingError: number
-    UnrecognizedStanza: number
-    UnrecognizedStanzaClass: number
-    UnrecognizedStanzaType: number
-    InvalidProtobuf: number
-    InvalidHostedCompanionStanza: number
-    MissingMessageSecret: number
-    SignalErrorOldCounter: number
-    MessageDeletedOnPeer: number
-    UnhandledError: number
-    UnsupportedAdminRevoke: number
-    UnsupportedLIDGroup: number
-    DBOperationFailed: number
-}
-
-export declare const extractAddressingContext: (stanza: BinaryNode) => {
-    addressingMode: string
-    senderAlt: string | undefined
-    recipientAlt: string | undefined
-}
-
-/**
- * Decode the received node as a message.
- * @note this will only parse the message, not decrypt it
- */
-export declare function decodeMessageNode(stanza: BinaryNode, meId: string, meLid: string): {
-    fullMessage: proto.IWebMessageInfo
-    author: string
-    sender: string
-}
-
-export declare const decryptMessageNode: (stanza: BinaryNode, meId: string, meLid: string, repository: SignalRepository, logger: ILogger) => {
-    fullMessage: proto.IWebMessageInfo
-    category: string
-    author: string
-    decrypt(): Promise<void>
-}