@alannxd/baileys 6.0.1 → 6.0.2

package/lib/Socket/index.d.ts

@@ -0,0 +1,173 @@
+/// <reference types="node" />
+import { UserFacingSocketConfig } from '../Types';
+declare const makeWASocket: (config: UserFacingSocketConfig) => {
+    register: (code: string) => Promise<import("./registration").ExistsResponse>;
+    requestRegistrationCode: (registrationOptions?: import("./registration").RegistrationOptions | undefined) => Promise<import("./registration").ExistsResponse>;
+    logger: import("pino").Logger<import("pino").LoggerOptions>;
+    getOrderDetails: (orderId: string, tokenBase64: string) => Promise<import("../Types").OrderDetails>;
+    getCatalog: ({ jid, limit, cursor }: import("../Types").GetCatalogOptions) => Promise<{
+        products: import("../Types").Product[];
+        nextPageCursor: string | undefined;
+    }>;
+    getCollections: (jid?: string | undefined, limit?: number) => Promise<{
+        collections: import("../Types").CatalogCollection[];
+    }>;
+    productCreate: (create: import("../Types").ProductCreate) => Promise<import("../Types").Product>;
+    productDelete: (productIds: string[]) => Promise<{
+        deleted: number;
+    }>;
+    productUpdate: (productId: string, update: import("../Types").ProductUpdate) => Promise<import("../Types").Product>;
+    sendMessageAck: ({ tag, attrs, content }: import("../index").BinaryNode) => Promise<void>;
+    sendRetryRequest: (node: import("../index").BinaryNode, forceIncludeKeys?: boolean) => Promise<void>;
+    offerCall: (toJid: string, isVideo?: boolean) => Promise<{
+        id: string;
+        to: string;
+    }>;
+    rejectCall: (callId: string, callFrom: string) => Promise<void>;
+    getPrivacyTokens: (jids: string[]) => Promise<import("../index").BinaryNode>;
+    assertSessions: (jids: string[], force: boolean) => Promise<boolean>;
+    relayMessage: (jid: string, message: import("../Types").WAProto.IMessage, { messageId: msgId, participant, additionalAttributes, additionalNodes, useUserDevicesCache, cachedGroupMetadata, statusJidList }: import("../Types").MessageRelayOptions) => Promise<string>;
+    sendReceipt: (jid: string, participant: string | undefined, messageIds: string[], type: import("../Types").MessageReceiptType) => Promise<void>;
+    sendReceipts: (keys: import("../Types").WAProto.IMessageKey[], type: import("../Types").MessageReceiptType) => Promise<void>;
+    getButtonArgs: (message: import("../Types").WAProto.IMessage) => {
+        [key: string]: string;
+    };
+    readMessages: (keys: import("../Types").WAProto.IMessageKey[]) => Promise<void>;
+    refreshMediaConn: (forceGet?: boolean) => Promise<import("../Types").MediaConnInfo>;
+    getUSyncDevices: (jids: string[], useCache: boolean, ignoreZeroDevices: boolean) => Promise<import("../index").JidWithDevice[]>;
+    createParticipantNodes: (jids: string[], message: import("../Types").WAProto.IMessage, extraAttrs?: {
+        [key: string]: string;
+    } | undefined) => Promise<{
+        nodes: import("../index").BinaryNode[];
+        shouldIncludeDeviceIdentity: boolean;
+    }>;
+    waUploadToServer: import("../Types").WAMediaUploadFunction;
+    fetchPrivacySettings: (force?: boolean) => Promise<{
+        [_: string]: string;
+    }>;
+    updateMediaMessage: (message: import("../Types").WAProto.IWebMessageInfo) => Promise<import("../Types").WAProto.IWebMessageInfo>;
+    sendMessage: (jid: string, content: import("../Types").AnyMessageContent, options?: import("../Types").MiscMessageGenerationOptions) => Promise<import("../Types").WAProto.WebMessageInfo | undefined>;
+    subscribeNewsletterUpdates: (jid: string) => Promise<{
+        duration: string;
+    }>;
+    newsletterReactionMode: (jid: string, mode: import("../Types").NewsletterReactionMode) => Promise<void>;
+    newsletterUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
+    newsletterUpdateName: (jid: string, name: string) => Promise<void>;
+    newsletterUpdatePicture: (jid: string, content: import("../Types").WAMediaUpload) => Promise<void>;
+    newsletterRemovePicture: (jid: string) => Promise<void>;
+    newsletterUnfollow: (jid: string) => Promise<void>;
+    newsletterFollow: (jid: string) => Promise<void>;
+    newsletterUnmute: (jid: string) => Promise<void>;
+    newsletterMute: (jid: string) => Promise<void>;
+    newsletterAction: (jid: string, type: "mute" | "follow" | "unfollow" | "unmute") => Promise<void>;
+    newsletterCreate: (name: string, description: string, reaction_codes: string) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterMetadata: (type: "invite" | "jid", key: string, role?: import("../Types").NewsletterViewRole | undefined) => Promise<import("../Types").NewsletterMetadata>;
+    newsletterAdminCount: (jid: string) => Promise<number>;
+    newsletterChangeOwner: (jid: string, user: string) => Promise<void>;
+    newsletterDemote: (jid: string, user: string) => Promise<void>;
+    newsletterDelete: (jid: string) => Promise<void>;
+    newsletterReactMessage: (jid: string, serverId: string, code?: string | undefined) => Promise<void>;
+    newsletterFetchMessages: (type: "invite" | "jid", key: string, count: number, after?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    newsletterFetchUpdates: (jid: string, count: number, after?: number | undefined, since?: number | undefined) => Promise<import("../Types").NewsletterFetchedUpdate[]>;
+    groupMetadata: (jid: string) => Promise<import("../Types").GroupMetadata>;
+    groupCreate: (subject: string, participants: string[]) => Promise<import("../Types").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: "reject" | "approve") => Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupParticipantsUpdate: (jid: string, participants: string[], action: import("../Types").ParticipantAction) => Promise<{
+        status: string;
+        jid: string;
+        content: import("../index").BinaryNode;
+    }[]>;
+    groupUpdateDescription: (jid: string, description?: string | undefined) => Promise<void>;
+    groupInviteCode: (jid: string) => Promise<string | undefined>;
+    groupRevokeInvite: (jid: string) => Promise<string | undefined>;
+    groupAcceptInvite: (code: string) => Promise<string | undefined>;
+    groupAcceptInviteV4: (key: string | import("../Types").WAProto.IMessageKey, inviteMessage: import("../Types").WAProto.Message.IGroupInviteMessage) => Promise<string>;
+    groupGetInviteInfo: (code: string) => Promise<import("../Types").GroupMetadata>;
+    groupToggleEphemeral: (jid: string, ephemeralExpiration: number) => Promise<void>;
+    groupSettingUpdate: (jid: string, setting: "announcement" | "locked" | "not_announcement" | "unlocked") => Promise<void>;
+    groupMemberAddMode: (jid: string, mode: "all_member_add" | "admin_add") => Promise<void>;
+    groupJoinApprovalMode: (jid: string, mode: "on" | "off") => Promise<void>;
+    groupFetchAllParticipating: () => Promise<{
+        [_: string]: import("../Types").GroupMetadata;
+    }>;
+    processingMutex: {
+        mutex<T>(code: () => T | Promise<T>): Promise<T>;
+    };
+    upsertMessage: (msg: import("../Types").WAProto.IWebMessageInfo, type: import("../Types").MessageUpsertType) => Promise<void>;
+    appPatch: (patchCreate: import("../Types").WAPatchCreate) => Promise<void>;
+    sendPresenceUpdate: (type: import("../Types").WAPresence, toJid?: string | undefined) => Promise<void>;
+    presenceSubscribe: (toJid: string, tcToken?: Buffer | undefined) => Promise<void>;
+    profilePictureUrl: (jid: string, type?: "image" | "preview", timeoutMs?: number | undefined) => Promise<string | undefined>;
+    onWhatsApp: (...jids: string[]) => Promise<{
+        jid: string;
+        exists: unknown;
+        lid: unknown;
+    }[] | undefined>;
+    fetchBlocklist: () => Promise<string[]>;
+    fetchStatus: (jid: string) => Promise<{
+        status: string | undefined;
+        setAt: Date;
+    } | undefined>;
+    updateProfilePicture: (jid: string, content: import("../Types").WAMediaUpload) => 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>;
+    updateLastSeenPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateOnlinePrivacy: (value: import("../Types").WAPrivacyOnlineValue) => Promise<void>;
+    updateProfilePicturePrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateStatusPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateReadReceiptsPrivacy: (value: import("../Types").WAReadReceiptsValue) => Promise<void>;
+    updateGroupsAddPrivacy: (value: import("../Types").WAPrivacyValue) => Promise<void>;
+    updateDefaultDisappearingMode: (duration: number) => Promise<void>;
+    getBusinessProfile: (jid: string) => Promise<void | import("../Types").WABusinessProfile>;
+    resyncAppState: (collections: readonly ("critical_block" | "critical_unblock_low" | "regular_high" | "regular_low" | "regular")[], isInitialSync: boolean) => Promise<void>;
+    chatModify: (mod: import("../Types").ChatModification, jid: string) => Promise<void>;
+    cleanDirtyBits: (type: "account_sync" | "groups", fromTimestamp?: string | number | undefined) => 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 | undefined;
+    }[], star: boolean) => Promise<void>;
+    type: "md";
+    ws: any;
+    ev: import("../Types").BaileysEventEmitter & {
+        process(handler: (events: Partial<import("../Types").BaileysEventMap>) => void | Promise<void>): () => void;
+        buffer(): void;
+        createBufferedFunction<A extends any[], T_1>(work: (...args: A) => Promise<T_1>): (...args: A) => Promise<T_1>;
+        flush(force?: boolean | undefined): boolean;
+        isBuffering(): boolean;
+    };
+    authState: {
+        creds: import("../Types").AuthenticationCreds;
+        keys: import("../Types").SignalKeyStoreWithTransaction;
+    };
+    signalRepository: import("../Types").SignalRepository;
+    user: import("../Types").Contact | undefined;
+    generateMessageTag: () => string;
+    query: (node: import("../index").BinaryNode, timeoutMs?: number | undefined) => Promise<import("../index").BinaryNode>;
+    waitForMessage: <T_2>(msgId: string, timeoutMs?: number | undefined) => Promise<T_2>;
+    waitForSocketOpen: () => Promise<void>;
+    sendRawMessage: (data: Uint8Array | Buffer) => Promise<void>;
+    sendNode: (frame: import("../index").BinaryNode) => Promise<void>;
+    logout: (msg?: string | undefined) => Promise<void>;
+    end: (error: Error | undefined) => void;
+    onUnexpectedError: (err: Error | import("@hapi/boom").Boom<any>, msg: string) => void;
+    uploadPreKeys: (count?: number) => Promise<void>;
+    uploadPreKeysToServerIfRequired: () => Promise<void>;
+    requestPairingCode: (phoneNumber: string) => Promise<string>;
+    waitForConnectionUpdate: (check: (u: Partial<import("../Types").ConnectionState>) => boolean | undefined, timeoutMs?: number | undefined) => Promise<void>;
+    sendWAMBuffer: (wamBuffer: Buffer) => Promise<import("../index").BinaryNode>;
+};
+export default makeWASocket;

package/lib/Socket/luxu.d.ts

@@ -0,0 +1,266 @@
+import { proto } from '../../WAProto';
+
+declare namespace imup {
+    interface MediaUploadOptions {
+        fileEncSha256?: Buffer;
+        mediaType?: string;
+        newsletter?: boolean;
+    }
+
+    type WAMediaUploadFunction = (
+        stream: Buffer | NodeJS.ReadableStream, 
+        options?: MediaUploadOptions
+    ) => Promise<{ url: string; directPath: string }>;
+
+    interface WAMessageContentGenerationOptions {
+        upload?: WAMediaUploadFunction;
+        mediaCache?: any;
+        options?: any;
+        logger?: any;
+    }
+
+    interface StickerMessage {
+        url: string;
+        fileSha256: Buffer | string;
+        fileEncSha256: Buffer | string;
+        mediaKey: Buffer | string;
+        mimetype: string;
+        directPath: string;
+        fileLength: number | string;
+        mediaKeyTimestamp: number | string;
+        isAnimated?: boolean;
+        stickerSentTs?: number | string;
+        isAvatar?: boolean;
+        isAiSticker?: boolean;
+        isLottie?: boolean;
+    }
+
+    interface PaymentMessage {
+        amount: number;
+        currency?: string;
+        from?: string;
+        expiry?: number;
+        sticker?: { stickerMessage: StickerMessage };
+        note?: string;
+        background?: {
+            id?: string;
+            fileLength?: string;
+            width?: number;
+            height?: number;
+            mimetype?: string;
+            placeholderArgb?: number;
+            textArgb?: number;
+            subtextArgb?: number;
+        };
+    }
+
+    interface ProductMessage {
+        title: string;
+        description: string;
+        thumbnail: Buffer | { url: string };
+        productId: string;
+        retailerId: string;
+        url: string;
+        body?: string;
+        footer?: string;
+        buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
+        priceAmount1000?: number | null;
+        currencyCode?: string;
+    }
+
+    interface InteractiveMessage {
+        title: string;
+        footer?: string;
+        thumbnail?: string;
+        image?: string | Buffer | { url: string };
+        video?: string | Buffer | { url: string };
+        document?: Buffer;
+        mimetype?: string;
+        fileName?: string;
+        jpegThumbnail?: Buffer;
+        contextInfo?: {
+            mentionedJid?: string[];
+            forwardingScore?: number;
+            isForwarded?: boolean;
+            forwardedNewsletterMessageInfo?: proto.Message.ContextInfo.ForwardedNewsletterMessageInfo;
+            externalAdReply?: {
+                title?: string;
+                body?: string;
+                mediaType?: number;
+                thumbnailUrl?: string;
+                mediaUrl?: string;
+                sourceUrl?: string;
+                showAdAttribution?: boolean;
+                renderLargerThumbnail?: boolean;
+                [key: string]: any;
+            };
+            [key: string]: any;
+        };
+        externalAdReply?: {
+            title?: string;
+            body?: string;
+            mediaType?: number;
+            thumbnailUrl?: string;
+            mediaUrl?: string;
+            sourceUrl?: string;
+            showAdAttribution?: boolean;
+            renderLargerThumbnail?: boolean;
+            [key: string]: any;
+        };
+        buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
+        nativeFlowMessage?: {
+            messageParamsJson?: string;
+            buttons?: proto.Message.InteractiveMessage.INativeFlowButton[];
+            [key: string]: any;
+        };
+    }
+
+    interface AlbumItem {
+        image?: { url: string; caption?: string };
+        video?: { url: string; caption?: string };
+    }
+
+    interface EventMessageLocation {
+        degreesLatitude: number;
+        degreesLongitude: number;
+        name: string;
+    }
+
+    interface EventMessage {
+        isCanceled?: boolean;
+        name: string;
+        description: string;
+        location?: EventMessageLocation;
+        joinLink?: string;
+        startTime?: string | number;
+        endTime?: string | number;
+        extraGuestsAllowed?: boolean;
+    }
+    
+    interface PollVote {
+        optionName: string;
+        optionVoteCount: string | number;
+    }
+    
+    interface PollResultMessage {
+        name: string;
+        pollVotes: PollVote[];
+        newsletter?: {
+            newsletterName: string;
+            newsletterJid: string;
+        };
+    }
+
+    interface OrderMessage {
+        thumbnail?: Buffer | string,
+        itemCount?: string | number,
+        message: string,
+        orderTitle: string,
+        totalAmount1000?: string | number,
+        totalCurrencyCode?: string
+    }
+    
+    interface GroupStatus {
+        message?: any;
+        image?: string | Buffer | { url: string };
+        video?: string | Buffer | { url: string };
+        text?: string;
+        caption?: string;
+        document?: string | Buffer | { url: string };
+        [key: string]: any;
+    }
+    
+    interface GroupLabel {
+        labelText: string;
+    }
+ 
+    interface MessageContent {
+        requestPaymentMessage?: PaymentMessage;
+        productMessage?: ProductMessage;
+        interactiveMessage?: InteractiveMessage;
+        albumMessage?: AlbumItem[];
+        eventMessage?: EventMessage;
+        pollResultMessage?: PollResultMessage;
+        groupStatus?: GroupStatus;
+        orderMessage?: OrderMessage;
+        groupLabel?: GroupLabel;
+        sender?: string;
+    }
+
+    interface MessageOptions {
+        quoted?: proto.IWebMessageInfo;
+        filter?: boolean;
+    }
+
+    interface Utils {
+        prepareWAMessageMedia: (media: any, options: WAMessageContentGenerationOptions) => Promise<any>;
+        generateWAMessageContent: (content: any, options: WAMessageContentGenerationOptions) => Promise<any>;
+        generateWAMessageFromContent: (jid: string, content: any, options?: any) => Promise<any>;
+        generateWAMessage: (jid: string, content: any, options?: any) => Promise<any>;
+        generateMessageID: () => string;
+    }
+}
+
+declare class imup {
+    constructor(
+        utils: imup.Utils,
+        waUploadToServer: imup.WAMediaUploadFunction,
+        relayMessageFn?: (jid: string, content: any, options?: any) => Promise<any>
+    );
+    
+    detectType(content: imup.MessageContent): 'PAYMENT' | 'PRODUCT' | 'INTERACTIVE' | 'ALBUM' | 'EVENT' | 'POLL_RESULT' | 'GROUP_STATUS' | 'ORDER' | 'GROUP_LABEL' |null;
+
+    handlePayment(
+        content: { requestPaymentMessage: imup.PaymentMessage },
+        quoted?: proto.IWebMessageInfo
+    ): Promise<{ requestPaymentMessage: proto.Message.RequestPaymentMessage }>;
+
+    handleProduct(
+        content: { productMessage: imup.ProductMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<{ viewOnceMessage: proto.Message.ViewOnceMessage }>;
+
+    handleInteractive(
+        content: { interactiveMessage: imup.InteractiveMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<{ interactiveMessage: proto.Message.InteractiveMessage }>;
+
+    handleAlbum(
+        content: { albumMessage: imup.AlbumItem[] },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+
+    handleEvent(
+        content: { eventMessage: imup.EventMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+    
+    handlePollResult(
+        content: { pollResultMessage: imup.PollResultMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+
+    handleOrderMessage(
+        content: { orderMessage: imup.OrderMessage },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+    
+    handleGroupStory(
+        content: { groupStatus: imup.GroupStatus },
+        jid: string,
+        quoted?: proto.IWebMessageInfo
+    ): Promise<any>;
+    
+    handleGbLabel(
+        content: { groupLabel: imup.GroupLabel },
+        jid: string,
+    ): Promise<any>;
+}
+
+export = imup;