zaileys 4.7.0 → 4.7.2

package/dist/command/types.d.ts

@@ -0,0 +1,30 @@
+import type { WAMessageKey } from 'baileys';
+import type { MessageContext } from '../events/context.js';
+import type { TextOptions } from '../builder/builder.js';
+export type CommandPrefix = string | string[];
+export interface ParsedArgs {
+    matched: boolean;
+    name?: string;
+    args: string[];
+    flags: Record<string, string | boolean>;
+    json: unknown;
+    raw: string;
+}
+export interface CommandContext extends MessageContext {
+    raw: string;
+    command: string;
+    args: string[];
+    flags: Record<string, string | boolean>;
+    json: unknown;
+    reply(content: string, opts?: TextOptions): Promise<WAMessageKey>;
+    react(emoji: string): Promise<WAMessageKey>;
+    edit(content: string): Promise<void>;
+}
+export type CommandHandler = (ctx: CommandContext) => Promise<void> | void;
+export type Middleware = (ctx: CommandContext, next: () => Promise<void>) => Promise<void> | void;
+export interface CommandDefinition {
+    name: string;
+    aliases: string[];
+    parts: string[];
+    handler: CommandHandler;
+}

package/dist/connection/auth-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { SignalKeyStore } from 'baileys';
+import type { AuthStore } from '../auth/types.js';
+import type { Logger } from '../client/types.js';
+export declare function signalKeyStoreFromAuthStore(store: AuthStore, _logger?: Logger): SignalKeyStore;

package/dist/connection/auth-guard.d.ts

@@ -0,0 +1,37 @@
+import type { ConnectionAuthType } from '../client/types.js';
+/**
+ * Bounds QR and pairing-code regeneration across a client's lifetime to avoid
+ * tripping WhatsApp's spam/automation restriction. Each reconnect creates a fresh
+ * socket which re-emits a QR or requests a new pairing code; without a budget and
+ * cooldown this loops unbounded and gets the account restricted.
+ */
+export interface AuthGuardOptions {
+    /** Master switch. When `false` the guard never blocks (legacy behaviour). Default `true`. */
+    enabled?: boolean;
+    /** Total QR codes emitted before the guard stops and signals exhaustion. Default `5`. */
+    maxQrAttempts?: number;
+    /** Total pairing-code requests before the guard stops and signals exhaustion. Default `3`. */
+    maxPairingAttempts?: number;
+    /** Base cooldown between pairing-code requests; escalates per attempt. Default `60000`. */
+    pairingCooldownMs?: number;
+}
+export type AuthAttemptBlockReason = 'budget-exhausted' | 'cooldown';
+export interface AuthAttemptDecision {
+    allowed: boolean;
+    reason?: AuthAttemptBlockReason;
+    waitMs: number;
+    attempts: number;
+    max: number;
+}
+export interface AuthGuard {
+    /** Decide whether a new auth attempt of `kind` is permitted at time `now` (does not mutate). */
+    evaluate(kind: ConnectionAuthType, now: number): AuthAttemptDecision;
+    /** Record that an attempt of `kind` was actually issued at time `now`. */
+    record(kind: ConnectionAuthType, now: number): void;
+    /** Clear all counters and cooldowns (call on a successful connection or manual restart). */
+    reset(): void;
+    readonly enabled: boolean;
+    readonly qrAttempts: number;
+    readonly pairingAttempts: number;
+}
+export declare function createAuthGuard(options?: AuthGuardOptions): AuthGuard;

package/dist/connection/disconnect-reason.d.ts

@@ -0,0 +1,6 @@
+export type DisconnectReasonDomain = 'logged-out' | 'connection-replaced' | 'forbidden' | 'restart-required' | 'bad-session' | 'connection-closed' | 'connection-lost' | 'multi-device-mismatch' | 'unavailable-service' | 'rate-limited' | 'unknown';
+export declare function mapDisconnectReason(code: number | undefined): DisconnectReasonDomain;
+export declare function isFatalDisconnect(reason: DisconnectReasonDomain): boolean;
+export declare function isRateLimited(reason: DisconnectReasonDomain): boolean;
+export declare function shouldClearAuth(reason: DisconnectReasonDomain): boolean;
+export declare function shouldReconnect(reason: DisconnectReasonDomain): boolean;

package/dist/connection/index.d.ts

@@ -0,0 +1,7 @@
+export * from './auth-adapter.js';
+export * from './auth-guard.js';
+export * from './disconnect-reason.js';
+export * from './pairing-flow.js';
+export * from './qr-terminal.js';
+export * from './reconnect.js';
+export * from './state-machine.js';

package/dist/connection/pairing-flow.d.ts

@@ -0,0 +1,16 @@
+import type { BaileysSocket } from '../client/types.js';
+export interface PairingFlowOptions {
+    phoneNumber: string;
+    ttlMs?: number;
+}
+export interface PairingFlowResult {
+    code: string;
+    expiresAt: number;
+}
+export interface PairingFlow {
+    readonly phoneNumber: string;
+    requestCode(socket: Pick<BaileysSocket, 'requestPairingCode'>): Promise<PairingFlowResult>;
+}
+export declare function normalizePhoneNumber(raw: string): string;
+export declare function validateE164(raw: string): string;
+export declare function createPairingFlow(options: PairingFlowOptions): PairingFlow;

package/dist/connection/qr-terminal.d.ts

@@ -0,0 +1,2 @@
+export declare function renderQrInTerminal(qrString: string): Promise<string>;
+export declare function printQrToTerminal(qrString: string, write?: (s: string) => void): Promise<void>;

package/dist/connection/reconnect.d.ts

@@ -0,0 +1,15 @@
+import type { ReconnectOptions } from '../client/types.js';
+import { type DisconnectReasonDomain } from './disconnect-reason.js';
+export interface ReconnectDecision {
+    attempt: number;
+    delayMs: number;
+}
+export interface ReconnectStrategy {
+    next(reason: DisconnectReasonDomain): ReconnectDecision | null;
+    reset(): void;
+    readonly attempts: number;
+}
+export interface ReconnectStrategyDeps {
+    random?: () => number;
+}
+export declare function createReconnectStrategy(options?: ReconnectOptions, deps?: ReconnectStrategyDeps): ReconnectStrategy;

package/dist/connection/state-machine.d.ts

@@ -0,0 +1,9 @@
+import type { ConnectionState } from '../client/types.js';
+export type StateTransitionListener = (prev: ConnectionState, next: ConnectionState) => void;
+export interface ConnectionStateMachine {
+    readonly state: ConnectionState;
+    canTransition(next: ConnectionState): boolean;
+    transition(next: ConnectionState): void;
+    onChange(listener: StateTransitionListener): () => void;
+}
+export declare function createConnectionStateMachine(initial?: ConnectionState): ConnectionStateMachine;

package/dist/connection/status-log.d.ts

@@ -0,0 +1,25 @@
+import type { DisconnectReasonDomain } from './disconnect-reason.js';
+export type StatusEvent = {
+    kind: 'connecting';
+    sessionId: string;
+} | {
+    kind: 'qr';
+} | {
+    kind: 'pairing-code';
+    code: string;
+} | {
+    kind: 'connected';
+    id: string;
+} | {
+    kind: 'reconnecting';
+    attempt: number;
+    delayMs: number;
+    reason: DisconnectReasonDomain;
+    invalidCredsSuspected: boolean;
+} | {
+    kind: 'disconnect';
+    reason: DisconnectReasonDomain;
+    willReconnect: boolean;
+};
+export declare function formatConnectionStatus(event: StatusEvent): string | null;
+export declare function suppressLibsignalNoise(): void;

package/dist/domain/business.d.ts

@@ -0,0 +1,19 @@
+import type { DomainSocketLike } from './socket-like.js';
+export declare class BusinessModule {
+    private readonly getSocket;
+    constructor(getSocket: () => DomainSocketLike | undefined);
+    protected requireSocket(): DomainSocketLike;
+    profile(jid: string): Promise<unknown>;
+    catalog(opts?: {
+        jid?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    collections(jid?: string, limit?: number): Promise<unknown>;
+    orderDetails(orderId: string, tokenBase64: string): Promise<unknown>;
+    createProduct(create: Record<string, unknown>): Promise<unknown>;
+    updateProduct(productId: string, update: Record<string, unknown>): Promise<unknown>;
+    deleteProduct(...productIds: string[]): Promise<{
+        deleted: number;
+    }>;
+}

package/dist/domain/chat.d.ts

@@ -0,0 +1,27 @@
+import type { WAMessageKey } from 'baileys';
+import type { DomainSocketLike } from './socket-like.js';
+export type LastMessage = {
+    key: WAMessageKey;
+    messageTimestamp: number;
+};
+export type LastMessageResolver = (jid: string) => Promise<LastMessage[]>;
+export declare class ChatModule {
+    private readonly getSocket;
+    private readonly resolveLast?;
+    constructor(getSocket: () => DomainSocketLike | undefined, resolveLast?: LastMessageResolver | undefined);
+    protected requireSocket(): DomainSocketLike;
+    private last;
+    archive(jid: string): Promise<void>;
+    unarchive(jid: string): Promise<void>;
+    pin(jid: string): Promise<void>;
+    unpin(jid: string): Promise<void>;
+    /** Mute for `durationMs` (e.g. 8h = 28_800_000). Omit to mute indefinitely. */
+    mute(jid: string, durationMs?: number): Promise<void>;
+    unmute(jid: string): Promise<void>;
+    markRead(jid: string): Promise<void>;
+    markUnread(jid: string): Promise<void>;
+    star(key: WAMessageKey, starred?: boolean): Promise<void>;
+    unstar(key: WAMessageKey): Promise<void>;
+    delete(jid: string): Promise<void>;
+    clear(jid: string): Promise<void>;
+}

package/dist/domain/community.d.ts

@@ -0,0 +1,28 @@
+import type { OperationGuard } from '../automation/operation-guard.js';
+import type { DomainSocketLike } from './socket-like.js';
+import type { GroupMetadata, LinkedGroup } from './types.js';
+export declare class CommunityModule {
+    private readonly getSocket;
+    private readonly guard?;
+    constructor(getSocket: () => DomainSocketLike | undefined, guard?: OperationGuard | undefined);
+    protected requireSocket(): DomainSocketLike;
+    private run;
+    create(subject: string, body: string): Promise<GroupMetadata>;
+    createGroup(subject: string, participants: string[], communityId: string): Promise<GroupMetadata>;
+    linkGroup(communityId: string, groupId: string): Promise<void>;
+    unlinkGroup(communityId: string, groupId: string): Promise<void>;
+    subGroups(communityId: string): Promise<LinkedGroup[]>;
+    leave(communityId: string): Promise<void>;
+    updateSubject(communityId: string, subject: string): Promise<void>;
+    updateDescription(communityId: string, description?: string): Promise<void>;
+    inviteCode(communityId: string): Promise<string | undefined>;
+    revokeInvite(communityId: string): Promise<string | undefined>;
+    acceptInvite(code: string): Promise<string | undefined>;
+    metadata(communityId: string): Promise<GroupMetadata>;
+    list(): Promise<GroupMetadata[]>;
+    inviteInfo(code: string): Promise<GroupMetadata>;
+    toggleEphemeral(communityId: string, seconds: number): Promise<void>;
+    setting(communityId: string, setting: 'announcement' | 'not_announcement'): Promise<void>;
+    memberAddMode(communityId: string, adminsOnly: boolean): Promise<void>;
+    joinApproval(communityId: string, enabled: boolean): Promise<void>;
+}

package/dist/domain/contact.d.ts

@@ -0,0 +1,21 @@
+import type { DomainSocketLike } from './socket-like.js';
+export type ContactCheckResult = {
+    jid: string;
+    exists: boolean;
+    lid?: string;
+};
+export declare class ContactModule {
+    private readonly getSocket;
+    private readonly normalize;
+    constructor(getSocket: () => DomainSocketLike | undefined, normalize: (input: string) => string);
+    protected requireSocket(): DomainSocketLike;
+    /** Check whether phone numbers are on WhatsApp; returns the resolved jid + existence per input. */
+    check(...numbers: string[]): Promise<ContactCheckResult[]>;
+    exists(number: string): Promise<boolean>;
+    save(jid: string, name: {
+        firstName?: string;
+        lastName?: string;
+        fullName?: string;
+    }): Promise<void>;
+    remove(jid: string): Promise<void>;
+}

package/dist/domain/errors.d.ts

@@ -0,0 +1,8 @@
+export type DomainErrorCode = 'NOT_CONNECTED' | 'GROUP_NOT_FOUND' | 'NEWSLETTER_NOT_FOUND' | 'INVALID_PARTICIPANT' | 'OPERATION_FAILED';
+export declare class ZaileysDomainError extends Error {
+    readonly code: DomainErrorCode;
+    readonly cause?: unknown;
+    constructor(code: DomainErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}

package/dist/domain/group.d.ts

@@ -0,0 +1,35 @@
+import type { OperationGuard } from '../automation/operation-guard.js';
+import type { DomainSocketLike } from './socket-like.js';
+import type { GroupMetadata, ParticipantUpdateResult } from './types.js';
+export declare class GroupModule {
+    private readonly getSocket;
+    private readonly guard?;
+    constructor(getSocket: () => DomainSocketLike | undefined, guard?: OperationGuard | undefined);
+    protected requireSocket(): DomainSocketLike;
+    private mapParticipants;
+    private run;
+    create(subject: string, participants: string[]): Promise<GroupMetadata>;
+    addMember(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    removeMember(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    promote(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    demote(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    updateSubject(groupId: string, subject: string): Promise<void>;
+    updateDescription(groupId: string, description?: string): Promise<void>;
+    leave(groupId: string): Promise<void>;
+    metadata(groupId: string): Promise<GroupMetadata>;
+    tagMember(groupId: string, jid: string, label: string): Promise<void>;
+    inviteCode(groupId: string): Promise<string>;
+    revokeInvite(groupId: string): Promise<string>;
+    acceptInvite(code: string): Promise<string>;
+    toggleEphemeral(groupId: string, seconds: number): Promise<void>;
+    setting(groupId: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked'): Promise<void>;
+    list(): Promise<GroupMetadata[]>;
+    inviteInfo(code: string): Promise<GroupMetadata>;
+    joinRequests(groupId: string): Promise<Array<{
+        [k: string]: string;
+    }>>;
+    approveJoin(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    rejectJoin(groupId: string, jids: string[]): Promise<ParticipantUpdateResult[]>;
+    joinApproval(groupId: string, enabled: boolean): Promise<void>;
+    memberAddMode(groupId: string, adminsOnly: boolean): Promise<void>;
+}

package/dist/domain/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types.js';
+export * from './errors.js';
+export { GroupModule } from './group.js';
+export { PrivacyModule } from './privacy.js';
+export { NewsletterModule } from './newsletter.js';
+export { CommunityModule } from './community.js';
+export { ProfileModule } from './profile.js';
+export { ChatModule } from './chat.js';
+export { ContactModule } from './contact.js';
+export { BusinessModule } from './business.js';
+export type { DomainSocketLike } from './socket-like.js';

package/dist/domain/newsletter.d.ts

@@ -0,0 +1,35 @@
+import type { OperationGuard } from '../automation/operation-guard.js';
+import type { DomainSocketLike } from './socket-like.js';
+import type { NewsletterMetadata } from './types.js';
+export declare class NewsletterModule {
+    private readonly getSocket;
+    private readonly guard?;
+    constructor(getSocket: () => DomainSocketLike | undefined, guard?: OperationGuard | undefined);
+    protected requireSocket(): DomainSocketLike;
+    private run;
+    create(name: string, opts?: {
+        description?: string;
+        picture?: Buffer;
+    }): Promise<NewsletterMetadata>;
+    follow(jid: string): Promise<void>;
+    unfollow(jid: string): Promise<void>;
+    metadata(jid: string): Promise<NewsletterMetadata>;
+    updateName(jid: string, name: string): Promise<void>;
+    updateDescription(jid: string, description: string): Promise<void>;
+    updatePicture(jid: string, picture: Buffer): Promise<void>;
+    mute(jid: string): Promise<void>;
+    unmute(jid: string): Promise<void>;
+    delete(jid: string): Promise<void>;
+    removePicture(jid: string): Promise<void>;
+    react(jid: string, serverId: string, emoji: string): Promise<void>;
+    /** Remove a reaction from a newsletter message. */
+    unreact(jid: string, serverId: string): Promise<void>;
+    subscribers(jid: string): Promise<unknown>;
+    messages(jid: string, count?: number, opts?: {
+        since?: number;
+        after?: number;
+    }): Promise<unknown>;
+    adminCount(jid: string): Promise<number>;
+    changeOwner(jid: string, newOwnerJid: string): Promise<void>;
+    demote(jid: string, userJid: string): Promise<void>;
+}

package/dist/domain/privacy.d.ts

@@ -0,0 +1,15 @@
+import type { DomainSocketLike } from './socket-like.js';
+import type { PrivacyConfig, PrivacySettings, WAReadReceiptsValue } from './types.js';
+export declare class PrivacyModule {
+    private readonly getSocket;
+    constructor(getSocket: () => DomainSocketLike | undefined);
+    protected requireSocket(): DomainSocketLike;
+    set(config: PrivacyConfig & {
+        readReceipts?: WAReadReceiptsValue | boolean;
+    }): Promise<void>;
+    get(): Promise<PrivacySettings>;
+    block(jid: string): Promise<void>;
+    unblock(jid: string): Promise<void>;
+    blocklist(): Promise<string[]>;
+    disappearingMode(seconds: number): Promise<void>;
+}

package/dist/domain/profile.d.ts

@@ -0,0 +1,14 @@
+import type { WAMediaUpload } from 'baileys';
+import type { DomainSocketLike } from './socket-like.js';
+export declare class ProfileModule {
+    private readonly getSocket;
+    constructor(getSocket: () => DomainSocketLike | undefined);
+    protected requireSocket(): DomainSocketLike;
+    setName(name: string): Promise<void>;
+    setStatus(status: string): Promise<void>;
+    /** Set the profile/group picture. `jid` defaults to self; pass a group jid to set a group avatar. */
+    setPicture(jid: string, image: WAMediaUpload): Promise<void>;
+    removePicture(jid: string): Promise<void>;
+    getPicture(jid: string, hd?: boolean): Promise<string | null>;
+    getStatus(jid: string): Promise<unknown>;
+}

package/dist/domain/socket-like.d.ts

@@ -0,0 +1,117 @@
+import type { ChatModification, GroupMetadata, NewsletterMetadata, ParticipantAction, WAMediaUpload, WAPrivacyGroupAddValue, WAPrivacyOnlineValue, WAPrivacyValue, WAReadReceiptsValue } from 'baileys';
+import type { LinkedGroup } from './types.js';
+export interface DomainSocketLike {
+    groupCreate(subject: string, participants: string[]): Promise<GroupMetadata>;
+    groupParticipantsUpdate(jid: string, participants: string[], action: ParticipantAction): Promise<{
+        status: string;
+        jid: string;
+        content?: unknown;
+    }[]>;
+    groupUpdateSubject(jid: string, subject: string): Promise<void>;
+    groupUpdateDescription(jid: string, description?: string): Promise<void>;
+    groupLeave(id: string): Promise<void>;
+    groupMetadata(jid: string): Promise<GroupMetadata>;
+    groupInviteCode(jid: string): Promise<string | undefined>;
+    groupRevokeInvite(jid: string): Promise<string | undefined>;
+    groupAcceptInvite(code: string): Promise<string | undefined>;
+    groupToggleEphemeral(jid: string, ephemeralExpiration: number): Promise<void>;
+    groupSettingUpdate(jid: string, setting: 'announcement' | 'not_announcement' | 'locked' | 'unlocked'): Promise<void>;
+    updateMemberLabel(jid: string, memberLabel: string): Promise<unknown>;
+    groupFetchAllParticipating(): Promise<{
+        [jid: string]: GroupMetadata;
+    }>;
+    groupGetInviteInfo(code: string): Promise<GroupMetadata>;
+    groupRequestParticipantsList(jid: string): Promise<Array<{
+        [k: string]: string;
+    }>>;
+    groupRequestParticipantsUpdate(jid: string, participants: string[], action: 'approve' | 'reject'): Promise<{
+        status: string;
+        jid: string;
+    }[]>;
+    groupJoinApprovalMode(jid: string, mode: 'on' | 'off'): Promise<void>;
+    groupMemberAddMode(jid: string, mode: 'admin_add' | 'all_member_add'): Promise<void>;
+    onWhatsApp(...jids: string[]): Promise<Array<{
+        jid: string;
+        exists: boolean;
+        lid?: string;
+    }> | undefined>;
+    addOrEditContact(jid: string, contact: {
+        firstName?: string;
+        lastName?: string;
+        fullName?: string;
+    }): Promise<unknown>;
+    removeContact(jid: string): Promise<unknown>;
+    getBusinessProfile(jid: string): Promise<unknown>;
+    getCatalog(opts: {
+        jid?: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+    getCollections(jid?: string, limit?: number): Promise<unknown>;
+    getOrderDetails(orderId: string, tokenBase64: string): Promise<unknown>;
+    productCreate(create: Record<string, unknown>): Promise<unknown>;
+    productUpdate(productId: string, update: Record<string, unknown>): Promise<unknown>;
+    productDelete(productIds: string[]): Promise<{
+        deleted: number;
+    }>;
+    updateLastSeenPrivacy(value: WAPrivacyValue): Promise<void>;
+    updateOnlinePrivacy(value: WAPrivacyOnlineValue): Promise<void>;
+    updateProfilePicturePrivacy(value: WAPrivacyValue): Promise<void>;
+    updateStatusPrivacy(value: WAPrivacyValue): Promise<void>;
+    updateReadReceiptsPrivacy(value: WAReadReceiptsValue): Promise<void>;
+    updateGroupsAddPrivacy(value: WAPrivacyGroupAddValue): Promise<void>;
+    updateDefaultDisappearingMode(duration: number): Promise<void>;
+    fetchPrivacySettings(force?: boolean): Promise<{
+        [_: string]: string;
+    }>;
+    updateBlockStatus(jid: string, action: 'block' | 'unblock'): Promise<void>;
+    fetchBlocklist(): Promise<string[]>;
+    updateProfileName(name: string): Promise<void>;
+    updateProfileStatus(status: string): Promise<void>;
+    updateProfilePicture(jid: string, content: WAMediaUpload): Promise<void>;
+    removeProfilePicture(jid: string): Promise<void>;
+    profilePictureUrl(jid: string, type?: 'image' | 'preview', timeoutMs?: number): Promise<string | undefined>;
+    fetchStatus(jid: string): Promise<unknown>;
+    chatModify(mod: ChatModification, jid: string): Promise<void>;
+    newsletterCreate(name: string, description?: string): Promise<NewsletterMetadata>;
+    newsletterFollow(jid: string): Promise<unknown>;
+    newsletterUnfollow(jid: string): Promise<unknown>;
+    newsletterMetadata(type: 'invite' | 'jid', key: string): Promise<NewsletterMetadata | null>;
+    newsletterUpdateName(jid: string, name: string): Promise<unknown>;
+    newsletterUpdateDescription(jid: string, description: string): Promise<unknown>;
+    newsletterUpdatePicture(jid: string, content: WAMediaUpload): Promise<unknown>;
+    newsletterMute(jid: string): Promise<unknown>;
+    newsletterUnmute(jid: string): Promise<unknown>;
+    newsletterDelete(jid: string): Promise<void>;
+    newsletterSubscribers(jid: string): Promise<unknown>;
+    newsletterRemovePicture(jid: string): Promise<unknown>;
+    newsletterReactMessage(jid: string, serverId: string, reaction?: string): Promise<void>;
+    newsletterFetchMessages(jid: string, count: number, since?: number, after?: number): Promise<unknown>;
+    newsletterAdminCount(jid: string): Promise<number>;
+    newsletterChangeOwner(jid: string, newOwnerJid: string): Promise<void>;
+    newsletterDemote(jid: string, userJid: string): Promise<void>;
+    communityCreate(subject: string, body: string): Promise<GroupMetadata>;
+    communityCreateGroup(subject: string, participants: string[], parentCommunityJid: string): Promise<GroupMetadata>;
+    communityLinkGroup(groupJid: string, parentCommunityJid: string): Promise<void>;
+    communityUnlinkGroup(groupJid: string, parentCommunityJid: string): Promise<void>;
+    communityFetchLinkedGroups(jid: string): Promise<{
+        communityJid: string;
+        isCommunity: boolean;
+        linkedGroups: LinkedGroup[];
+    }>;
+    communityLeave(id: string): Promise<void>;
+    communityUpdateSubject(jid: string, subject: string): Promise<void>;
+    communityUpdateDescription(jid: string, description?: string): Promise<void>;
+    communityInviteCode(jid: string): Promise<string | undefined>;
+    communityRevokeInvite(jid: string): Promise<string | undefined>;
+    communityAcceptInvite(code: string): Promise<string | undefined>;
+    communityMetadata(jid: string): Promise<GroupMetadata>;
+    communityFetchAllParticipating(): Promise<{
+        [jid: string]: GroupMetadata;
+    }>;
+    communityGetInviteInfo(code: string): Promise<GroupMetadata>;
+    communityToggleEphemeral(jid: string, ephemeralExpiration: number): Promise<void>;
+    communitySettingUpdate(jid: string, setting: 'announcement' | 'not_announcement'): Promise<void>;
+    communityMemberAddMode(jid: string, mode: 'admin_add' | 'all_member_add'): Promise<void>;
+    communityJoinApprovalMode(jid: string, mode: 'on' | 'off'): Promise<void>;
+}

package/dist/domain/types.d.ts

@@ -0,0 +1,24 @@
+export type { GroupMetadata, GroupParticipant, ParticipantAction, WAPrivacyValue, WAPrivacyOnlineValue, WAReadReceiptsValue, WAPrivacyGroupAddValue, NewsletterMetadata, WAMediaUpload, } from 'baileys';
+import type { WAPrivacyValue, WAPrivacyOnlineValue, WAReadReceiptsValue, WAPrivacyGroupAddValue } from 'baileys';
+export interface ParticipantUpdateResult {
+    jid: string;
+    status: string;
+}
+export interface PrivacyConfig {
+    lastSeen?: WAPrivacyValue;
+    online?: WAPrivacyOnlineValue;
+    profile?: WAPrivacyValue;
+    status?: WAPrivacyValue;
+    readReceipts?: WAReadReceiptsValue;
+    groupAdd?: WAPrivacyGroupAddValue;
+}
+export type PrivacySettings = {
+    [key: string]: string;
+};
+export interface LinkedGroup {
+    id?: string;
+    subject: string;
+    creation?: number;
+    owner?: string;
+    size?: number;
+}