zaileys 0.29.7-beta → 0.29.9-beta

package/dist/classes/Client.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { ClientClassesType } from "../types/classes/client";
+import { EventCallbackType, EventEnumType } from "../types/classes/event";
+declare class Client {
+    private props;
+    options: z.infer<typeof ClientClassesType> | undefined;
+    private chatId;
+    private logger;
+    private event;
+    private db;
+    private socket;
+    private groupCache;
+    constructor(props: z.input<typeof ClientClassesType>);
+    initialize(): Promise<void>;
+    on<T extends EventEnumType>(event: T, handler: EventCallbackType[T]): void;
+}
+export default Client;

package/dist/classes/Event.d.ts

@@ -0,0 +1,12 @@
+import { WASocket } from "baileys";
+import { EventCallbackType, EventEnumType } from "../types/classes/event";
+import Client from "./Client";
+declare class Event {
+    private client;
+    private events;
+    constructor(client: Client);
+    setup(sock: WASocket): void;
+    on<T extends EventEnumType>(event: T, handler: EventCallbackType[T]): void;
+    private emit;
+}
+export default Event;

package/dist/classes/Parser.d.ts

@@ -0,0 +1,3 @@
+export default class Parser {
+    constructor(parameters: any);
+}

package/dist/database/handler.d.ts

@@ -0,0 +1,12 @@
+import { Kysely } from "kysely";
+import { z } from "zod";
+import { AuthAdapterHandlerType } from "../types/adapter/general";
+import { AdapterDatabaseType } from "../types/classes/client";
+import type { DB } from "./schema";
+import { BaileysEventEmitter } from "baileys";
+export declare const ConnectDB: (type: z.infer<typeof AdapterDatabaseType>["type"], url: string) => Kysely<DB>;
+export declare const MigrateDB: (db: Kysely<DB>) => Promise<void>;
+export declare const AuthAdapterHandler: (db: Kysely<DB>, session: string) => AuthAdapterHandlerType;
+export declare const StoreAdapterHandler: (db: Kysely<DB>, session: string) => Promise<{
+    bind: (event: BaileysEventEmitter) => void;
+}>;

package/dist/database/schema.d.ts

@@ -0,0 +1,63 @@
+import { z } from "zod";
+export declare const AuthSchema: z.ZodObject<{
+    session: z.ZodString;
+    id: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+    value: string | null;
+    id: string;
+}, {
+    session: string;
+    value: string | null;
+    id: string;
+}>;
+export declare const ChatSchema: z.ZodObject<{
+    session: z.ZodString;
+    id: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+    value: string | null;
+    id: string;
+}, {
+    session: string;
+    value: string | null;
+    id: string;
+}>;
+export declare const ContactSchema: z.ZodObject<{
+    session: z.ZodString;
+    id: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+    value: string | null;
+    id: string;
+}, {
+    session: string;
+    value: string | null;
+    id: string;
+}>;
+export declare const MessageSchema: z.ZodObject<{
+    session: z.ZodString;
+    id: z.ZodString;
+    value: z.ZodNullable<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    session: string;
+    value: string | null;
+    id: string;
+}, {
+    session: string;
+    value: string | null;
+    id: string;
+}>;
+export type AuthTable = z.infer<typeof AuthSchema>;
+export type ChatTable = z.infer<typeof ChatSchema>;
+export type ContactTable = z.infer<typeof ContactSchema>;
+export type MessageTable = z.infer<typeof MessageSchema>;
+export type DB = {
+    auth: AuthTable;
+    chats: ChatTable;
+    contacts: ContactTable;
+    messages: MessageTable;
+};

package/dist/helpers/adapter.d.ts

@@ -0,0 +1,57 @@
+import { AppDataSync, valueReplacer, valueReviver } from "../types/adapter/general";
+export declare const fromObject: (args: AppDataSync) => {
+    keyData: Uint8Array<ArrayBuffer>;
+    fingerprint: {
+        rawId: number;
+        currentIndex: number;
+        deviceIndexes: number[];
+    };
+    timestamp: number | import("long").Long;
+};
+export declare const BufferJSON: {
+    replacer: (_: string, value: valueReplacer) => valueReplacer | {
+        type: string;
+        data: string;
+    };
+    reviver: (_: string, value: valueReviver) => valueReviver | Buffer<ArrayBuffer>;
+};
+export declare const initAuthCreds: () => {
+    noiseKey: {
+        private: Buffer<any>;
+        public: Buffer<any>;
+    };
+    pairingEphemeralKeyPair: {
+        private: Buffer<any>;
+        public: Buffer<any>;
+    };
+    signedIdentityKey: {
+        private: Buffer<any>;
+        public: Buffer<any>;
+    };
+    signedPreKey: {
+        keyPair: {
+            private: Buffer<any>;
+            public: Buffer<any>;
+        };
+        signature: any;
+        keyId: number;
+    };
+    registrationId: number;
+    advSecretKey: string;
+    processedHistoryMessages: never[];
+    nextPreKeyId: number;
+    firstUnuploadedPreKeyId: number;
+    accountSyncCounter: number;
+    accountSettings: {
+        unarchiveChats: boolean;
+    };
+    deviceId: string;
+    phoneId: `${string}-${string}-${string}-${string}-${string}`;
+    identityId: Buffer<ArrayBufferLike>;
+    backupToken: Buffer<ArrayBufferLike>;
+    registered: boolean;
+    registration: never;
+    pairingCode: undefined;
+    lastPropHash: undefined;
+    routingInfo: undefined;
+};

package/dist/helpers/error.d.ts

@@ -0,0 +1,8 @@
+import { ZodError } from "zod";
+export declare const handleZodError: (error: ZodError) => {
+    status: string;
+    errors: {
+        field: string;
+        message: string;
+    }[];
+};

package/dist/index.d.ts

@@ -1,235 +1,2 @@
-import { WABusinessProfile, proto } from '@whiskeysockets/baileys';
-import { EventEmitter } from 'events';
-
-declare const MESSAGE_TYPE: {
-    readonly text: "text";
-    readonly conversation: "text";
-    readonly imageMessage: "image";
-    readonly contactMessage: "contact";
-    readonly locationMessage: "location";
-    readonly documentMessage: "document";
-    readonly audioMessage: "audio";
-    readonly videoMessage: "video";
-    readonly protocolMessage: "protocol";
-    readonly contactsArrayMessage: "contactsArray";
-    readonly highlyStructuredMessage: "highlyStructured";
-    readonly sendPaymentMessage: "sendPayment";
-    readonly liveLocationMessage: "liveLocation";
-    readonly requestPaymentMessage: "requestPayment";
-    readonly declinePaymentRequestMessage: "declinePaymentRequest";
-    readonly cancelPaymentRequestMessage: "cancelPaymentRequest";
-    readonly templateMessage: "template";
-    readonly stickerMessage: "sticker";
-    readonly groupInviteMessage: "groupInvite";
-    readonly templateButtonReplyMessage: "templateButtonReply";
-    readonly productMessage: "product";
-    readonly deviceSentMessage: "deviceSent";
-    readonly listMessage: "list";
-    readonly viewOnceMessage: "viewOnce";
-    readonly orderMessage: "order";
-    readonly listResponseMessage: "listResponse";
-    readonly ephemeralMessage: "ephemeral";
-    readonly invoiceMessage: "invoice";
-    readonly buttonsMessage: "buttons";
-    readonly buttonsResponseMessage: "buttonsResponse";
-    readonly paymentInviteMessage: "paymentInvite";
-    readonly interactiveMessage: "interactive";
-    readonly reactionMessage: "reaction";
-    readonly stickerSyncRmrMessage: "sticker";
-    readonly interactiveResponseMessage: "interactiveResponse";
-    readonly pollCreationMessage: "pollCreation";
-    readonly pollUpdateMessage: "pollUpdate";
-    readonly keepInChatMessage: "keepInChat";
-    readonly documentWithCaptionMessage: "document";
-    readonly requestPhoneNumberMessage: "requestPhoneNumber";
-    readonly viewOnceMessageV2: "viewOnce";
-    readonly encReactionMessage: "reaction";
-    readonly editedMessage: "text";
-    readonly viewOnceMessageV2Extension: "viewOnce";
-    readonly pollCreationMessageV2: "pollCreation";
-    readonly scheduledCallCreationMessage: "scheduledCallCreation";
-    readonly groupMentionedMessage: "groupMentioned";
-    readonly pinInChatMessage: "pinInChat";
-    readonly pollCreationMessageV3: "pollCreation";
-    readonly scheduledCallEditMessage: "scheduledCallEdit";
-    readonly ptvMessage: "ptv";
-    readonly botInvokeMessage: "botInvoke";
-    readonly callLogMesssage: "callLog";
-    readonly encCommentMessage: "encComment";
-    readonly bcallMessage: "bcall";
-    readonly lottieStickerMessage: "lottieSticker";
-    readonly eventMessage: "event";
-    readonly commentMessage: "comment";
-    readonly newsletterAdminInviteMessage: "text";
-    readonly extendedTextMessageWithParentKey: "text";
-    readonly placeholderMessage: "placeholder";
-    readonly encEventUpdateMessage: "encEventUpdate";
-};
-declare const VERIFIED_PLATFORM: {
-    readonly whatsapp: "0@s.whatsapp.net";
-    readonly meta: "13135550002@s.whatsapp.net";
-    readonly chatgpt: "18002428478@s.whatsapp.net";
-    readonly copilot: "18772241042@s.whatsapp.net";
-    readonly instagram: "447723442971@s.whatsapp.net";
-    readonly tiktok: "6285574670498@s.whatsapp.net";
-};
-
-declare const Config_MESSAGE_TYPE: typeof MESSAGE_TYPE;
-declare const Config_VERIFIED_PLATFORM: typeof VERIFIED_PLATFORM;
-declare namespace Config {
-  export { Config_MESSAGE_TYPE as MESSAGE_TYPE, Config_VERIFIED_PLATFORM as VERIFIED_PLATFORM };
-}
-
-type FakeVerifiedEnum = keyof typeof VERIFIED_PLATFORM;
-type SendActionType = {
-    asReply?: boolean;
-    senderId?: string;
-};
-type ReplyActionType = {
-    footer?: string;
-    fakeVerified?: FakeVerifiedEnum;
-    senderId?: string;
-};
-
-type Action_FakeVerifiedEnum = FakeVerifiedEnum;
-type Action_ReplyActionType = ReplyActionType;
-type Action_SendActionType = SendActionType;
-declare namespace Action {
-  export type { Action_FakeVerifiedEnum as FakeVerifiedEnum, Action_ReplyActionType as ReplyActionType, Action_SendActionType as SendActionType };
-}
-
-type MessageTypeEnum = (typeof MESSAGE_TYPE)[keyof typeof MESSAGE_TYPE];
-type DeviceTypeEnum = "unknown" | "android" | "ios" | "desktop" | "web";
-type ExtractCitationType<T> = {
-    [K in keyof T as `is${Capitalize<K & string>}`]: boolean;
-};
-type MessageBaseContent<T> = {
-    fromMe: boolean;
-    chatId: string;
-    channelId: string;
-    roomId: string;
-    roomImage: () => Promise<string | null>;
-    senderId: string;
-    senderName: string;
-    senderDevice: DeviceTypeEnum;
-    senderBio: () => Promise<string | null>;
-    senderImage: () => Promise<string | null>;
-    senderBusiness: () => Promise<WABusinessProfile | null>;
-    chatType: MessageTypeEnum;
-    timestamp: number;
-    text: string;
-    command: string;
-    mentions: string[] | null;
-    isTagMe: boolean;
-    isGroup: boolean;
-    isStory: boolean;
-    isEdited: boolean;
-    isChannel: boolean;
-    isBroadcast: boolean;
-    isEphemeral: boolean;
-    isForwarded: boolean;
-    citation: {
-        [key: string]: unknown;
-    } | null;
-    media: {
-        buffer?: () => Promise<Buffer | null>;
-        stream?: () => Promise<Buffer | null>;
-        [key: string]: unknown;
-    } | null;
-    reply: MessageBaseContent<T> | null;
-    key: () => proto.IMessageKey;
-    message: () => proto.IWebMessageInfo;
-};
-
-type Message_DeviceTypeEnum = DeviceTypeEnum;
-type Message_ExtractCitationType<T> = ExtractCitationType<T>;
-type Message_MessageBaseContent<T> = MessageBaseContent<T>;
-type Message_MessageTypeEnum = MessageTypeEnum;
-declare namespace Message {
-  export type { Message_DeviceTypeEnum as DeviceTypeEnum, Message_ExtractCitationType as ExtractCitationType, Message_MessageBaseContent as MessageBaseContent, Message_MessageTypeEnum as MessageTypeEnum };
-}
-
-type AuthType = "pairing" | "qr";
-type CitationConfig = {
-    [key: string]: (() => string[]) | (() => Promise<string[]>);
-};
-interface BaseClientConfig {
-    prefix?: string;
-    ignoreMe?: boolean;
-    authPath?: string;
-    authType: AuthType;
-    showLogs?: boolean;
-    autoMentions?: boolean;
-    autoOnline?: boolean;
-    autoRead?: boolean;
-    autoRejectCall?: boolean;
-    citation?: CitationConfig;
-}
-interface PairingClientConfig extends BaseClientConfig {
-    authType: "pairing";
-    phoneNumber: number;
-}
-interface QRClientConfig extends BaseClientConfig {
-    authType: "qr";
-}
-type ClientConfig = PairingClientConfig | QRClientConfig;
-interface BaseContext {
-}
-interface ConnectionContext extends BaseContext {
-    status: "connecting" | "open" | "close";
-}
-interface ErrorContext extends BaseContext {
-    error: Error;
-}
-interface ClientEvents<B> {
-    connection: (ctx: ConnectionContext) => void;
-    message: (ctx: MessageBaseContent<B>) => void;
-    error: (ctx: ErrorContext) => void;
-}
-
-type General_AuthType = AuthType;
-type General_BaseClientConfig = BaseClientConfig;
-type General_BaseContext = BaseContext;
-type General_CitationConfig = CitationConfig;
-type General_ClientConfig = ClientConfig;
-type General_ClientEvents<B> = ClientEvents<B>;
-type General_ConnectionContext = ConnectionContext;
-type General_ErrorContext = ErrorContext;
-type General_PairingClientConfig = PairingClientConfig;
-type General_QRClientConfig = QRClientConfig;
-declare namespace General {
-  export type { General_AuthType as AuthType, General_BaseClientConfig as BaseClientConfig, General_BaseContext as BaseContext, General_CitationConfig as CitationConfig, General_ClientConfig as ClientConfig, General_ClientEvents as ClientEvents, General_ConnectionContext as ConnectionContext, General_ErrorContext as ErrorContext, General_PairingClientConfig as PairingClientConfig, General_QRClientConfig as QRClientConfig };
-}
-
-declare class Client extends EventEmitter {
-    private config;
-    private authState;
-    private authProvider;
-    private socket;
-    private store;
-    private groupCache;
-    private logger;
-    protected temporaryMessage: MessageBaseContent<any> | null;
-    protected parseMention: string[];
-    private spinner;
-    constructor(config: ClientConfig);
-    protected initialize(): Promise<void>;
-    private deleteSession;
-    on<K extends keyof ClientEvents<typeof this$1.config.citation>>(event: K, listener: ClientEvents<typeof this$1.config.citation>[K]): this;
-    emit<K extends keyof ClientEvents<typeof this$1.config.citation>>(event: K, ...args: Parameters<ClientEvents<typeof this$1.config.citation>[K]>): boolean;
-    protected generateMentions(mentions: string[]): string[];
-    protected generateFakeVerified(key: proto.IMessageKey, platform: FakeVerifiedEnum): {
-        participant: "0@s.whatsapp.net" | "13135550002@s.whatsapp.net" | "18002428478@s.whatsapp.net" | "18772241042@s.whatsapp.net" | "447723442971@s.whatsapp.net" | "6285574670498@s.whatsapp.net";
-        remoteJid?: string | null | undefined;
-        fromMe?: boolean | null | undefined;
-        id?: string | null | undefined;
-    };
-    sendText(text: string, payload?: ReplyActionType): Promise<void>;
-    sendReply(text: string, payload?: ReplyActionType): Promise<void>;
-    sendImage(image: string | Buffer, payload?: SendActionType): Promise<void>;
-    sendVideo(video: string | Buffer, payload?: SendActionType): Promise<void>;
-    sendAudio(audio: string | Buffer, payload?: SendActionType): Promise<void>;
-    sendSticker(sticker: string | Buffer, payload?: SendActionType): Promise<void>;
-}
-
-export { Client, Config, General, Message, Action as Types, Client as default };
+import Client from "./classes/Client";
+export default Client;

package/dist/types/adapter/general.d.ts

@@ -0,0 +1,156 @@
+type Awaitable<T> = T | Promise<T>;
+export type AuthAdapterHandlerType = Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    clear: () => Promise<void>;
+    removeCreds: () => Promise<void>;
+}>;
+type Contact = {
+    id: string;
+    lid?: string;
+    name?: string;
+    notify?: string;
+    verifiedName?: string;
+    imgUrl?: string | null;
+    status?: string;
+};
+type Account = {
+    details?: Uint8Array | null;
+    accountSignatureKey?: Uint8Array | null;
+    accountSignature?: Uint8Array | null;
+    deviceSignature?: Uint8Array | null;
+};
+type SignedKeyPair = {
+    keyPair: KeyPair;
+    signature: Uint8Array;
+    keyId: number;
+    timestampS?: number;
+};
+type ProtocolAddress = {
+    name: string;
+    deviceId: number;
+};
+type SignalIdentity = {
+    identifier: ProtocolAddress;
+    identifierKey: Uint8Array;
+};
+type LTHashState = {
+    version: number;
+    hash: Buffer;
+    indexValueMap: {
+        [indexMacBase64: string]: {
+            valueMac: Uint8Array | Buffer;
+        };
+    };
+};
+type SignalCreds = {
+    readonly signedIdentityKey: KeyPair;
+    readonly signedPreKey: SignedKeyPair;
+    readonly registrationId: number;
+};
+type AccountSettings = {
+    unarchiveChats: boolean;
+    defaultDisappearingMode?: Pick<any, "ephemeralExpiration" | "ephemeralSettingTimestamp">;
+};
+type SignalKeyStore = {
+    get<T extends keyof SignalDataTypeMap>(type: T, ids: string[]): Awaitable<{
+        [id: string]: SignalDataTypeMap[T];
+    }>;
+    set(data: SignalDataSet): Awaitable<void>;
+    clear?(): Awaitable<void>;
+};
+interface RegistrationOptions {
+    phoneNumber?: string;
+    phoneNumberCountryCode: string;
+    phoneNumberNationalNumber: string;
+    phoneNumberMobileCountryCode: string;
+    phoneNumberMobileNetworkCode: string;
+    method?: "sms" | "voice" | "captcha";
+    captcha?: string;
+}
+export type SslOptions = {
+    pfx?: string;
+    key?: string | string[] | Buffer | Buffer[];
+    passphrase?: string;
+    cert?: string | string[] | Buffer | Buffer[];
+    ca?: string | string[] | Buffer | Buffer[];
+    crl?: string | string[];
+    ciphers?: string;
+    rejectUnauthorized?: boolean;
+    minVersion?: string;
+    maxVersion?: string;
+    verifyIdentity?: boolean;
+};
+export type Fingerprint = {
+    rawId: number;
+    currentIndex: number;
+    deviceIndexes: number[];
+};
+export type AppDataSync = {
+    keyData: Uint8Array;
+    fingerprint: Fingerprint;
+    timestamp: Long | number;
+};
+export type SignalDataTypeMap = {
+    session: Uint8Array;
+    "pre-key": KeyPair;
+    "sender-key": Uint8Array;
+    "app-state-sync-key": AppDataSync;
+    "app-state-sync-version": LTHashState;
+    "sender-key-memory": {
+        [jid: string]: boolean;
+    };
+};
+export type SignalDataSet = {
+    [T in keyof SignalDataTypeMap]?: {
+        [id: string]: SignalDataTypeMap[T] | null;
+    };
+};
+export type KeyPair = {
+    public: Uint8Array;
+    private: Uint8Array;
+};
+export type sqlData = {
+    constructor: {
+        name: "RowDataPacket";
+    };
+    value?: object[];
+};
+export type valueReplacer = {
+    data: number[];
+    type: string;
+};
+export type valueReviver = {
+    data: string;
+    type: string;
+};
+export type AuthenticationState = {
+    creds: AuthenticationCreds;
+    keys: SignalKeyStore;
+};
+export type AuthenticationCreds = SignalCreds & {
+    readonly noiseKey: KeyPair;
+    readonly pairingEphemeralKeyPair: KeyPair;
+    advSecretKey: string;
+    me?: Contact;
+    account?: Account;
+    signalIdentities?: SignalIdentity[];
+    myAppStateKeyId?: string;
+    firstUnuploadedPreKeyId: number;
+    nextPreKeyId: number;
+    lastAccountSyncTimestamp?: number;
+    platform?: string;
+    processedHistoryMessages: Pick<any, "key" | "messageTimestamp">[];
+    accountSyncCounter: number;
+    accountSettings: AccountSettings;
+    deviceId: string;
+    phoneId: string;
+    identityId: Buffer;
+    registered: boolean;
+    backupToken: Buffer;
+    registration: RegistrationOptions;
+    pairingCode: string | undefined;
+    lastPropHash: string | undefined;
+    routingInfo: Buffer | undefined;
+};
+export {};