Bot

import { Bot, flow } from '@botmesh/core'
import { BaileysProvider } from '@botmesh/baileys'

const bot = new Bot({ provider: new BaileysProvider({ session: 'my-bot' }) })

bot.when('hi', (ctx) => ctx.reply('Hello! 👋'))
bot.use(
  flow('register')
    .ask('What is your name?', 'name')
    .say((_ctx, c) => `Nice to meet you, ${c.state.name}!`),
)

await bot.start()

new Bot(config): Bot;

readonly logger: Logger;

readonly ready: Promise<void>;

readonly blacklist: AccessList;

readonly whitelist: Whitelist;

on<K>(event, listener): this;

server.on('connection', (stream) => {
  console.log('someone connected!');
});

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

on(event, listener): this;

once<K>(event, listener): this;

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

once(event, listener): this;

off<K>(event, listener): this;

off(event, listener): this;

emit<K>(event, ...args): boolean;

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

emit(event, ...args): boolean;

start(): Promise<void>;

stop(opts?): Promise<void>;

send(
   chatId, 
   content, 
   options?
): Promise<SentMessage<unknown>>;

enqueue(
   chatId, 
   content, 
   options?
): Promise<{
  key: string;
  status: "exists" | "queued" | "skipped";
}>;

await bot.enqueue(chatId, 'Tu cita es mañana', { idempotencyKey: `reminder:${citaId}` })

sendText(chatId, text): Promise<SentMessage<unknown>>;

broadcast(
   chatIds, 
   content, 
   opts?
): Promise<BroadcastResult>;

const ac = new AbortController()
const res = await bot.broadcast(chatIds, '🎉 Nueva promo!', {
  batchSize: 10, delayBetween: '2s', signal: ac.signal,
  onProgress: (done, total) => bot.logger.info(`${done}/${total}`),
  onFail: (chatId, error) => bot.logger.warn({ chatId, err: error }, 'broadcast failed'),
})
// → { total: 500, sent: 480, failed: 20, skipped: 0, errors: [{ chatId, error }], messages, cancelled: false, pending: [] }

trigger(name, opts): Promise<TriggerResult>;

bot.schedule('0 9 * * *', async () => {
  for (const cita of await db.citasDeHoy()) {
    await bot.trigger('recordatorio', { chatId: cita.chatId, data: { hora: cita.hora } })
  }
})

metrics(): BotMetricsSnapshot;

resetMetrics(): void;

handoff(chatId, opts?): Promise<boolean>;

resume(chatId, opts?): Promise<boolean>;

isHandedOff(chatId): boolean;

getHandoff(chatId): HandoffState | undefined;

listHandoffs(): HandoffState[];

sendTo(
   chatId, 
   content, 
   options?
): Promise<SentMessage<unknown>>;

exportAccessLists(): AccessListsSnapshot;

loadAccessLists(snapshot): this;

when(trigger, handler): () => void;

conversation(
   name, 
   fn, 
   opts?
): () => void;

bot.conversation('ahorcado', async (c, ctx) => {
  c.idle('2m', () => c.end('⏰ Te desconecté por inactividad'))
  let letra = await c.ask('Escribe una letra')
  while (letra.length !== 1) letra = await c.retry('❌ Solo una letra')
  await ctx.react('✅')
})

enterConversation(handler, ctx): Promise<void>;

bot.when('pedido', async (ctx) => {
  bot.enterConversation(async (c) => {
    const ok = await c.ask('¿Confirmas? (sí/no)')
    await c.say(ok === 'sí' ? 'Hecho' : 'Cancelado')
  }, ctx)
})

enterConversation(name, ctx): Promise<void>;

use(flow): this;

use(item): this;

useFlow(flow): this;

command(name, handler): () => void;

onMessage(handler): () => void;

onType(type, handler): () => void;

onImage(handler): () => void;

onAudio(handler): () => void;

onVideo(handler): () => void;

onDocument(handler): () => void;

onSticker(handler): () => void;

onLocation(handler): () => void;

onContact(handler): () => void;

onPoll(handler): () => void;

registerFlow(flow): string;

bot.registerFlow(flow('encuesta').ask('¿Tu nombre?', 'name').say((_ctx, c) => `Gracias ${c.state.name}`))

unregisterFlow(id): boolean;

replaceFlow(id, flow): void;

hasFlow(id): boolean;

listFlows(): RegisteredFlowInfo[];

triggerFlow(
   id, 
   target, 
   opts?
): Promise<boolean>;

listConversations(): ConversationSnapshot[];

abortConversation(target): boolean;

resetWelcome(chatId, userId?): Promise<void>;

bot.command('bienvenida', async (ctx) => {
  await bot.resetWelcome(ctx.from, ctx.isGroup ? ctx.sender : undefined)
  await ctx.reply('Listo: tu próximo mensaje recibirá la bienvenida otra vez.')
})

inspectConversation(target): 
  | ConversationSnapshot
  | undefined;

isBusy(): boolean;

before<E, TCtx>(
   event, 
   handler, 
   priority?
): this;

after<E, TCtx>(
   event, 
   handler, 
   priority?
): this;

onError<E, TCtx>(
   event, 
   handler, 
   priority?
): this;

hook<E, TCtx>(
   event, 
   phase, 
   handler, 
   priority?
): this;

hook<E, TCtx>(
   event, 
   phase, 
   handler, 
   priority?
): this;

hook<E, TCtx>(
   event, 
   phase, 
   handler, 
   priority?
): this;

hook(
   event, 
   phase, 
   handler, 
   priority?
): this;

plug<TConfig>(plugin, config?): () => void;

locale(code, messages): this;

bot.locale('es', { greeting: '¡Hola, {name}!', cart: { one: '{count} producto', other: '{count} productos' } })
bot.locale('en', { greeting: 'Hello, {name}!', cart: { one: '{count} item', other: '{count} items' } })
bot.locale({ defaultLocale: 'es' })
bot.when('hola', (ctx) => ctx.reply(ctx.t('greeting', { name: ctx.pushName ?? '' })))
bot.command('lang', async (ctx, [code]) => {
  if (!code || !bot.locales().includes(code.toLowerCase())) return ctx.reply(bot.locales().join(', '))
  await ctx.setLang(code)
})

locale(options): this;

bot.locale('es', { greeting: '¡Hola, {name}!', cart: { one: '{count} producto', other: '{count} productos' } })
bot.locale('en', { greeting: 'Hello, {name}!', cart: { one: '{count} item', other: '{count} items' } })
bot.locale({ defaultLocale: 'es' })
bot.when('hola', (ctx) => ctx.reply(ctx.t('greeting', { name: ctx.pushName ?? '' })))
bot.command('lang', async (ctx, [code]) => {
  if (!code || !bot.locales().includes(code.toLowerCase())) return ctx.reply(bot.locales().join(', '))
  await ctx.setLang(code)
})

t(
   key, 
   params?, 
   lang?
): string;

langOf(userId): Promise<string>;

locales(): string[];

provide<T>(name, value): this;

unprovide(name): boolean;

schedule(cron, fn): ScheduledTask;

schedule(
   cron, 
   opts, 
   fn
): ScheduledTask;

schedule(
   cron, 
   opts, 
   fn
): ScheduledTask;

every(interval, fn): ScheduledTask;

every(
   interval, 
   opts, 
   fn
): ScheduledTask;

delay(duration, fn): ScheduledTask;

delay(
   duration, 
   opts, 
   fn
): ScheduledTask;

forgetTask(id): Promise<void>;