gifted-baileys 1.5.0 → 1.5.5

package/src/Types/Newsletter.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryIds = exports.XWAPaths = exports.MexOperations = void 0;
+var MexOperations;
+(function (MexOperations) {
+    MexOperations["PROMOTE"] = "NotificationNewsletterAdminPromote";
+    MexOperations["DEMOTE"] = "NotificationNewsletterAdminDemote";
+    MexOperations["UPDATE"] = "NotificationNewsletterUpdate";
+})(MexOperations || (exports.MexOperations = MexOperations = {}));
+var XWAPaths;
+(function (XWAPaths) {
+    XWAPaths["PROMOTE"] = "xwa2_notify_newsletter_admin_promote";
+    XWAPaths["DEMOTE"] = "xwa2_notify_newsletter_admin_demote";
+    XWAPaths["ADMIN_COUNT"] = "xwa2_newsletter_admin";
+    XWAPaths["CREATE"] = "xwa2_newsletter_create";
+    XWAPaths["NEWSLETTER"] = "xwa2_newsletter";
+    XWAPaths["METADATA_UPDATE"] = "xwa2_notify_newsletter_on_metadata_update";
+})(XWAPaths || (exports.XWAPaths = XWAPaths = {}));
+var QueryIds;
+(function (QueryIds) {
+    QueryIds["JOB_MUTATION"] = "7150902998257522";
+    QueryIds["METADATA"] = "6620195908089573";
+    QueryIds["UNFOLLOW"] = "7238632346214362";
+    QueryIds["FOLLOW"] = "7871414976211147";
+    QueryIds["UNMUTE"] = "7337137176362961";
+    QueryIds["MUTE"] = "25151904754424642";
+    QueryIds["CREATE"] = "6996806640408138";
+    QueryIds["ADMIN_COUNT"] = "7130823597031706";
+    QueryIds["CHANGE_OWNER"] = "7341777602580933";
+    QueryIds["DELETE"] = "8316537688363079";
+    QueryIds["DEMOTE"] = "6551828931592903";
+})(QueryIds || (exports.QueryIds = QueryIds = {}));

package/src/Types/Newsletter.ts

@@ -0,0 +1,98 @@
+import { proto } from '../../WAProto'
+
+export type NewsletterReactionMode = 'ALL' | 'BASIC' | 'NONE'
+
+export type NewsletterState = 'ACTIVE' | 'GEOSUSPENDED' | 'SUSPENDED'
+
+export type NewsletterVerification = 'VERIFIED' | 'UNVERIFIED'
+
+export type NewsletterMute = 'ON' | 'OFF' | 'UNDEFINED'
+
+export type NewsletterViewRole = 'ADMIN' | 'GUEST' | 'OWNER' | 'SUBSCRIBER'
+
+export type NewsletterViewerMetadata = {
+    mute: NewsletterMute
+    view_role: NewsletterViewRole
+}
+
+export type NewsletterMetadata = {
+    /**jid of newsletter */
+    id: string
+    /**state of newsletter */
+    state: NewsletterState
+    /**creation timestamp of newsletter */
+    creation_time: number
+    /**name of newsletter */
+    name: string
+    /**timestamp of last name modification of newsletter */
+    nameTime: number
+    /**description of newsletter */
+    description: string
+    /**timestamp of last description modification of newsletter */
+    descriptionTime: number
+    /**invite code of newsletter */
+    invite: string
+    /**i dont know */
+    handle: null
+    /**direct path of picture */
+    picture: string | null
+    /**direct path of picture preview (lower quality) */
+    preview: string | null
+    /**reaction mode of newsletter */
+    reaction_codes?: NewsletterReactionMode
+    /**subscribers count of newsletter */
+    subscribers: number
+    /**verification state of newsletter */
+    verification: NewsletterVerification
+    /**viewer metadata */
+    viewer_metadata: NewsletterViewerMetadata
+}
+
+export type SubscriberAction = 'promote' | 'demote'
+
+export type ReactionModeUpdate = {reaction_codes: {blocked_codes: null, enabled_ts_sec: null, value: NewsletterReactionMode}}
+
+/**only exists reaction mode update */
+export type NewsletterSettingsUpdate = ReactionModeUpdate
+
+export type NewsletterReaction = {count: number, code: string}
+
+export type NewsletterFetchedUpdate = {
+    /**id of message in newsletter, starts from 100 */
+    server_id: string
+    /**count of views in this message */
+    views?: number
+    /**reactions in this message */
+    reactions: NewsletterReaction[]
+    /**the message, if you requested only updates, you will not receive message */
+    message?: proto.IWebMessageInfo
+}
+
+export enum MexOperations {
+    PROMOTE = 'NotificationNewsletterAdminPromote',
+    DEMOTE = 'NotificationNewsletterAdminDemote',
+    UPDATE = 'NotificationNewsletterUpdate'
+}
+
+export enum XWAPaths {
+    PROMOTE = 'xwa2_notify_newsletter_admin_promote',
+    DEMOTE = 'xwa2_notify_newsletter_admin_demote',
+    ADMIN_COUNT = 'xwa2_newsletter_admin',
+    CREATE = 'xwa2_newsletter_create',
+    NEWSLETTER = 'xwa2_newsletter',
+    METADATA_UPDATE = 'xwa2_notify_newsletter_on_metadata_update'
+}
+
+export enum QueryIds {
+    JOB_MUTATION = '7150902998257522',
+    METADATA = '6620195908089573',
+    UNFOLLOW = '7238632346214362',
+    FOLLOW = '7871414976211147',
+    UNMUTE = '7337137176362961',
+    MUTE = '25151904754424642',
+    CREATE = '6996806640408138',
+    ADMIN_COUNT = '7130823597031706',
+    CHANGE_OWNER = '7341777602580933',
+    DELETE = '8316537688363079',
+    DEMOTE = '6551828931592903'
+}

package/src/Types/Product.ts

@@ -0,0 +1,85 @@
+import { WAMediaUpload } from './Message'
+
+export type CatalogResult = {
+	data: {
+		paging: { cursors: { before: string, after: string } }
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		data: any[]
+	}
+}
+
+export type ProductCreateResult = {
+	data: { product: {} }
+}
+
+export type CatalogStatus = {
+	status: string
+	canAppeal: boolean
+}
+
+export type CatalogCollection = {
+	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
+}
+
+export type ProductCreate = ProductBase & {
+	/** ISO country code for product origin. Set to undefined for no country */
+	originCountryCode: string | undefined
+	/** images of the product */
+	images: WAMediaUpload[]
+}
+
+export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>
+
+export type Product = ProductBase & {
+	id: string
+	imageUrls: { [_: string]: string }
+	reviewStatus: { [_: string]: string }
+	availability: ProductAvailability
+}
+
+export type OrderPrice = {
+	currency: string
+	total: number
+}
+
+export type OrderProduct = {
+	id: string
+	imageUrl: string
+	name: string
+	quantity: number
+
+	currency: string
+	price: number
+}
+
+export type OrderDetails = {
+	price: OrderPrice
+	products: OrderProduct[]
+}
+
+export type CatalogCursor = string
+
+export type GetCatalogOptions = {
+	/** cursor to start from */
+	cursor?: CatalogCursor
+	/** number of products to fetch */
+	limit?: number
+
+	jid?: string
+}

package/src/Types/Signal.ts

@@ -0,0 +1,68 @@
+import { proto } from '../../WAProto'
+
+type DecryptGroupSignalOpts = {
+	group: string
+	authorJid: string
+	msg: 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
+	}>
+	encryptGroupMessage(opts: EncryptGroupMessageOpts): Promise<{
+		senderKeyDistributionMessage: Uint8Array
+		ciphertext: Uint8Array
+	}>
+	injectE2ESession(opts: E2ESessionOpts): Promise<void>
+	jidToSignalProtocolAddress(jid: string): string
+}

package/{lib/Types/Socket.d.ts → src/Types/Socket.ts}

@@ -1,111 +1,123 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { AxiosRequestConfig } from 'axios';
-import type { Agent } from 'https';
-import type { Logger } from 'pino';
-import type { URL } from 'url';
-import { proto } from '../../WAProto';
-import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth';
-import { MediaConnInfo } from './Message';
-import { SignalRepository } from './Signal';
-export type WAVersion = [number, number, number];
-export type WABrowserDescription = [string, string, string];
+
+import { AxiosRequestConfig } from 'axios'
+import type { Agent } from 'https'
+import type { Logger } from 'pino'
+import type { URL } from 'url'
+import { proto } from '../../WAProto'
+import { AuthenticationState, SignalAuthState, TransactionCapabilityOptions } from './Auth'
+import { MediaConnInfo } from './Message'
+import { SignalRepository } 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): T | undefined;
+    get<T>(key: string): T | undefined
     /** set a key in the cache */
-    set<T>(key: string, value: T): void;
+    set<T>(key: string, value: T): void
     /** delete a key from the cache */
-    del(key: string): void;
+    del(key: string): void
     /** flush all data */
-    flushAll(): void;
-};
+    flushAll(): void
+}
+
 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;
-    /** should baileys use the mobile api instead of the multi device api */
-    mobile?: boolean;
+    keepAliveIntervalMs: number
+	/** should baileys use the mobile api instead of the multi device api */
+	mobile?: boolean
     /** proxy agent */
-    agent?: Agent;
+    agent?: Agent
     /** pino logger */
-    logger: Logger;
+    logger: Logger
     /** version to connect with */
-    version: WAVersion;
+    version: WAVersion
     /** override browser config */
-    browser: WABrowserDescription;
+    browser: WABrowserDescription
     /** agent used for fetch requests -- uploading/downloading media */
-    fetchAgent?: Agent;
+    fetchAgent?: Agent
     /** should the QR be printed in the terminal */
-    printQRInTerminal: boolean;
+    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;
+    auth: AuthenticationState
     /** manage history processing with this control; by default will sync up everything */
-    shouldSyncHistoryMessage: (msg: proto.Message.IHistorySyncNotification) => boolean;
+    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
+
     /** 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;
      * 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?: CacheStore;
+    userDevicesCache?: CacheStore
     /** cache to store call offers */
-    callOfferCache?: CacheStore;
+    callOfferCache?: 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
+
     /**
      * 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<proto.IMessage> | proto.IMessage;
+    patchMessageBeforeSending: (
+        msg: proto.IMessage,
+        recipientJids: string[],
+    ) => Promise<proto.IMessage> | proto.IMessage
+
     /** verify app state MACs */
     appStateMacVerification: {
-        patch: boolean;
-        snapshot: boolean;
-    };
+        patch: boolean
+        snapshot: boolean
+    }
+
     /** options for axios */
-    options: AxiosRequestConfig<{}>;
+    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>;
-    makeSignalRepository: (auth: SignalAuthState) => SignalRepository;
+    getMessage: (key: proto.IMessageKey) => Promise<proto.IMessage | undefined>
+
+    makeSignalRepository: (auth: SignalAuthState) => SignalRepository
+
     /** Socket passthrough */
-    socket?: any;
-};
+    socket?: any
+}

package/src/Types/State.ts

@@ -0,0 +1,29 @@
+import { Contact } from './Contact'
+
+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: 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 → src}/Types/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./Chat"), exports);
 __exportStar(require("./Contact"), exports);
 __exportStar(require("./State"), exports);
 __exportStar(require("./Message"), exports);
+__exportStar(require("./Newsletter"), exports);
 __exportStar(require("./Socket"), exports);
 __exportStar(require("./Events"), exports);
 __exportStar(require("./Product"), exports);
@@ -38,4 +39,4 @@ var DisconnectReason;
     DisconnectReason[DisconnectReason["multideviceMismatch"] = 411] = "multideviceMismatch";
     DisconnectReason[DisconnectReason["forbidden"] = 403] = "forbidden";
     DisconnectReason[DisconnectReason["unavailableService"] = 503] = "unavailableService";
-})(DisconnectReason = exports.DisconnectReason || (exports.DisconnectReason = {}));
+})(DisconnectReason || (exports.DisconnectReason = DisconnectReason = {}));

package/src/Types/index.ts

@@ -0,0 +1,59 @@
+export * from './Auth'
+export * from './GroupMetadata'
+export * from './Chat'
+export * from './Contact'
+export * from './State'
+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 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 }