@whanext/core 0.19.15 → 0.19.18

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # Changelog
 
+## 0.19.18
+
+### Stability
+- Added bounded command queues for `strategy: 'queue'`: `maxQueue` defaults to 10 waiting executions and `queueTimeoutMs` defaults to 60 seconds. Set either option to `0` to disable that limit.
+- Added `COMMAND_QUEUE_FULL` and `COMMAND_QUEUE_TIMEOUT` with typed `commandQueueFull` and `commandQueueTimeout` application events.
+- Added explicit Zapo transport/query timeouts through `providerTimeouts.connectTimeoutMs` and `providerTimeouts.nodeQueryTimeoutMs`, defaulting to 15 seconds and 30 seconds.
+- Stability event listeners are isolated from provider recovery work so consumer handler failures cannot turn a successful metadata recovery into a provider failure.
+
+### Health
+- Expanded `app.health()` without removing the existing fields. It now exposes `stability`, connection/reconnect state, messaging counters, crypto degradation counters, group metadata recovery counters, command queue metrics, and effective provider timeouts.
+- Added `healthy`, `degraded`, `reconnecting`, and `offline` operational stability states. Transient crypto/group warnings move the provider to `degraded` for a bounded window and automatically return it to `healthy`.
+- Added typed `healthChanged`, `connectionRecovered`, `groupMetadataRecovered`, and `cryptoDegraded` events.
+
+### Performance
+- Added `@zapo-js/native@0.1.0` as an optional dependency. Zapo automatically uses its X25519/XEdDSA accelerator when available and falls back to JavaScript when unavailable.
+- Health reports the detected crypto backend as `napi`, `wasm`, `js`, or `unknown`; the published optional package is detected as WASM on supported Node runtimes while locally built N-API addons are reported only when they can actually be loaded.
+
+### Compatibility
+- Existing command concurrency declarations remain valid; the queue limits only affect commands that already use `strategy: 'queue'`.
+- Custom providers are not required to implement `health()`; WhaNext supplies neutral health fallbacks when a provider does not expose runtime metrics.
+
+## 0.19.17
+
+### Reliability
+- Group sends now self-heal when Zapo reports an acknowledged participant-hash mismatch: WhaNext invalidates only the affected group's metadata cache, fetches fresh server metadata, invalidates the public group snapshot, and rate-limits recovery to once per group per minute.
+- Volatile Zapo `groupMetadata` and `deviceList` memory caches now expire after 3 minutes instead of the 5-minute default, reducing stale LID/device fan-out windows without disabling caching or forcing an IQ/usync on every send.
+- Transient WhatsApp disconnects now retry indefinitely by default with the existing exponential backoff; applications that set `reconnect.maxAttempts` keep their explicit limit. Fatal/logout reasons still stop reconnection immediately.
+
+### Performance
+- The shared Zapo SQLite store now uses `WAL`, `synchronous=NORMAL`, and a 5-second `busy_timeout`, improving concurrent reads/writes for persisted Signal, sender-key, mailbox, and app-state data.
+- The WhaNext mutation-snapshot SQLite database now uses the same WAL/NORMAL settings, reducing fsync contention on active bots.
+
+### Safety
+- Sender keys and Signal sessions are never globally reset during mismatch recovery. Zapo's normal retry-receipt/decryption recovery remains authoritative; WhaNext only refreshes stale group metadata.
+
+## 0.19.16
+
+### Fixed
+- Remote media URLs are now streamed into Zapo instead of being fully materialized as `Uint8Array` in memory before upload. This removes the extra whole-file buffering step that could stall or intermittently fail larger MP3/audio sends.
+- Remote media fetches now have a bounded 120-second transfer timeout and surface provider errors when the source cannot be opened or returns an empty body.
+- Local paths and caller-provided byte arrays keep their existing behavior.
+
+### Performance
+- URL-backed audio/video/image uploads now follow Zapo's recommended streaming media path, keeping memory usage flat while Zapo stages, hashes, encrypts, and uploads the attachment.
+
 ## 0.19.15
 
 ### Added

package/README.md

@@ -311,20 +311,27 @@ const app = await create({
 
 ## Health checks
 
-`app.health()` entrega um snapshot sem consultar o WhatsApp novamente:
+`app.health()` entrega um snapshot local e barato, sem consultar o WhatsApp novamente. Os campos antigos permanecem disponíveis e a camada de estabilidade acrescenta conexão, mensagens, crypto, grupos, filas e timeouts:
 
 ```ts
 const health = app.health();
 
 console.log(health.status);
+console.log(health.stability);
 console.log(health.ready);
 console.log(health.state);
 console.log(health.uptimeMs);
-console.log(health.muteEnabled);
-console.log(health.logLevel);
+console.log(health.connection);
+console.log(health.messaging);
+console.log(health.crypto);
+console.log(health.groups);
+console.log(health.commands);
+console.log(health.timeouts);
 ```
 
-Estados possíveis: `idle`, `starting`, `ready` e `stopped`.
+`status` continua representando o ciclo da aplicação: `idle`, `starting`, `ready` ou `stopped`. `stability` representa a saúde operacional do provider: `healthy`, `degraded`, `reconnecting` ou `offline`.
+
+O provider Zapo contabiliza reconexões, mensagens enviadas/recebidas, falhas de envio, falhas de descriptografia, `sender key id mismatch`, falhas de addons, divergências de `phash` e recuperações de metadata. O router contabiliza execuções ativas, fila atual, expirações e rejeições por fila cheia.
 
 ```ts
 server.get('/health', async () => app.health());
@@ -333,11 +340,67 @@ server.get('/health', async () => app.health());
 Para uma verificação simples:
 
 ```ts
-if (app.isReady) {
-  console.log('Aplicação pronta.');
+if (app.isReady && app.health().stability === 'healthy') {
+  console.log('Aplicação pronta e saudável.');
 }
 ```
 
+## Estabilidade do provider
+
+O provider oficial usa timeouts explícitos para conexão e queries de protocolo. Os padrões são 15 segundos para conexão e 30 segundos para queries; ambos podem ser ajustados na criação da aplicação:
+
+```ts
+const app = await create({
+  providerTimeouts: {
+    connectTimeoutMs: 15_000,
+    nodeQueryTimeoutMs: 30_000,
+  },
+});
+```
+
+Valores menores que 1 segundo são normalizados para 1 segundo. Os valores efetivos ficam disponíveis em `app.health().timeouts`.
+
+A aceleração crypto do Zapo também é integrada de forma opcional. `@zapo-js/native` acelera X25519 e XEdDSA e o provider continua funcionando com o backend JavaScript caso o acelerador não esteja disponível. O pacote publicado usa WASM; um build N-API local também é detectado quando realmente carregável.
+
+```ts
+const health = app.health();
+
+console.log(health.crypto.backend);
+console.log(health.crypto.acceleration);
+```
+
+Backends reportados: `napi`, `wasm`, `js` ou `unknown`. Para forçar o fallback JavaScript, inicie o processo com `ZAPO_NATIVE_BACKEND=js`.
+
+A aplicação expõe eventos tipados para observabilidade sem parsing de logs:
+
+```ts
+app.on('healthChanged', ({ previous, current }) => {
+  console.log(previous, current);
+});
+
+app.on('connectionRecovered', ({ recoveredAt, reconnects }) => {
+  console.log(recoveredAt, reconnects);
+});
+
+app.on('groupMetadataRecovered', ({ groupId }) => {
+  console.log(groupId);
+});
+
+app.on('cryptoDegraded', ({ kind, chatId }) => {
+  console.log(kind, chatId);
+});
+
+app.on('commandQueueTimeout', ({ command, queuedForMs }) => {
+  console.log(command, queuedForMs);
+});
+
+app.on('commandQueueFull', ({ command, queued }) => {
+  console.log(command, queued);
+});
+```
+
+Falhas criptográficas transitórias deixam o provider em `degraded` por uma janela curta; a volta para `healthy` também dispara `healthChanged`. A recuperação de metadata por `phash` continua específica ao grupo afetado e não apaga Sender Keys nem sessões Signal.
+
 ## Usuários
 
 Toda mensagem possui `message.sender: User`. Menções ficam em `message.mentionedUsers`, e o remetente de um reply em `message.quoted?.sender`.
@@ -537,6 +600,8 @@ const downloaded = await app.media.download(message);
 await writeFile(`./downloads/${downloaded.fileName ?? message.id}`, downloaded.data);
 ```
 
+Ao enviar `{ url }`, o provider abre a origem remota como stream e entrega o fluxo ao pipeline de mídia do Zapo; o arquivo não é carregado inteiro na memória antes do upload. Para arquivos locais, `{ path }` continua sendo a opção mais direta.
+
 `download()` aceita a `Message` recebida, uma `QuotedMessage` ou uma `MessageKey` e devolve o buffer junto dos metadados normalizados. A mídia deve ser baixada enquanto a mensagem ainda está no cache da instância; o provider tenta renovar a URL de mídia automaticamente quando necessário.
 
 Para visualização única citada, o provider oficial preserva os metadados do envelope sem expor tipos do Zapo:
@@ -695,6 +760,8 @@ app.commands.command(
       scope: 'chat',
       max: 1,
       strategy: 'queue',
+      maxQueue: 10,
+      queueTimeoutMs: 60_000,
     },
 
     async execute(ctx) {
@@ -713,6 +780,21 @@ app.commands.command(
 );
 ```
 
+Para `strategy: 'queue'`, o WhaNext limita por padrão a fila a 10 execuções aguardando e cada entrada pode esperar até 60 segundos. `maxQueue: 0` remove o limite de quantidade e `queueTimeoutMs: 0` remove o timeout. Quando os limites são atingidos, o router usa `COMMAND_QUEUE_FULL` ou `COMMAND_QUEUE_TIMEOUT` e emite os eventos tipados correspondentes.
+
+```ts
+app.commands.onError(async (ctx, error) => {
+  if (error.code === 'COMMAND_QUEUE_FULL') {
+    await ctx.reply('Muitos comandos estão aguardando. Tente novamente em instantes.');
+    return;
+  }
+
+  if (error.code === 'COMMAND_QUEUE_TIMEOUT') {
+    await ctx.reply('A fila demorou demais. Envie o comando novamente.');
+  }
+});
+```
+
 ### Comandos exclusivos do dono
 
 O dono é a própria conta conectada naquela aplicação. Não é necessário salvar número, JID ou LID manualmente. O provider usa a marca de mensagem enviada pela própria conta e, quando necessário, compara as identidades normalizadas da sessão.

package/dist/index.d.ts

@@ -289,6 +289,8 @@ interface CallEvent {
 }
 
 type ConnectionState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'closed';
+type StabilityHealthStatus = 'healthy' | 'degraded' | 'reconnecting' | 'offline';
+type CryptoAccelerationBackend = 'napi' | 'wasm' | 'js' | 'unknown';
 type PresenceState = 'typing' | 'recording' | 'paused';
 type ParticipantAction = 'remove' | 'promote' | 'demote';
 interface ParticipantUpdateResult {
@@ -301,6 +303,69 @@ interface ConnectionUpdate {
     attempt?: number;
     error?: Error;
 }
+interface ProviderConnectionHealth {
+    state: ConnectionState;
+    uptimeMs: number;
+    reconnects: number;
+    reconnectAttempt: number;
+    lastConnectedAt?: Date;
+    lastDisconnectedAt?: Date;
+}
+interface ProviderMessagingHealth {
+    sent: number;
+    received: number;
+    failed: number;
+    lastIncomingAt?: Date;
+    lastOutgoingAt?: Date;
+}
+interface ProviderCryptoHealth {
+    backend: CryptoAccelerationBackend;
+    acceleration: boolean;
+    decryptFailures: number;
+    addonDecryptFailures: number;
+    senderKeyMismatches: number;
+}
+interface ProviderGroupHealth {
+    phashMismatches: number;
+    metadataRecoveries: number;
+    metadataRecoveryFailures: number;
+}
+interface ProviderTimeoutHealth {
+    connectTimeoutMs: number;
+    nodeQueryTimeoutMs: number;
+}
+interface ProviderHealth {
+    stability: StabilityHealthStatus;
+    connection: ProviderConnectionHealth;
+    messaging: ProviderMessagingHealth;
+    crypto: ProviderCryptoHealth;
+    groups: ProviderGroupHealth;
+    timeouts: ProviderTimeoutHealth;
+}
+interface GroupMetadataRecoveredEvent {
+    groupId: string;
+    recoveredAt: Date;
+}
+type CryptoDegradationKind = 'decrypt_failure' | 'addon_decrypt_failure' | 'sender_key_mismatch';
+interface CryptoDegradedEvent {
+    kind: CryptoDegradationKind;
+    occurredAt: Date;
+    messageId?: string;
+    chatId?: string;
+    participantId?: string;
+}
+type ProviderStabilityEvent = {
+    type: 'groupMetadataRecovered';
+    payload: GroupMetadataRecoveredEvent;
+} | {
+    type: 'cryptoDegraded';
+    payload: CryptoDegradedEvent;
+} | {
+    type: 'healthRefresh';
+    payload: {
+        occurredAt: Date;
+    };
+};
 interface ProviderEvents {
     message: Message;
     messageDeleted: MessageDeleted;
@@ -311,6 +376,7 @@ interface ProviderEvents {
     };
     groupParticipantsChanged: GroupParticipantsChanged;
     call: CallEvent;
+    stability: ProviderStabilityEvent;
 }
 type Unsubscribe = () => void;
 interface WhatsAppProvider {
@@ -319,6 +385,7 @@ interface WhatsAppProvider {
     getCurrentUserIds(): string[];
     requestPairingCode(phone: string): Promise<string>;
     on<Event extends keyof ProviderEvents>(event: Event, listener: (payload: ProviderEvents[Event]) => void | Promise<void>): Unsubscribe;
+    health?(): ProviderHealth;
     sendMessage(chatId: string, content: MessageContent, replyTo?: MessageKey): Promise<SentMessage>;
     repostMessage(source: MessageKey, chatId: string, options?: RepostMessageOptions): Promise<SentMessage>;
     reactToMessage(key: MessageKey, emoji?: string): Promise<SentMessage>;
@@ -616,7 +683,7 @@ declare class DeferredReply {
     delete(): Promise<void>;
 }
 
-type WhaNextErrorCode = 'AUTH_INVALID_PHONE' | 'AUTH_EXPIRED' | 'AUTH_PASSKEY_REQUIRED' | 'CONNECTION_CLOSED' | 'CONNECTION_FAILED' | 'GROUP_NOT_FOUND' | 'MEMBER_NOT_FOUND' | 'BOT_NOT_ADMIN' | 'MESSAGE_NOT_FOUND' | 'MEDIA_NOT_AVAILABLE' | 'MESSAGE_REACHOUT_LOCKED' | 'MUTE_DISABLED' | 'STORAGE_ERROR' | 'ARGUMENT_MISSING' | 'ARGUMENT_INVALID' | 'COMMAND_NOT_ALLOWED' | 'COMMAND_COOLDOWN' | 'COMMAND_BUSY' | 'COMMAND_LOAD_FAILED' | 'PROVIDER_ERROR' | 'UNKNOWN_ERROR';
+type WhaNextErrorCode = 'AUTH_INVALID_PHONE' | 'AUTH_EXPIRED' | 'AUTH_PASSKEY_REQUIRED' | 'CONNECTION_CLOSED' | 'CONNECTION_FAILED' | 'GROUP_NOT_FOUND' | 'MEMBER_NOT_FOUND' | 'BOT_NOT_ADMIN' | 'MESSAGE_NOT_FOUND' | 'MEDIA_NOT_AVAILABLE' | 'MESSAGE_REACHOUT_LOCKED' | 'MUTE_DISABLED' | 'STORAGE_ERROR' | 'ARGUMENT_MISSING' | 'ARGUMENT_INVALID' | 'COMMAND_NOT_ALLOWED' | 'COMMAND_COOLDOWN' | 'COMMAND_BUSY' | 'COMMAND_QUEUE_FULL' | 'COMMAND_QUEUE_TIMEOUT' | 'COMMAND_LOAD_FAILED' | 'PROVIDER_ERROR' | 'UNKNOWN_ERROR';
 interface WhaNextErrorOptions {
     cause?: unknown;
     context?: Readonly<Record<string, unknown>>;
@@ -646,8 +713,8 @@ declare const guards: {
     custom(guard: CommandGuard): CommandGuard;
 };
 
-type CommandScope = "global" | "user" | "chat" | "user-chat" | "user-group";
-type ConcurrencyStrategy = "parallel" | "reject" | "queue" | "replace";
+type CommandScope = 'global' | 'user' | 'chat' | 'user-chat' | 'user-group';
+type ConcurrencyStrategy = 'parallel' | 'reject' | 'queue' | 'replace';
 interface CommandCooldown {
     durationMs: number;
     scope?: CommandScope;
@@ -656,6 +723,8 @@ interface CommandConcurrency {
     max?: number;
     scope?: CommandScope;
     strategy?: ConcurrencyStrategy;
+    maxQueue?: number;
+    queueTimeoutMs?: number;
 }
 interface CommandLocalization {
     name?: string;
@@ -710,6 +779,37 @@ declare function defineCommandGroup<const Group extends CommandGroupDefinition>(
 declare function defineCommands<const Commands extends readonly CommandDefinition[]>(...commands: Commands): Commands;
 declare function isCommandGroup(definition: CommandDefinition): definition is CommandGroupDefinition;
 
+interface CommandConcurrencyContext {
+    command: string;
+    messageId: string;
+    chatId: string;
+    userId: string;
+}
+interface CommandQueueTimeoutEvent extends CommandConcurrencyContext {
+    key: string;
+    queuedForMs: number;
+    queueTimeoutMs: number;
+    queued: number;
+}
+interface CommandQueueFullEvent extends CommandConcurrencyContext {
+    key: string;
+    maxQueue: number;
+    queued: number;
+}
+interface CommandConcurrencyHealth {
+    running: number;
+    queued: number;
+    queueTimeouts: number;
+    queueRejected: number;
+}
+type CommandConcurrencyEvent = {
+    type: 'commandQueueTimeout';
+    payload: CommandQueueTimeoutEvent;
+} | {
+    type: 'commandQueueFull';
+    payload: CommandQueueFullEvent;
+};
+
 interface CommandRegistrar {
     command(definition: CommandDefinition): unknown;
 }
@@ -743,6 +843,10 @@ interface CommandHelpOptions extends CommandCatalogOptions {
     title?: string;
 }
 type CommandErrorHandler = (context: CommandContext, error: WhaNextError) => void | Promise<void>;
+interface CommandRouterEvents {
+    commandQueueTimeout: CommandQueueTimeoutEvent;
+    commandQueueFull: CommandQueueFullEvent;
+}
 declare class CommandRouter {
     #private;
     constructor(services: CommandRuntimeServices, options?: RouterOptions);
@@ -751,6 +855,8 @@ declare class CommandRouter {
     get prefixes(): readonly string[];
     setPrefixes(prefixes: string | readonly string[]): this;
     get size(): number;
+    health(): CommandConcurrencyHealth;
+    on<Event extends keyof CommandRouterEvents>(event: Event, listener: (payload: CommandRouterEvents[Event]) => void | Promise<void>): () => void;
     command(definition: CommandDefinition): this;
     load(dirPath: string | URL, options?: LoadCommandsOptions): Promise<LoadCommandsResult>;
     use(middleware: CommandMiddleware): this;
@@ -808,6 +914,15 @@ declare class AccountService {
     isOwner(message: Pick<Message, 'keys' | 'senderIds'>): boolean;
 }
 
+interface HealthChangedEvent {
+    previous: StabilityHealthStatus;
+    current: StabilityHealthStatus;
+    health: AppHealth;
+}
+interface ConnectionRecoveredEvent {
+    recoveredAt: Date;
+    reconnects: number;
+}
 interface AppEvents {
     message: Message;
     messageDeleted: MessageDeleted;
@@ -817,6 +932,12 @@ interface AppEvents {
     mute: MuteEnforcement;
     call: CallEvent;
     groupParticipantsChanged: GroupParticipantsChanged;
+    healthChanged: HealthChangedEvent;
+    connectionRecovered: ConnectionRecoveredEvent;
+    groupMetadataRecovered: GroupMetadataRecoveredEvent;
+    cryptoDegraded: CryptoDegradedEvent;
+    commandQueueTimeout: CommandQueueTimeoutEvent;
+    commandQueueFull: CommandQueueFullEvent;
 }
 interface LoginOptions {
     onCode?: (code: string) => void | Promise<void>;
@@ -825,12 +946,19 @@ interface LoginOptions {
 type AppHealthStatus = 'idle' | 'starting' | 'ready' | 'stopped';
 interface AppHealth {
     status: AppHealthStatus;
+    stability: StabilityHealthStatus;
     state: ConnectionUpdate['state'];
     ready: boolean;
     uptimeMs: number;
     timestamp: Date;
     muteEnabled: boolean;
     logLevel: LogLevel;
+    connection: ProviderConnectionHealth;
+    messaging: ProviderMessagingHealth;
+    crypto: ProviderCryptoHealth;
+    groups: ProviderGroupHealth;
+    commands: CommandConcurrencyHealth;
+    timeouts: ProviderTimeoutHealth;
 }
 interface WhaNextAppOptions {
     phone?: string;
@@ -869,6 +997,10 @@ declare enum Browser {
     Ubuntu = "ubuntu"
 }
 
+interface ProviderTimeoutOptions {
+    connectTimeoutMs?: number;
+    nodeQueryTimeoutMs?: number;
+}
 interface ReconnectOptions {
     enabled?: boolean;
     maxAttempts?: number;
@@ -885,6 +1017,7 @@ interface CreateOptions {
     mute?: MuteOptions;
     router?: Omit<RouterOptions, 'prefix'>;
     reconnect?: ReconnectOptions;
+    providerTimeouts?: ProviderTimeoutOptions;
     messageCacheSize?: number;
     processOfflineMessages?: boolean;
     provider?: WhatsAppProvider;
@@ -972,4 +1105,4 @@ declare class SqliteMuteStore implements MuteStore {
     close(): void;
 }
 
-export { AccountService, type AddMuteOptions, type AddMuteResult, type AppEvents, type AppHealth, type AppHealthStatus, ArgsParser, type AudioContent, type BooleanOption, Browser, type ButtonsContent, type CacheOptions, type CacheStore, type CallEvent, type CallStatus, type ChangeResult, type CommandAccountContext, type CommandCatalogOptions, type CommandCatalogView, type CommandChatContext, type CommandConcurrency, type CommandContext, type CommandCooldown, type CommandDefinition, type CommandErrorHandler, type CommandGroupContext, type CommandGroupDefinition, type CommandGuard, type CommandHelpOptions, type CommandHooks, type CommandLocalization, type CommandMetadata, type CommandMiddleware, type CommandOptionDefinition, type CommandOptionSchema, type CommandOptionValue, type CommandOptionValues, type CommandRegistrar, CommandRouter, type CommandRuntimeServices, type CommandScope, type ConcurrencyStrategy, type ConnectionState, type ConnectionUpdate, type CopyCodeButton, type CreateMultiOptions, type CreateOptions, DeferredReply, type DownloadedMedia, type DurationOption, type EnumOption, type ExecutableCommandDefinition, type GroupAccess, type GroupAddressingMode, type GroupParticipant, type GroupParticipantAction, type GroupParticipantsChanged, type GroupRole, type GroupSnapshot, type GuardResult, type ImageContent, type InteractiveResponse, type InteractiveResponseKind, type InviteResult, type LinkButton, type ListContent, type ListRow, type ListSection, type LoadCommandsOptions, type LoadCommandsResult, type LoadedCommand, type LogContext, type LogEntry, type LogFormat, type LogLevel, type LogWriter, Logger, type LoggerConfig, type LoggerOptions, type LoginOptions, type MediaKind, type MediaSource, type MemberActionState, MemoryCache, type MemoryCacheStats, type MentionTarget, type Message, type MessageButton, type MessageContent, type MessageContentKind, type MessageDeleted, type MessageEdited, type MessageKey, type MessageMedia, type MessagePayloadKind, type MessageProtocolKind, type MultiAccountOptions, type MultiAppEvent, type MultiAppHealth, MultiCommandRouter, type MultiLoadCommandsResult, type MultiLoginOptions, type MuteChangeResult, type MuteEnforcement, type MuteOptions, type MuteRecord, MuteService, type MuteStore, type NumberOption, ParsedCommandOptions, type ParticipantUpdateResult, type PollContent, type PresenceState, type QuickReplyButton, type QuotedMessage, type ReconnectOptions, type RegisteredCommand, type RemoveMuteResult, type ReplyOptions, type RepostMessageOptions, type RouterOptions, type SentMessage, SqliteMuteStore, type StickerContent, type StoredMute, type StringOption, type TextContent, User, type UserData, type UserOption, type VideoContent, WhaNextApp, WhaNextError, type WhaNextErrorCode, WhaNextMultiApp, type WhatsAppProvider, create, createMulti, defineCommand, defineCommandGroup, defineCommands, defineSubcommand, guards, isCommandGroup, loadCommands, option, toWhaNextError };
+export { AccountService, type AddMuteOptions, type AddMuteResult, type AppEvents, type AppHealth, type AppHealthStatus, ArgsParser, type AudioContent, type BooleanOption, Browser, type ButtonsContent, type CacheOptions, type CacheStore, type CallEvent, type CallStatus, type ChangeResult, type CommandAccountContext, type CommandCatalogOptions, type CommandCatalogView, type CommandChatContext, type CommandConcurrency, type CommandConcurrencyContext, type CommandConcurrencyEvent, type CommandConcurrencyHealth, type CommandContext, type CommandCooldown, type CommandDefinition, type CommandErrorHandler, type CommandGroupContext, type CommandGroupDefinition, type CommandGuard, type CommandHelpOptions, type CommandHooks, type CommandLocalization, type CommandMetadata, type CommandMiddleware, type CommandOptionDefinition, type CommandOptionSchema, type CommandOptionValue, type CommandOptionValues, type CommandQueueFullEvent, type CommandQueueTimeoutEvent, type CommandRegistrar, CommandRouter, type CommandRouterEvents, type CommandRuntimeServices, type CommandScope, type ConcurrencyStrategy, type ConnectionRecoveredEvent, type ConnectionState, type ConnectionUpdate, type CopyCodeButton, type CreateMultiOptions, type CreateOptions, type CryptoAccelerationBackend, type CryptoDegradationKind, type CryptoDegradedEvent, DeferredReply, type DownloadedMedia, type DurationOption, type EnumOption, type ExecutableCommandDefinition, type GroupAccess, type GroupAddressingMode, type GroupMetadataRecoveredEvent, type GroupParticipant, type GroupParticipantAction, type GroupParticipantsChanged, type GroupRole, type GroupSnapshot, type GuardResult, type HealthChangedEvent, type ImageContent, type InteractiveResponse, type InteractiveResponseKind, type InviteResult, type LinkButton, type ListContent, type ListRow, type ListSection, type LoadCommandsOptions, type LoadCommandsResult, type LoadedCommand, type LogContext, type LogEntry, type LogFormat, type LogLevel, type LogWriter, Logger, type LoggerConfig, type LoggerOptions, type LoginOptions, type MediaKind, type MediaSource, type MemberActionState, MemoryCache, type MemoryCacheStats, type MentionTarget, type Message, type MessageButton, type MessageContent, type MessageContentKind, type MessageDeleted, type MessageEdited, type MessageKey, type MessageMedia, type MessagePayloadKind, type MessageProtocolKind, type MultiAccountOptions, type MultiAppEvent, type MultiAppHealth, MultiCommandRouter, type MultiLoadCommandsResult, type MultiLoginOptions, type MuteChangeResult, type MuteEnforcement, type MuteOptions, type MuteRecord, MuteService, type MuteStore, type NumberOption, ParsedCommandOptions, type ParticipantUpdateResult, type PollContent, type PresenceState, type ProviderConnectionHealth, type ProviderCryptoHealth, type ProviderGroupHealth, type ProviderHealth, type ProviderMessagingHealth, type ProviderStabilityEvent, type ProviderTimeoutHealth, type ProviderTimeoutOptions, type QuickReplyButton, type QuotedMessage, type ReconnectOptions, type RegisteredCommand, type RemoveMuteResult, type ReplyOptions, type RepostMessageOptions, type RouterOptions, type SentMessage, SqliteMuteStore, type StabilityHealthStatus, type StickerContent, type StoredMute, type StringOption, type TextContent, User, type UserData, type UserOption, type VideoContent, WhaNextApp, WhaNextError, type WhaNextErrorCode, WhaNextMultiApp, type WhatsAppProvider, create, createMulti, defineCommand, defineCommandGroup, defineCommands, defineSubcommand, guards, isCommandGroup, loadCommands, option, toWhaNextError };