@pontalabs/baileys 1.0.6 → 1.0.7

package/lib/Types/Message.js

@@ -1,17 +1,19 @@
-import { proto } from '../../WAProto/index.js';
-// export the WAMessage Prototypes
-export { proto as WAProto };
-export const AssociationType = proto.MessageAssociation.AssociationType;
-export const WAMessageStubType = proto.WebMessageInfo.StubType;
-export const WAMessageStatus = proto.WebMessageInfo.Status;
-export const ButtonHeaderType = proto.Message.ButtonsMessage.HeaderType;
-export const ButtonType = proto.Message.ButtonsMessage.Button.Type;
-export const CarouselCardType = proto.Message.InteractiveMessage.CarouselMessage.CarouselCardType;
-export const ListType = proto.Message.ListMessage.ListType;
-export const ProtocolType = proto.Message.ProtocolMessage.Type;
-export var WAMessageAddressingMode;
-(function (WAMessageAddressingMode) {
-    WAMessageAddressingMode["PN"] = "pn";
-    WAMessageAddressingMode["LID"] = "lid";
-})(WAMessageAddressingMode || (WAMessageAddressingMode = {}));
-//# sourceMappingURL=Message.js.map
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAProto_1 = require("../../WAProto")
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const WAMessageAddressingMode = {
+	PN: 'pn', 
+	LID: 'lid'
+}
+
+module.exports = {
+  WAMessageAddressingMode, 
+  WAMessageStubType: WAProto_1.proto.WebMessageInfo.StubType, 
+  WAMessageStatus: WAProto_1.proto.WebMessageInfo.Status, 
+  WAProto: WAProto_1.proto
+}

package/lib/Types/Product.d.ts

@@ -1,79 +1,92 @@
-import type { WAMediaUpload } from './Message.js';
+import { WAMediaUpload } from './Message'
+
 export type CatalogResult = {
     data: {
         paging: {
             cursors: {
-                before: string;
-                after: string;
-            };
-        };
-        data: any[];
-    };
-};
+                before: string
+                after: string
+            }
+        }
+        data: any[]
+    }
+}
+
 export type ProductCreateResult = {
     data: {
-        product: {};
-    };
-};
+        product: {}
+    }
+}
+
 export type CatalogStatus = {
-    status: string;
-    canAppeal: boolean;
-};
+    status: string
+    canAppeal: boolean
+}
+
 export type CatalogCollection = {
-    id: string;
-    name: string;
-    products: Product[];
-    status: CatalogStatus;
-};
-export type ProductAvailability = 'in stock';
+    id: string
+    name: string
+    products: Product[]
+    status: CatalogStatus
+}
+
+export type ProductAvailability = 'in stock'
+
 export type ProductBase = {
-    name: string;
-    retailerId?: string;
-    url?: string;
-    description: string;
-    price: number;
-    currency: string;
-    isHidden?: boolean;
-};
+    name: string
+    retailerId?: string
+    url?: string
+    description: string
+    price: number
+    currency: string
+    isHidden?: boolean
+}
+
 export type ProductCreate = ProductBase & {
     /** ISO country code for product origin. Set to undefined for no country */
-    originCountryCode: string | undefined;
+    originCountryCode: string | undefined
     /** images of the product */
-    images: WAMediaUpload[];
-};
-export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>;
+    images: WAMediaUpload[]
+}
+
+export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>
+
 export type Product = ProductBase & {
-    id: string;
+    id: string
     imageUrls: {
-        [_: string]: string;
-    };
+        [_: string]: string
+    }
     reviewStatus: {
-        [_: string]: string;
-    };
-    availability: ProductAvailability;
-};
+        [_: string]: string
+    }
+    availability: ProductAvailability
+}
+
 export type OrderPrice = {
-    currency: string;
-    total: number;
-};
+    currency: string
+    total: number
+}
+
 export type OrderProduct = {
-    id: string;
-    imageUrl: string;
-    name: string;
-    quantity: number;
-    currency: string;
-    price: number;
-};
+    id: string
+    imageUrl: string
+    name: string
+    quantity: number
+    currency: string
+    price: number
+}
+
 export type OrderDetails = {
-    price: OrderPrice;
-    products: OrderProduct[];
-};
-export type CatalogCursor = string;
+    price: OrderPrice
+    products: OrderProduct[]
+}
+
+export type CatalogCursor = string
+
 export type GetCatalogOptions = {
     /** cursor to start from */
-    cursor?: CatalogCursor;
+    cursor?: CatalogCursor
     /** number of products to fetch */
-    limit?: number;
-    jid?: string;
-};
-//# sourceMappingURL=Product.d.ts.map
+    limit?: number
+    jid?: string
+}

package/lib/Types/Product.js

@@ -1,2 +1,3 @@
-export {};
-//# sourceMappingURL=Product.js.map
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/Signal.d.ts

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

package/lib/Types/Signal.js

@@ -1,2 +1,3 @@
-import { proto } from '../../WAProto/index.js';
-//# sourceMappingURL=Signal.js.map
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })

package/lib/Types/Socket.d.ts

@@ -1,136 +1,141 @@
-import type { Agent } from 'https';
-import type { URL } from 'url';
-import { proto } from '../../WAProto/index.js';
-import type { ILogger } from '../Utils/logger.js';
-import type { AuthenticationState, LIDMapping, SignalAuthState, TransactionCapabilityOptions } from './Auth.js';
-import type { GroupMetadata } from './GroupMetadata.js';
-import { type MediaConnInfo, type WAMessageKey } from './Message.js';
-import type { SignalRepositoryWithLIDStore } from './Signal.js';
-export type WAVersion = [number, number, number];
-export type WABrowserDescription = [string, string, string];
+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;
+    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;
+    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;
+    del(key: string): void | Promise<void> | number | boolean
     /** flush all data */
-    flushAll(): void | Promise<void>;
-    close?: () => void;
-};
+    flushAll(): void | Promise<void>
+}
+
 export type PossiblyExtendedCacheStore = CacheStore & {
-    mget?: <T>(keys: string[]) => Promise<Record<string, T | undefined>>;
+    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;
-};
+        key: string
+        value: T
+    }[]) => Promise<void> | void | number | boolean
+    mdel?: (keys: string[]) => void | Promise<void> | number | boolean
+}
+
 export type PatchedMessageWithRecipientJID = proto.IMessage & {
-    recipientJid?: string;
-};
+    recipientJid?: string
+}
+
 export type SocketConfig = {
     /** the WS url to connect to WA */
-    waWebSocketUrl: string | URL;
+    waWebSocketUrl: string | URL
     /** Fails the connection if the socket times out in this interval */
-    connectTimeoutMs: number;
+    connectTimeoutMs: number
     /** Default timeout for queries, undefined for no timeout */
-    defaultQueryTimeoutMs: number | undefined;
+    defaultQueryTimeoutMs: number | undefined
     /** ping-pong interval for WS connection */
-    keepAliveIntervalMs: number;
+    keepAliveIntervalMs: number
     /** should baileys use the mobile api instead of the multi device api
      * @deprecated This feature has been removed
-     */
-    mobile?: boolean;
+    */
+    mobile?: boolean
     /** proxy agent */
-    agent?: Agent;
+    agent?: Agent
     /** logger */
-    logger: ILogger;
+    logger: ILogger
     /** version to connect with */
-    version: WAVersion;
+    version: WAVersion
     /** override browser config */
-    browser: WABrowserDescription;
-    /** Initial pushName carried in the registration ClientPayload (used by mock servers for deterministic phone assignment). */
-    pushName?: string;
+    browser: WABrowserDescription
     /** agent used for fetch requests -- uploading/downloading media */
-    fetchAgent?: Agent;
-    /** should the QR be printed in the terminal
-     * @deprecated This feature has been removed
-     */
-    printQRInTerminal?: boolean;
+    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;
+    emitOwnEvents: boolean
     /** custom upload hosts to upload media to */
-    customUploadHosts: MediaConnInfo['hosts'];
+    customUploadHosts: MediaConnInfo['hosts']
     /** time to wait between sending new retry requests */
-    retryRequestDelayMs: number;
+    retryRequestDelayMs: number
     /** max retry count */
-    maxMsgRetryCount: number;
+    maxMsgRetryCount: number
     /** time to wait for the generation of the next QR in ms */
-    qrTimeout?: number;
+    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;
+    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;
+    transactionOpts: TransactionCapabilityOptions
     /** marks the client as online whenever the socket successfully connects */
-    markOnlineOnConnect: boolean;
+    markOnlineOnConnect: boolean
     /** alphanumeric country code (USA -> US) for the number used */
-    countryCode: string;
+    countryCode: string
     /** provide a cache to store media, so does not have to be re-uploaded */
-    mediaCache?: CacheStore;
+    mediaCache?: CacheStore
     /**
-     * map to store the retry counts for failed messages;
+     * map to store the retry counts for failed messages
      * used to determine whether to retry a message or not */
-    msgRetryCounterCache?: CacheStore;
+    msgRetryCounterCache?: CacheStore
     /** provide a cache to store a user's device list */
-    userDevicesCache?: PossiblyExtendedCacheStore;
+    userDevicesCache?: PossiblyExtendedCacheStore
     /** cache to store call offers */
-    callOfferCache?: CacheStore;
+    callOfferCache?: CacheStore
     /** cache to track placeholder resends */
-    placeholderResendCache?: CacheStore;
+    placeholderResendCache?: CacheStore
     /** width for link preview images */
-    linkPreviewImageThumbnailWidth: number;
+    linkPreviewImageThumbnailWidth: number
     /** Should Baileys ask the phone for full history, will be received async */
-    syncFullHistory: boolean;
+    syncFullHistory: boolean
     /** Should baileys fire init queries automatically, default true */
-    fireInitQueries: boolean;
+    fireInitQueries: boolean
     /**
      * generate a high quality link preview,
      * entails uploading the jpegThumbnail to WA
      * */
-    generateHighQualityLinkPreview: boolean;
+    generateHighQualityLinkPreview: boolean
     /** Enable automatic session recreation for failed messages */
-    enableAutoSessionRecreation: boolean;
+    enableAutoSessionRecreation: boolean
     /** Enable recent message caching for retry handling */
-    enableRecentMessageCache: boolean;
+    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;
+    shouldIgnoreJid: (jid: string) => boolean | undefined
     /**
      * Optionally patch the message before sending out
      * */
-    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids?: string[]) => Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> | PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID;
+    patchMessageBeforeSending: (msg: proto.IMessage, recipientJids?: string[]) => Promise<PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID> | PatchedMessageWithRecipientJID[] | PatchedMessageWithRecipientJID
     /** verify app state MACs */
     appStateMacVerification: {
-        patch: boolean;
-        snapshot: boolean;
-    };
-    /** options for HTTP fetch requests */
-    options: RequestInit;
+        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: WAMessageKey) => Promise<proto.IMessage | undefined>;
+    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, logger: ILogger, pnToLIDFunc?: (jids: string[]) => Promise<LIDMapping[] | undefined>) => SignalRepositoryWithLIDStore;
-};
-//# sourceMappingURL=Socket.d.ts.map
+    cachedGroupMetadata: (jid: string) => Promise<GroupMetadata | undefined>
+    makeSignalRepository: (auth: SignalAuthState, onWhatsAppFunc?: (...jids: string[]) => Promise<{
+        jid: string
+        exists: boolean
+        lid: string
+    }[] | undefined>) => SignalRepositoryWithLIDStore
+}

package/lib/Types/Socket.js

@@ -1,3 +1,3 @@
-import { proto } from '../../WAProto/index.js';
-import {} from './Message.js';
-//# sourceMappingURL=Socket.js.map
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })