@d0v3riz/baileys 6.3.1 → 6.4.0

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

@@ -7,14 +7,14 @@ import type { BaileysEventEmitter, Chat, ConnectionState, Contact, GroupMetadata
 import { Label } from '../Types/Label';
 import { LabelAssociation } from '../Types/LabelAssociation';
 import { ObjectRepository } from './object-repository';
-declare type WASocket = ReturnType<typeof makeMDSocket>;
+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 declare type BaileysInMemoryStoreConfig = {
+export type BaileysInMemoryStoreConfig = {
     chatKey?: Comparable<Chat, string>;
     labelAssociationKey?: Comparable<LabelAssociation, string>;
     logger?: Logger;

package/lib/Types/Auth.d.ts

@@ -3,25 +3,25 @@ import type { proto } from '../../WAProto';
 import { RegistrationOptions } from '../Socket/registration';
 import type { Contact } from './Contact';
 import type { MinimalMessage } from './Message';
-export declare type KeyPair = {
+export type KeyPair = {
     public: Uint8Array;
     private: Uint8Array;
 };
-export declare type SignedKeyPair = {
+export type SignedKeyPair = {
     keyPair: KeyPair;
     signature: Uint8Array;
     keyId: number;
     timestampS?: number;
 };
-export declare type ProtocolAddress = {
+export type ProtocolAddress = {
     name: string;
     deviceId: number;
 };
-export declare type SignalIdentity = {
+export type SignalIdentity = {
     identifier: ProtocolAddress;
     identifierKey: Uint8Array;
 };
-export declare type LTHashState = {
+export type LTHashState = {
     version: number;
     hash: Buffer;
     indexValueMap: {
@@ -30,20 +30,21 @@ export declare type LTHashState = {
         };
     };
 };
-export declare type SignalCreds = {
+export type SignalCreds = {
     readonly signedIdentityKey: KeyPair;
     readonly signedPreKey: SignedKeyPair;
     readonly registrationId: number;
 };
-export declare type AccountSettings = {
+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 declare type AuthenticationCreds = SignalCreds & {
+export type AuthenticationCreds = SignalCreds & {
     readonly noiseKey: KeyPair;
-    readonly advSecretKey: string;
+    readonly pairingEphemeralKeyPair: KeyPair;
+    advSecretKey: string;
     me?: Contact;
     account?: proto.IADVSignedDeviceIdentity;
     signalIdentities?: SignalIdentity[];
@@ -62,8 +63,9 @@ export declare type AuthenticationCreds = SignalCreds & {
     registered: boolean;
     backupToken: Buffer;
     registration: RegistrationOptions;
+    pairingCode: string | undefined;
 };
-export declare type SignalDataTypeMap = {
+export type SignalDataTypeMap = {
     'pre-key': KeyPair;
     'session': Uint8Array;
     'sender-key': Uint8Array;
@@ -73,13 +75,13 @@ export declare type SignalDataTypeMap = {
     'app-state-sync-key': proto.Message.IAppStateSyncKeyData;
     'app-state-sync-version': LTHashState;
 };
-export declare type SignalDataSet = {
+export type SignalDataSet = {
     [T in keyof SignalDataTypeMap]?: {
         [id: string]: SignalDataTypeMap[T] | null;
     };
 };
-declare type Awaitable<T> = T | Promise<T>;
-export declare type SignalKeyStore = {
+type Awaitable<T> = T | Promise<T>;
+export type SignalKeyStore = {
     get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
         [id: string]: SignalDataTypeMap[T];
     }>;
@@ -87,19 +89,19 @@ export declare type SignalKeyStore = {
     /** clear all the data in the store */
     clear?(): Awaitable<void>;
 };
-export declare type SignalKeyStoreWithTransaction = SignalKeyStore & {
+export type SignalKeyStoreWithTransaction = SignalKeyStore & {
     isInTransaction: () => boolean;
     transaction<T>(exec: () => Promise<T>): Promise<T>;
 };
-export declare type TransactionCapabilityOptions = {
+export type TransactionCapabilityOptions = {
     maxCommitRetries: number;
     delayBetweenTriesMs: number;
 };
-export declare type SignalAuthState = {
+export type SignalAuthState = {
     creds: SignalCreds;
     keys: SignalKeyStore | SignalKeyStoreWithTransaction;
 };
-export declare type AuthenticationState = {
+export type AuthenticationState = {
     creds: AuthenticationCreds;
     keys: SignalKeyStore;
 };

package/lib/Types/Call.d.ts

@@ -1,5 +1,5 @@
-export declare type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
-export declare type WACallEvent = {
+export type WACallUpdateType = 'offer' | 'ringing' | 'timeout' | 'reject' | 'accept';
+export type WACallEvent = {
     chatId: string;
     from: string;
     isGroup?: boolean;

package/lib/Types/Chat.d.ts

@@ -5,33 +5,33 @@ import type { ChatLabelAssociationActionBody } from './LabelAssociation';
 import type { MessageLabelAssociationActionBody } from './LabelAssociation';
 import type { MinimalMessage } from './Message';
 /** privacy settings in WhatsApp Web */
-export declare type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
-export declare type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
-export declare type WAReadReceiptsValue = 'all' | 'none';
+export type WAPrivacyValue = 'all' | 'contacts' | 'contact_blacklist' | 'none';
+export type WAPrivacyOnlineValue = 'all' | 'match_last_seen';
+export type WAReadReceiptsValue = 'all' | 'none';
 /** set of statuses visible to other people; see updatePresence() in WhatsAppWeb.Send */
-export declare type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
+export type WAPresence = 'unavailable' | 'available' | 'composing' | 'recording' | 'paused';
 export declare const ALL_WA_PATCH_NAMES: readonly ["critical_block", "critical_unblock_low", "regular_high", "regular_low", "regular"];
-export declare type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
+export type WAPatchName = typeof ALL_WA_PATCH_NAMES[number];
 export interface PresenceData {
     lastKnownPresence: WAPresence;
     lastSeen?: number;
 }
-export declare type ChatMutation = {
+export type ChatMutation = {
     syncAction: proto.ISyncActionData;
     index: string[];
 };
-export declare type WAPatchCreate = {
+export type WAPatchCreate = {
     syncAction: proto.ISyncActionValue;
     index: string[];
     type: WAPatchName;
     apiVersion: number;
     operation: proto.SyncdMutation.SyncdOperation;
 };
-export declare type Chat = proto.IConversation & {
+export type Chat = proto.IConversation & {
     /** unix timestamp of when the last message was received in the chat */
     lastMessageRecvTimestamp?: number;
 };
-export declare type ChatUpdate = Partial<Chat & {
+export type ChatUpdate = Partial<Chat & {
     /**
      * if specified in the update,
      * the EV buffer will check if the condition gets fulfilled before applying the update
@@ -47,8 +47,8 @@ export declare type ChatUpdate = Partial<Chat & {
  * the last messages in a chat, sorted reverse-chronologically. That is, the latest message should be first in the chat
  * for MD modifications, the last message in the array (i.e. the earlist message) must be the last message recv in the chat
  * */
-export declare type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange;
-export declare type ChatModification = {
+export type LastMessageList = MinimalMessage[] | proto.SyncActionValue.ISyncActionMessageRange;
+export type ChatModification = {
     archive: boolean;
     lastMessages: LastMessageList;
 } | {
@@ -89,7 +89,7 @@ export declare type ChatModification = {
 } | {
     removeMessageLabel: MessageLabelAssociationActionBody;
 };
-export declare type InitialReceivedChatsState = {
+export type InitialReceivedChatsState = {
     [jid: string]: {
         /** the last message received from the other party */
         lastMsgRecvTimestamp?: number;
@@ -97,6 +97,6 @@ export declare type InitialReceivedChatsState = {
         lastMsgTimestamp: number;
     };
 };
-export declare type InitialAppStateSyncOptions = {
+export type InitialAppStateSyncOptions = {
     accountSettings: AccountSettings;
 };

package/lib/Types/Events.d.ts

@@ -9,7 +9,7 @@ import { Label } from './Label';
 import { LabelAssociation } from './LabelAssociation';
 import { MessageUpsertType, MessageUserReceiptUpdate, WAMessage, WAMessageKey, WAMessageUpdate } from './Message';
 import { ConnectionState } from './State';
-export declare type BaileysEventMap = {
+export type BaileysEventMap = {
     /** connection state has been updated -- WS closed, opened, connecting etc. */
     'connection.update': Partial<ConnectionState>;
     /** credentials updated -- some metadata, keys or something */
@@ -88,7 +88,7 @@ export declare type BaileysEventMap = {
         type: 'add' | 'remove';
     };
 };
-export declare type BufferedEventData = {
+export type BufferedEventData = {
     historySets: {
         chats: {
             [jid: string]: Chat;
@@ -143,7 +143,7 @@ export declare type BufferedEventData = {
         [jid: string]: Partial<GroupMetadata>;
     };
 };
-export declare type BaileysEvent = keyof BaileysEventMap;
+export type BaileysEvent = keyof BaileysEventMap;
 export interface BaileysEventEmitter {
     on<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;
     off<T extends keyof BaileysEventMap>(event: T, listener: (arg: BaileysEventMap[T]) => void): void;

package/lib/Types/GroupMetadata.d.ts

@@ -1,10 +1,10 @@
 import { Contact } from './Contact';
-export declare type GroupParticipant = (Contact & {
+export type GroupParticipant = (Contact & {
     isAdmin?: boolean;
     isSuperAdmin?: boolean;
     admin?: 'admin' | 'superadmin' | null;
 });
-export declare type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
+export type ParticipantAction = 'add' | 'remove' | 'promote' | 'demote';
 export interface GroupMetadata {
     id: string;
     owner: string | undefined;

package/lib/Types/LabelAssociation.d.ts

@@ -3,7 +3,7 @@ export declare enum LabelAssociationType {
     Chat = "label_jid",
     Message = "label_message"
 }
-export declare type LabelAssociationTypes = `${LabelAssociationType}`;
+export type LabelAssociationTypes = `${LabelAssociationType}`;
 /** Association for chat */
 export interface ChatLabelAssociation {
     type: LabelAssociationType.Chat;
@@ -17,7 +17,7 @@ export interface MessageLabelAssociation {
     messageId: string;
     labelId: string;
 }
-export declare type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation;
+export type LabelAssociation = ChatLabelAssociation | MessageLabelAssociation;
 /** Body for add/remove chat label association action */
 export interface ChatLabelAssociationActionBody {
     labelId: string;

package/lib/Types/Message.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { AxiosRequestConfig } from 'axios';
 import type { Logger } from 'pino';
 import type { Readable } from 'stream';
@@ -8,31 +10,31 @@ import { MEDIA_HKDF_KEY_MAPPING } from '../Defaults';
 import type { GroupMetadata } from './GroupMetadata';
 import { CacheStore } from './Socket';
 export { proto as WAProto };
-export declare type WAMessage = proto.IWebMessageInfo;
-export declare type WAMessageContent = proto.IMessage;
-export declare type WAContactMessage = proto.Message.IContactMessage;
-export declare type WAContactsArrayMessage = proto.Message.IContactsArrayMessage;
-export declare type WAMessageKey = proto.IMessageKey;
-export declare type WATextMessage = proto.Message.IExtendedTextMessage;
-export declare type WAContextInfo = proto.IContextInfo;
-export declare type WALocationMessage = proto.Message.ILocationMessage;
-export declare type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
+export type WAMessage = proto.IWebMessageInfo;
+export type WAMessageContent = proto.IMessage;
+export type WAContactMessage = proto.Message.IContactMessage;
+export type WAContactsArrayMessage = proto.Message.IContactsArrayMessage;
+export type WAMessageKey = proto.IMessageKey;
+export type WATextMessage = proto.Message.IExtendedTextMessage;
+export type WAContextInfo = proto.IContextInfo;
+export type WALocationMessage = proto.Message.ILocationMessage;
+export type WAGenericMediaMessage = proto.Message.IVideoMessage | proto.Message.IImageMessage | proto.Message.IAudioMessage | proto.Message.IDocumentMessage | proto.Message.IStickerMessage;
 export import WAMessageStubType = proto.WebMessageInfo.StubType;
 export import WAMessageStatus = proto.WebMessageInfo.Status;
-export declare type WAMediaUpload = Buffer | {
+export type WAMediaUpload = Buffer | {
     url: URL | string;
 } | {
     stream: Readable;
 };
 /** Set of message types that are supported by the library */
-export declare type MessageType = keyof proto.Message;
-export declare type DownloadableMessage = {
+export type MessageType = keyof proto.Message;
+export type DownloadableMessage = {
     mediaKey?: Uint8Array | null;
     directPath?: string | null;
     url?: string | null;
 };
-export declare type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined;
-export declare type MediaConnInfo = {
+export type MessageReceiptType = 'read' | 'read-self' | 'hist_sync' | 'peer_msg' | 'sender' | 'inactive' | 'played' | undefined;
+export type MediaConnInfo = {
     auth: string;
     ttl: number;
     hosts: {
@@ -50,30 +52,30 @@ export interface WAUrlInfo {
     highQualityThumbnail?: proto.Message.IImageMessage;
     originalThumbnailUrl?: string;
 }
-declare type Mentionable = {
+type Mentionable = {
     /** list of jids that are mentioned in the accompanying text */
     mentions?: string[];
 };
-declare type Contextable = {
+type Contextable = {
     /** add contextInfo to the message */
     contextInfo?: proto.IContextInfo;
 };
-declare type ViewOnce = {
+type ViewOnce = {
     viewOnce?: boolean;
 };
-declare type Buttonable = {
+type Buttonable = {
     /** add buttons to the message  */
     buttons?: proto.Message.ButtonsMessage.IButton[];
 };
-declare type Templatable = {
+type Templatable = {
     /** add buttons to the message (conflicts with normal buttons)*/
     templateButtons?: proto.IHydratedTemplateButton[];
     footer?: string;
 };
-declare type Editable = {
+type Editable = {
     edit?: WAMessageKey;
 };
-declare type Listable = {
+type Listable = {
     /** Sections of the List */
     sections?: proto.Message.ListMessage.ISection[];
     /** Title of a List Message only */
@@ -81,19 +83,19 @@ declare type Listable = {
     /** Text of the bnutton on the list (required) */
     buttonText?: string;
 };
-declare type WithDimensions = {
+type WithDimensions = {
     width?: number;
     height?: number;
 };
-export declare type PollMessageOptions = {
+export type PollMessageOptions = {
     name: string;
     selectableCount?: number;
     values: string[];
     /** 32 byte message secret to encrypt poll selections */
     messageSecret?: Uint8Array;
 };
-export declare type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING;
-export declare type AnyMediaMessageContent = (({
+export type MediaType = keyof typeof MEDIA_HKDF_KEY_MAPPING;
+export type AnyMediaMessageContent = (({
     image: WAMediaUpload;
     caption?: string;
     jpegThumbnail?: string;
@@ -119,15 +121,15 @@ export declare type AnyMediaMessageContent = (({
 } & Contextable & Buttonable & Templatable)) & {
     mimetype?: string;
 } & Editable;
-export declare type ButtonReplyInfo = {
+export type ButtonReplyInfo = {
     displayText: string;
     id: string;
     index: number;
 };
-export declare type WASendableProduct = Omit<proto.Message.ProductMessage.IProductSnapshot, 'productImage'> & {
+export type WASendableProduct = Omit<proto.Message.ProductMessage.IProductSnapshot, 'productImage'> & {
     productImage: WAMediaUpload;
 };
-export declare type AnyRegularMessageContent = (({
+export type AnyRegularMessageContent = (({
     text: string;
     linkPreview?: WAUrlInfo | null;
 } & Mentionable & Contextable & Buttonable & Templatable & Listable & Editable) | AnyMediaMessageContent | ({
@@ -152,7 +154,7 @@ export declare type AnyRegularMessageContent = (({
     body?: string;
     footer?: string;
 }) & ViewOnce;
-export declare type AnyMessageContent = AnyRegularMessageContent | {
+export type AnyMessageContent = AnyRegularMessageContent | {
     forward: WAMessage;
     force?: boolean;
 } | {
@@ -161,14 +163,14 @@ export declare type AnyMessageContent = AnyRegularMessageContent | {
 } | {
     disappearingMessagesInChat: boolean | number;
 };
-export declare type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
-declare type MinimalRelayOptions = {
+export type GroupMetadataParticipants = Pick<GroupMetadata, 'participants'>;
+type MinimalRelayOptions = {
     /** override the message ID with a custom provided string */
     messageId?: string;
     /** cached group metadata, use to prevent redundant requests to WA & speed up msg sending */
     cachedGroupMetadata?: (jid: string) => Promise<GroupMetadataParticipants | undefined>;
 };
-export declare type MessageRelayOptions = MinimalRelayOptions & {
+export type MessageRelayOptions = MinimalRelayOptions & {
     /** only send to a specific participant; used when a message decryption fails for a single user */
     participant?: {
         jid: string;
@@ -180,8 +182,10 @@ export declare type MessageRelayOptions = MinimalRelayOptions & {
     };
     /** should we use the devices cache, or fetch afresh from the server; default assumed to be "true" */
     useUserDevicesCache?: boolean;
+    /** jid list of participants for status@broadcast */
+    statusJidList?: string[];
 };
-export declare type MiscMessageGenerationOptions = MinimalRelayOptions & {
+export type MiscMessageGenerationOptions = MinimalRelayOptions & {
     /** optional, if you want to manually set the timestamp of the message */
     timestamp?: Date;
     /** the message you want to quote */
@@ -192,11 +196,17 @@ export declare type MiscMessageGenerationOptions = MinimalRelayOptions & {
     ephemeralExpiration?: number | string;
     /** timeout for media upload to WA server */
     mediaUploadTimeoutMs?: number;
+    /** jid list of participants for status@broadcast */
+    statusJidList?: string[];
+    /** backgroundcolor for status */
+    backgroundColor?: string;
+    /** font type for status */
+    font?: number;
 };
-export declare type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
+export type MessageGenerationOptionsFromContent = MiscMessageGenerationOptions & {
     userJid: string;
 };
-export declare type WAMediaUploadFunction = (readStream: Readable, opts: {
+export type WAMediaUploadFunction = (readStream: Readable, opts: {
     fileEncSha256B64: string;
     mediaType: MediaType;
     timeoutMs?: number;
@@ -204,7 +214,7 @@ export declare type WAMediaUploadFunction = (readStream: Readable, opts: {
     mediaUrl: string;
     directPath: string;
 }>;
-export declare type MediaGenerationOptions = {
+export type MediaGenerationOptions = {
     logger?: Logger;
     mediaTypeOverride?: MediaType;
     upload: WAMediaUploadFunction;
@@ -212,34 +222,36 @@ export declare type MediaGenerationOptions = {
     mediaCache?: CacheStore;
     mediaUploadTimeoutMs?: number;
     options?: AxiosRequestConfig;
+    backgroundColor?: string;
+    font?: number;
 };
-export declare type MessageContentGenerationOptions = MediaGenerationOptions & {
+export type MessageContentGenerationOptions = MediaGenerationOptions & {
     getUrlInfo?: (text: string) => Promise<WAUrlInfo | undefined>;
 };
-export declare type MessageGenerationOptions = MessageContentGenerationOptions & MessageGenerationOptionsFromContent;
+export type MessageGenerationOptions = MessageContentGenerationOptions & MessageGenerationOptionsFromContent;
 /**
  * Type of message upsert
  * 1. notify => notify the user, this message was just received
  * 2. append => append the message to the chat history, no notification required
  */
-export declare type MessageUpsertType = 'append' | 'notify';
-export declare type MessageUserReceipt = proto.IUserReceipt;
-export declare type WAMessageUpdate = {
+export type MessageUpsertType = 'append' | 'notify';
+export type MessageUserReceipt = proto.IUserReceipt;
+export type WAMessageUpdate = {
     update: Partial<WAMessage>;
     key: proto.IMessageKey;
 };
-export declare type WAMessageCursor = {
+export type WAMessageCursor = {
     before: WAMessageKey | undefined;
 } | {
     after: WAMessageKey | undefined;
 };
-export declare type MessageUserReceiptUpdate = {
+export type MessageUserReceiptUpdate = {
     key: proto.IMessageKey;
     receipt: MessageUserReceipt;
 };
-export declare type MediaDecryptionKeyInfo = {
+export type MediaDecryptionKeyInfo = {
     iv: Buffer;
     cipherKey: Buffer;
     macKey?: Buffer;
 };
-export declare type MinimalMessage = Pick<proto.IWebMessageInfo, 'key' | 'messageTimestamp'>;
+export type MinimalMessage = Pick<proto.IWebMessageInfo, 'key' | 'messageTimestamp'>;

package/lib/Types/Product.d.ts

@@ -1,5 +1,5 @@
 import { WAMediaUpload } from './Message';
-export declare type CatalogResult = {
+export type CatalogResult = {
     data: {
         paging: {
             cursors: {
@@ -10,23 +10,23 @@ export declare type CatalogResult = {
         data: any[];
     };
 };
-export declare type ProductCreateResult = {
+export type ProductCreateResult = {
     data: {
         product: {};
     };
 };
-export declare type CatalogStatus = {
+export type CatalogStatus = {
     status: string;
     canAppeal: boolean;
 };
-export declare type CatalogCollection = {
+export type CatalogCollection = {
     id: string;
     name: string;
     products: Product[];
     status: CatalogStatus;
 };
-export declare type ProductAvailability = 'in stock';
-export declare type ProductBase = {
+export type ProductAvailability = 'in stock';
+export type ProductBase = {
     name: string;
     retailerId?: string;
     url?: string;
@@ -35,14 +35,14 @@ export declare type ProductBase = {
     currency: string;
     isHidden?: boolean;
 };
-export declare type ProductCreate = ProductBase & {
+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 declare type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>;
-export declare type Product = ProductBase & {
+export type ProductUpdate = Omit<ProductCreate, 'originCountryCode'>;
+export type Product = ProductBase & {
     id: string;
     imageUrls: {
         [_: string]: string;
@@ -52,11 +52,11 @@ export declare type Product = ProductBase & {
     };
     availability: ProductAvailability;
 };
-export declare type OrderPrice = {
+export type OrderPrice = {
     currency: string;
     total: number;
 };
-export declare type OrderProduct = {
+export type OrderProduct = {
     id: string;
     imageUrl: string;
     name: string;
@@ -64,12 +64,12 @@ export declare type OrderProduct = {
     currency: string;
     price: number;
 };
-export declare type OrderDetails = {
+export type OrderDetails = {
     price: OrderPrice;
     products: OrderProduct[];
 };
-export declare type CatalogCursor = string;
-export declare type GetCatalogOptions = {
+export type CatalogCursor = string;
+export type GetCatalogOptions = {
     /** cursor to start from */
     cursor?: CatalogCursor;
     /** number of products to fetch */

package/lib/Types/Signal.d.ts

@@ -1,45 +1,45 @@
 import { proto } from '../../WAProto';
-declare type DecryptGroupSignalOpts = {
+type DecryptGroupSignalOpts = {
     group: string;
     authorJid: string;
     msg: Uint8Array;
 };
-declare type ProcessSenderKeyDistributionMessageOpts = {
+type ProcessSenderKeyDistributionMessageOpts = {
     item: proto.Message.ISenderKeyDistributionMessage;
     authorJid: string;
 };
-declare type DecryptSignalProtoOpts = {
+type DecryptSignalProtoOpts = {
     jid: string;
     type: 'pkmsg' | 'msg';
     ciphertext: Uint8Array;
 };
-declare type EncryptMessageOpts = {
+type EncryptMessageOpts = {
     jid: string;
     data: Uint8Array;
 };
-declare type EncryptGroupMessageOpts = {
+type EncryptGroupMessageOpts = {
     group: string;
     data: Uint8Array;
     meId: string;
 };
-declare type PreKey = {
+type PreKey = {
     keyId: number;
     publicKey: Uint8Array;
 };
-declare type SignedPreKey = PreKey & {
+type SignedPreKey = PreKey & {
     signature: Uint8Array;
 };
-declare type E2ESession = {
+type E2ESession = {
     registrationId: number;
     identityKey: Uint8Array;
     signedPreKey: SignedPreKey;
     preKey: PreKey;
 };
-declare type E2ESessionOpts = {
+type E2ESessionOpts = {
     jid: string;
     session: E2ESession;
 };
-export declare type SignalRepository = {
+export type SignalRepository = {
     decryptGroupMessage(opts: DecryptGroupSignalOpts): Promise<Uint8Array>;
     processSenderKeyDistributionMessage(opts: ProcessSenderKeyDistributionMessageOpts): Promise<void>;
     decryptMessage(opts: DecryptSignalProtoOpts): Promise<Uint8Array>;