spectrum-ts 1.4.0 → 1.7.1

package/dist/chunk-4O7DPKLI.js

@@ -0,0 +1,850 @@
+import {
+  asPollOption,
+  cloud,
+  mergeStreams,
+  stream
+} from "./chunk-WFIUWFE4.js";
+import {
+  UnsupportedError,
+  asAttachment,
+  asContact,
+  asCustom,
+  asReaction,
+  asText,
+  definePlatform
+} from "./chunk-JWWIFSI7.js";
+
+// src/providers/whatsapp-business/index.ts
+import { createClient as createClient2 } from "@photon-ai/whatsapp-business";
+
+// src/providers/whatsapp-business/auth.ts
+import {
+  createClient,
+  TypedEventStream
+} from "@photon-ai/whatsapp-business";
+var RENEWAL_RATIO = 0.8;
+var EXPIRY_BUFFER_MS = 3e4;
+var RETRY_DELAY_MS = 3e4;
+var RESUBSCRIBE_BACKOFF_MS = 500;
+var cloudAuthState = /* @__PURE__ */ new WeakMap();
+async function createCloudClients(projectId, projectSecret) {
+  let tokenData = await cloud.issueWhatsappBusinessTokens(
+    projectId,
+    projectSecret
+  );
+  let tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+  let disposed = false;
+  let renewalTimer;
+  const lines = /* @__PURE__ */ new Map();
+  const buildRawClient = (phoneNumberId) => {
+    const accessToken = tokenData.auth[phoneNumberId];
+    if (!accessToken) {
+      throw new Error(
+        `WhatsApp Business line ${phoneNumberId} missing from token response`
+      );
+    }
+    return createClient({ accessToken, appSecret: "", phoneNumberId });
+  };
+  const refreshTokens = async () => {
+    tokenData = await cloud.issueWhatsappBusinessTokens(
+      projectId,
+      projectSecret
+    );
+    tokenExpiresAt = Date.now() + tokenData.expiresIn * 1e3;
+    for (const [phoneNumberId, state] of lines) {
+      if (!tokenData.auth[phoneNumberId]) {
+        continue;
+      }
+      const old = state.current;
+      state.current = buildRawClient(phoneNumberId);
+      for (const sub of state.subscriptions) {
+        sub.swap();
+      }
+      await old.close().catch(() => void 0);
+    }
+  };
+  const clearRenewalTimer = () => {
+    if (renewalTimer !== void 0) {
+      clearTimeout(renewalTimer);
+      renewalTimer = void 0;
+    }
+  };
+  const scheduleRenewal = () => {
+    if (disposed) {
+      return;
+    }
+    clearRenewalTimer();
+    const ttlMs = tokenData.expiresIn * 1e3;
+    const renewInMs = Math.max(ttlMs * RENEWAL_RATIO, 5e3);
+    renewalTimer = setTimeout(async () => {
+      try {
+        await refreshTokens();
+        scheduleRenewal();
+      } catch (err) {
+        console.warn(
+          `[spectrum-ts] WhatsApp Business token refresh failed; retrying in ${RETRY_DELAY_MS}ms.`,
+          err
+        );
+        clearRenewalTimer();
+        renewalTimer = setTimeout(() => scheduleRenewal(), RETRY_DELAY_MS);
+        renewalTimer?.unref?.();
+      }
+    }, renewInMs);
+    renewalTimer?.unref?.();
+  };
+  const refreshIfNeeded = async () => {
+    if (Date.now() < tokenExpiresAt - EXPIRY_BUFFER_MS) {
+      return;
+    }
+    await refreshTokens();
+    scheduleRenewal();
+  };
+  scheduleRenewal();
+  const clients = Object.keys(tokenData.auth).map(
+    (phoneNumberId) => {
+      const state = {
+        current: buildRawClient(phoneNumberId),
+        subscriptions: /* @__PURE__ */ new Set()
+      };
+      lines.set(phoneNumberId, state);
+      return buildClientProxy(state, refreshIfNeeded);
+    }
+  );
+  cloudAuthState.set(clients, {
+    dispose: async () => {
+      disposed = true;
+      clearRenewalTimer();
+      for (const state of lines.values()) {
+        for (const sub of state.subscriptions) {
+          sub.close();
+        }
+      }
+      await Promise.allSettled(
+        Array.from(lines.values()).map((s) => s.current.close())
+      );
+      lines.clear();
+    }
+  });
+  return clients;
+}
+async function disposeCloudAuth(clients) {
+  const auth = cloudAuthState.get(clients);
+  if (!auth) {
+    return;
+  }
+  await auth.dispose();
+  cloudAuthState.delete(clients);
+}
+var buildClientProxy = (state, refresh) => {
+  const forwarder = (pick) => new Proxy({}, {
+    get: (_, prop) => async (...args) => {
+      await refresh();
+      const target = pick(state.current);
+      const fn = target[prop];
+      return Reflect.apply(fn, pick(state.current), args);
+    }
+  });
+  const events = {
+    fetchMissed: async (opts) => {
+      await refresh();
+      return state.current.events.fetchMissed(opts);
+    },
+    subscribe: (options) => resubscribableStream(state, options)
+  };
+  return {
+    events,
+    media: forwarder((c) => c.media),
+    messages: forwarder((c) => c.messages),
+    close: async () => {
+      for (const sub of state.subscriptions) {
+        sub.close();
+      }
+      await state.current.close();
+    },
+    [Symbol.asyncDispose]: async () => {
+      for (const sub of state.subscriptions) {
+        sub.close();
+      }
+      await state.current.close();
+    }
+  };
+};
+var pumpOnce = async (ctx) => {
+  const sub = ctx.getCurrent().events.subscribe(ctx.options);
+  ctx.setActive(sub);
+  try {
+    for await (const event of sub) {
+      await ctx.emit(event);
+    }
+    return true;
+  } catch {
+    return false;
+  } finally {
+    ctx.setActive(void 0);
+  }
+};
+var resubscribableStream = (state, options) => {
+  let closed = false;
+  let active;
+  const source = stream((emit, end) => {
+    const ctx = {
+      emit,
+      getCurrent: () => state.current,
+      options,
+      setActive: (s) => {
+        active = s;
+      }
+    };
+    const pump = (async () => {
+      while (!closed) {
+        await pumpOnce(ctx);
+        if (!closed) {
+          await new Promise((r) => setTimeout(r, RESUBSCRIBE_BACKOFF_MS));
+        }
+      }
+      end();
+    })();
+    return async () => {
+      closed = true;
+      active?.close().catch(() => void 0);
+      active = void 0;
+      state.subscriptions.delete(subscription);
+      await pump;
+    };
+  });
+  const subscription = {
+    close: () => {
+      closed = true;
+      active?.close().catch(() => void 0);
+    },
+    swap: () => {
+      active?.close().catch(() => void 0);
+    }
+  };
+  state.subscriptions.add(subscription);
+  return new TypedEventStream(source, async () => {
+    closed = true;
+    active?.close().catch(() => void 0);
+    state.subscriptions.delete(subscription);
+    await source.close();
+  });
+};
+
+// src/providers/whatsapp-business/messages.ts
+import { extension as mimeExtension } from "mime-types";
+
+// src/providers/whatsapp-business/poll.ts
+import {
+  button,
+  buttons,
+  list
+} from "@photon-ai/whatsapp-business";
+var MAX_BUTTON_OPTIONS = 3;
+var LIST_BUTTON_TEXT = "View options";
+var LIST_SECTION_TITLE = "Options";
+var pollOptionId = (index) => `opt_${index}`;
+var pollToInteractive = (content) => {
+  if (content.options.length <= MAX_BUTTON_OPTIONS) {
+    return buttons(
+      content.title,
+      ...content.options.map((o, i) => button(pollOptionId(i), o.title))
+    );
+  }
+  return list(content.title, LIST_BUTTON_TEXT).section(
+    LIST_SECTION_TITLE,
+    content.options.map((o, i) => ({ id: pollOptionId(i), title: o.title }))
+  );
+};
+
+// src/providers/whatsapp-business/messages.ts
+var primary = (clients) => {
+  const client = clients[0];
+  if (!client) {
+    throw new Error("No WhatsApp Business client available");
+  }
+  return client;
+};
+var toRecord = (result, spaceId, content) => ({
+  id: result.messageId,
+  content,
+  space: { id: spaceId },
+  timestamp: /* @__PURE__ */ new Date()
+});
+var MAX_POLL_CACHE_SIZE = 1e3;
+var OPTION_ID_PREFIX = "opt_";
+var pollCaches = /* @__PURE__ */ new WeakMap();
+var getPollCache = (client) => {
+  let cache = pollCaches.get(client);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    pollCaches.set(client, cache);
+  }
+  return cache;
+};
+var cachePoll = (client, messageId, poll) => {
+  const cache = getPollCache(client);
+  if (cache.has(messageId)) {
+    cache.delete(messageId);
+  }
+  cache.set(messageId, poll);
+  if (cache.size > MAX_POLL_CACHE_SIZE) {
+    const first = cache.keys().next().value;
+    if (first !== void 0) {
+      cache.delete(first);
+    }
+  }
+};
+var optionIndexFromId = (id) => {
+  if (!id.startsWith(OPTION_ID_PREFIX)) {
+    return;
+  }
+  const index = Number(id.slice(OPTION_ID_PREFIX.length));
+  if (!Number.isInteger(index) || index < 0 || pollOptionId(index) !== id) {
+    return;
+  }
+  return index;
+};
+var mapWaPhoneType = (type) => {
+  if (!type) {
+    return;
+  }
+  const upper = type.toUpperCase();
+  if (upper === "CELL" || upper === "MOBILE" || upper === "IPHONE") {
+    return "mobile";
+  }
+  if (upper === "HOME") {
+    return "home";
+  }
+  if (upper === "WORK" || upper === "BUSINESS") {
+    return "work";
+  }
+  return "other";
+};
+var mapWaSimpleType = (type) => {
+  if (!type) {
+    return;
+  }
+  const upper = type.toUpperCase();
+  if (upper === "HOME") {
+    return "home";
+  }
+  if (upper === "WORK" || upper === "BUSINESS") {
+    return "work";
+  }
+  return "other";
+};
+var waNameToSpectrum = (name) => {
+  const result = { formatted: name.formattedName };
+  if (name.firstName) {
+    result.first = name.firstName;
+  }
+  if (name.lastName) {
+    result.last = name.lastName;
+  }
+  if (name.middleName) {
+    result.middle = name.middleName;
+  }
+  if (name.prefix) {
+    result.prefix = name.prefix;
+  }
+  if (name.suffix) {
+    result.suffix = name.suffix;
+  }
+  return result;
+};
+var waPhoneToSpectrum = (phone) => {
+  const entry = { value: phone.phone };
+  const type = mapWaPhoneType(phone.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waEmailToSpectrum = (email) => {
+  const entry = { value: email.email };
+  const type = mapWaSimpleType(email.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waAddressToSpectrum = (address) => {
+  const entry = {};
+  if (address.street) {
+    entry.street = address.street;
+  }
+  if (address.city) {
+    entry.city = address.city;
+  }
+  if (address.state) {
+    entry.region = address.state;
+  }
+  if (address.zip) {
+    entry.postalCode = address.zip;
+  }
+  if (address.country) {
+    entry.country = address.country;
+  }
+  const type = mapWaSimpleType(address.type);
+  if (type) {
+    entry.type = type;
+  }
+  return entry;
+};
+var waOrgToSpectrum = (org) => {
+  const entry = {};
+  if (org.company) {
+    entry.name = org.company;
+  }
+  if (org.title) {
+    entry.title = org.title;
+  }
+  if (org.department) {
+    entry.department = org.department;
+  }
+  return entry;
+};
+var waContactToSpectrum = (card) => {
+  const input = { raw: card };
+  input.name = waNameToSpectrum(card.name);
+  if (card.phones.length > 0) {
+    input.phones = card.phones.map(waPhoneToSpectrum);
+  }
+  if (card.emails.length > 0) {
+    input.emails = card.emails.map(waEmailToSpectrum);
+  }
+  if (card.addresses.length > 0) {
+    input.addresses = card.addresses.map(waAddressToSpectrum);
+  }
+  if (card.org) {
+    input.org = waOrgToSpectrum(card.org);
+  }
+  if (card.urls.length > 0) {
+    input.urls = card.urls.map((u) => u.url);
+  }
+  if (card.birthday) {
+    input.birthday = card.birthday;
+  }
+  return asContact(input);
+};
+var toMessages = (client, msg) => {
+  const base = {
+    sender: { id: msg.from },
+    space: { id: msg.from },
+    timestamp: msg.timestamp
+  };
+  if (msg.content.type === "contacts") {
+    const multi = msg.content.contacts.length > 1;
+    return msg.content.contacts.map((card, index) => ({
+      ...base,
+      id: multi ? `${msg.id}:${index}` : msg.id,
+      content: waContactToSpectrum(card)
+    }));
+  }
+  return [
+    {
+      ...base,
+      id: msg.id,
+      content: mapContent(client, msg)
+    }
+  ];
+};
+var mapContent = (client, msg) => {
+  const { content } = msg;
+  switch (content.type) {
+    case "text":
+      return asText(content.body);
+    case "image":
+    case "video":
+    case "audio":
+    case "document":
+      return lazyMedia(client, content.media);
+    case "sticker":
+      return asCustom({ whatsapp_type: "sticker", ...content.sticker });
+    case "location":
+      return asCustom({ whatsapp_type: "location", ...content.location });
+    case "reaction": {
+      const stubTarget = {
+        id: content.reaction.messageId,
+        content: asCustom({ whatsapp_type: "reaction-target", stub: true })
+      };
+      return asReaction({
+        emoji: content.reaction.emoji,
+        target: stubTarget
+      });
+    }
+    case "interactive": {
+      const inter = content.interactive;
+      if (inter.type === "button_reply" || inter.type === "list_reply") {
+        const poll = msg.context?.id === void 0 ? void 0 : getPollCache(client).get(msg.context.id);
+        const optionIndex = optionIndexFromId(inter.reply.id);
+        const option = optionIndex === void 0 ? void 0 : poll?.options[optionIndex];
+        if (poll && option) {
+          return asPollOption({ poll, option, selected: true });
+        }
+      }
+      return asCustom({ whatsapp_type: "interactive", ...inter });
+    }
+    case "button":
+      return asCustom({ whatsapp_type: "button", ...content.button });
+    case "order":
+      return asCustom({ whatsapp_type: "order", ...content.order });
+    case "system":
+      return asCustom({ whatsapp_type: "system", ...content.system });
+    default:
+      return asCustom({ whatsapp_type: "unknown" });
+  }
+};
+var fetchMedia = async (client, mediaId) => {
+  const { url } = await client.media.getUrl(mediaId);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Media download failed: ${response.status}`);
+  }
+  return response;
+};
+var lazyMedia = (client, media) => asAttachment({
+  name: media.filename ?? `media-${media.id}`,
+  mimeType: media.mimeType,
+  read: async () => Buffer.from(await (await fetchMedia(client, media.id)).arrayBuffer()),
+  stream: async () => {
+    const response = await fetchMedia(client, media.id);
+    if (!response.body) {
+      throw new Error("Media response missing body");
+    }
+    return response.body;
+  }
+});
+var mimeToMediaType = (mimeType) => {
+  if (mimeType.startsWith("image/")) {
+    return "image";
+  }
+  if (mimeType.startsWith("video/")) {
+    return "video";
+  }
+  if (mimeType.startsWith("audio/")) {
+    return "audio";
+  }
+  return "document";
+};
+var voiceFilename = (content) => {
+  if (content.name) {
+    return content.name;
+  }
+  const ext = mimeExtension(content.mimeType);
+  return ext ? `voice.${ext}` : "voice";
+};
+var spectrumPhoneTypeToWa = (type) => {
+  if (type === "mobile") {
+    return "CELL";
+  }
+  if (type === "home" || type === "work" || type === "other") {
+    return type.toUpperCase();
+  }
+  return;
+};
+var spectrumSimpleTypeToWa = (type) => type ? type.toUpperCase() : void 0;
+var spectrumNameToWa = (name) => ({
+  formattedName: name?.formatted ?? ([name?.first, name?.middle, name?.last].filter((p) => Boolean(p)).join(" ") || "Unknown"),
+  firstName: name?.first,
+  lastName: name?.last,
+  middleName: name?.middle,
+  prefix: name?.prefix,
+  suffix: name?.suffix
+});
+var isWhatsAppContactCard = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const raw = value;
+  const name = raw.name;
+  if (!name || typeof name !== "object" || typeof name.formattedName !== "string") {
+    return false;
+  }
+  return Array.isArray(raw.phones) && Array.isArray(raw.emails) && Array.isArray(raw.addresses) && Array.isArray(raw.urls);
+};
+var contactToWa = (contact) => {
+  if (isWhatsAppContactCard(contact.raw)) {
+    return contact.raw;
+  }
+  const card = {
+    name: spectrumNameToWa(contact.name),
+    phones: (contact.phones ?? []).map((p) => ({
+      phone: p.value,
+      type: spectrumPhoneTypeToWa(p.type)
+    })),
+    emails: (contact.emails ?? []).map((e) => ({
+      email: e.value,
+      type: spectrumSimpleTypeToWa(e.type)
+    })),
+    addresses: (contact.addresses ?? []).map((a) => ({
+      street: a.street,
+      city: a.city,
+      state: a.region,
+      zip: a.postalCode,
+      country: a.country,
+      type: spectrumSimpleTypeToWa(a.type)
+    })),
+    urls: (contact.urls ?? []).map((url) => ({ url })),
+    org: contact.org?.name || contact.org?.department || contact.org?.title ? {
+      company: contact.org.name,
+      department: contact.org.department,
+      title: contact.org.title
+    } : void 0,
+    birthday: contact.birthday
+  };
+  return card;
+};
+var clientStream = (client) => {
+  const eventStream = client.events.subscribe().filter(
+    (e) => e.type === "message"
+  );
+  return stream((emit, end) => {
+    const pump = (async () => {
+      try {
+        for await (const event of eventStream) {
+          for (const m of toMessages(client, event.message)) {
+            await emit(m);
+          }
+        }
+        end();
+      } catch (e) {
+        end(e);
+      }
+    })();
+    return async () => {
+      await eventStream.close();
+      await pump;
+    };
+  });
+};
+var messages = (clients) => mergeStreams(clients.map(clientStream));
+var send = async (clients, spaceId, content) => {
+  if (content.type === "reply") {
+    return await replyToMessage(
+      clients,
+      spaceId,
+      content.target.id,
+      content.content
+    );
+  }
+  if (content.type === "reaction") {
+    await reactToMessage(clients, spaceId, content.target.id, content.emoji);
+    return;
+  }
+  if (content.type === "typing") {
+    return;
+  }
+  const client = primary(clients);
+  switch (content.type) {
+    case "text":
+      return toRecord(
+        await client.messages.send({ to: spaceId, text: content.text }),
+        spaceId,
+        content
+      );
+    case "attachment": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: content.name
+      });
+      const mediaType = mimeToMediaType(content.mimeType);
+      const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          [mediaType]: mediaPayload
+        }),
+        spaceId,
+        content
+      );
+    }
+    case "contact":
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          contacts: [contactToWa(content)]
+        }),
+        spaceId,
+        content
+      );
+    case "voice": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: voiceFilename(content)
+      });
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          audio: { id: mediaId }
+        }),
+        spaceId,
+        content
+      );
+    }
+    case "poll": {
+      const result = await client.messages.send({
+        to: spaceId,
+        interactive: pollToInteractive(content)
+      });
+      cachePoll(client, result.messageId, content);
+      return toRecord(result, spaceId, content);
+    }
+    default:
+      throw UnsupportedError.content(content.type);
+  }
+};
+var reactToMessage = async (clients, spaceId, messageId, reaction) => {
+  await primary(clients).messages.send({
+    to: spaceId,
+    reaction: { messageId, emoji: reaction }
+  });
+};
+var replyToMessage = async (clients, spaceId, messageId, content) => {
+  const client = primary(clients);
+  switch (content.type) {
+    case "text":
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          text: content.text
+        }),
+        spaceId,
+        content
+      );
+    case "attachment": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: content.name
+      });
+      const mediaType = mimeToMediaType(content.mimeType);
+      const mediaPayload = mediaType === "document" ? { id: mediaId, filename: content.name } : { id: mediaId };
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          [mediaType]: mediaPayload
+        }),
+        spaceId,
+        content
+      );
+    }
+    case "contact":
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          contacts: [contactToWa(content)]
+        }),
+        spaceId,
+        content
+      );
+    case "voice": {
+      const { mediaId } = await client.media.upload({
+        file: await content.read(),
+        mimeType: content.mimeType,
+        filename: voiceFilename(content)
+      });
+      return toRecord(
+        await client.messages.send({
+          to: spaceId,
+          replyTo: messageId,
+          audio: { id: mediaId }
+        }),
+        spaceId,
+        content
+      );
+    }
+    case "poll": {
+      const result = await client.messages.send({
+        to: spaceId,
+        replyTo: messageId,
+        interactive: pollToInteractive(content)
+      });
+      cachePoll(client, result.messageId, content);
+      return toRecord(result, spaceId, content);
+    }
+    default:
+      throw UnsupportedError.content(content.type);
+  }
+};
+
+// src/providers/whatsapp-business/types.ts
+import z from "zod";
+var directConfig = z.object({
+  accessToken: z.string().min(1),
+  appSecret: z.string().optional(),
+  phoneNumberId: z.string().min(1)
+});
+var cloudConfig = z.object({}).strict();
+var configSchema = z.union([directConfig, cloudConfig]);
+var isCloudConfig = (config) => !("accessToken" in config);
+var userSchema = z.object({});
+var spaceSchema = z.object({
+  id: z.string()
+});
+
+// src/providers/whatsapp-business/index.ts
+var whatsappBusiness = definePlatform("WhatsApp Business", {
+  config: configSchema,
+  lifecycle: {
+    createClient: async ({
+      config,
+      projectId,
+      projectSecret
+    }) => {
+      if (!isCloudConfig(config)) {
+        return [
+          createClient2({
+            accessToken: config.accessToken,
+            appSecret: config.appSecret ?? "",
+            phoneNumberId: config.phoneNumberId
+          })
+        ];
+      }
+      if (!(projectId && projectSecret)) {
+        throw new Error(
+          "WhatsApp Business cloud mode requires projectId and projectSecret. Either pass credentials to Spectrum(), or provide direct credentials: whatsappBusiness.config({ accessToken, phoneNumberId })"
+        );
+      }
+      return await createCloudClients(projectId, projectSecret);
+    },
+    destroyClient: async ({ client }) => {
+      await disposeCloudAuth(client);
+      await Promise.all(client.map((c) => c.close()));
+    }
+  },
+  user: {
+    resolve: async ({ input }) => ({ id: input.userID })
+  },
+  space: {
+    schema: spaceSchema,
+    resolve: async ({ input }) => {
+      if (input.users.length === 0) {
+        throw new Error("WhatsApp space creation requires at least one user");
+      }
+      if (input.users.length > 1) {
+        throw UnsupportedError.action(
+          "createSpace",
+          "WhatsApp Business",
+          "only 1:1 conversations are supported"
+        );
+      }
+      const user = input.users[0];
+      if (!user) {
+        throw new Error("WhatsApp space creation requires a user");
+      }
+      return { id: user.id };
+    }
+  },
+  messages: ({ client }) => messages(client),
+  send: async ({ space, content, client }) => await send(client, space.id, content)
+});
+
+export {
+  whatsappBusiness
+};