imessage-sdk 0.1.0-beta.0

package/dist/providers/blooio.js

@@ -0,0 +1,655 @@
+import { z } from 'zod';
+
+// src/providers/blooio.ts
+
+// src/core/errors.ts
+var IMessageSDKError = class extends Error {
+  provider;
+  connectionId;
+  code;
+  statusCode;
+  retryable;
+  retryAfter;
+  traceId;
+  raw;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = new.target.name;
+    this.provider = options.provider;
+    this.connectionId = options.connectionId;
+    this.code = options.code;
+    this.statusCode = options.statusCode;
+    this.retryable = options.retryable ?? false;
+    this.retryAfter = options.retryAfter;
+    this.traceId = options.traceId;
+    this.raw = options.raw;
+  }
+};
+var ValidationError = class extends IMessageSDKError {
+};
+var AuthenticationError = class extends IMessageSDKError {
+};
+var NotFoundError = class extends IMessageSDKError {
+};
+var ConflictError = class extends IMessageSDKError {
+};
+var RateLimitError = class extends IMessageSDKError {
+};
+var ProviderUnavailableError = class extends IMessageSDKError {
+};
+var AmbiguousDeliveryError = class extends IMessageSDKError {
+};
+
+// src/core/provider.ts
+function defineProvider(provider) {
+  return provider;
+}
+
+// src/providers/blooio.ts
+var DEFAULT_BASE_URL = "https://api.blooio.com/v2/api";
+var DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+var BLOOIO_CAPABILITIES = {
+  messages: {
+    text: true,
+    attachments: true,
+    replies: true,
+    get: true,
+    edit: false,
+    delete: false
+  },
+  conversations: {
+    direct: true,
+    groups: false,
+    get: true,
+    markRead: true
+  },
+  interactions: {
+    reactions: true,
+    typingStart: true,
+    typingStop: true,
+    readReceipts: true
+  },
+  events: {
+    webhooks: true,
+    stream: false
+  }
+};
+var JsonObjectSchema = z.record(z.string(), z.unknown());
+var OptionalNonEmptyStringSchema = z.string().min(1).optional().catch(void 0);
+var OptionalNumberSchema = z.number().optional().catch(void 0);
+var ReactionSchema = z.enum([
+  "love",
+  "like",
+  "dislike",
+  "laugh",
+  "emphasize",
+  "question"
+]);
+var PlanKindSchema = z.enum([
+  "shared",
+  "dedicated",
+  "inbound",
+  "trial",
+  "2fa"
+]);
+function dateValue(value) {
+  const number = OptionalNumberSchema.parse(value);
+  if (number !== void 0) return new Date(number);
+  const string = OptionalNonEmptyStringSchema.parse(value);
+  if (string === void 0) return void 0;
+  const date = new Date(string);
+  return Number.isNaN(date.valueOf()) ? void 0 : date;
+}
+function address(value) {
+  return {
+    kind: value.includes("@") ? "email" : "phone",
+    value
+  };
+}
+function requireAddress(value, fallback = "unknown") {
+  return address(OptionalNonEmptyStringSchema.parse(value) ?? fallback);
+}
+function mapStatus(value) {
+  switch (typeof value === "string" ? value.toLowerCase() : "") {
+    case "queued":
+    case "pending":
+      return "pending";
+    case "accepted":
+      return "accepted";
+    case "sent":
+      return "sent";
+    case "delivered":
+      return "delivered";
+    case "read":
+      return "read";
+    case "failed":
+    case "cancelled":
+    case "cancellation_requested":
+    case "error":
+      return "failed";
+    default:
+      return "pending";
+  }
+}
+function mapService(value) {
+  switch (typeof value === "string" ? value.toLowerCase() : "") {
+    case "imessage":
+      return "imessage";
+    case "sms":
+      return "sms";
+    case "rcs":
+      return "rcs";
+    default:
+      return "unknown";
+  }
+}
+function attachmentKind(contentType) {
+  if (contentType?.startsWith("image/")) return "image";
+  if (contentType?.startsWith("video/")) return "video";
+  return "file";
+}
+function mapAttachment(value) {
+  if (typeof value === "string") {
+    return { kind: "file", url: value, raw: value };
+  }
+  const parsedItem = JsonObjectSchema.safeParse(value);
+  const item = parsedItem.success ? parsedItem.data : {};
+  const contentType = OptionalNonEmptyStringSchema.parse(item["content_type"]) ?? OptionalNonEmptyStringSchema.parse(item["contentType"]) ?? OptionalNonEmptyStringSchema.parse(item["mime_type"]);
+  const id = OptionalNonEmptyStringSchema.parse(item["id"]);
+  const url = OptionalNonEmptyStringSchema.parse(item["url"]);
+  const filename = OptionalNonEmptyStringSchema.parse(item["name"]);
+  const size = OptionalNumberSchema.parse(item["size"]);
+  const result = {
+    kind: attachmentKind(contentType),
+    raw: value,
+    ...id === void 0 ? {} : { id },
+    ...url === void 0 ? {} : { url },
+    ...filename === void 0 ? {} : { filename },
+    ...contentType === void 0 ? {} : { contentType },
+    ...size === void 0 ? {} : { size }
+  };
+  return result;
+}
+function participantValues(value) {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((participant) => {
+    if (typeof participant === "string") return [participant];
+    const parsedParticipant = JsonObjectSchema.safeParse(participant);
+    if (!parsedParticipant.success) return [];
+    const identifier = OptionalNonEmptyStringSchema.parse(
+      parsedParticipant.data["identifier"]
+    );
+    return identifier === void 0 ? [] : [identifier];
+  });
+}
+function mapProviderMessage(raw, fallbackConversationId, configuredSender) {
+  const direction = raw["direction"] === "inbound" ? "inbound" : "outbound";
+  const conversationId2 = OptionalNonEmptyStringSchema.parse(raw["chat_id"]) ?? OptionalNonEmptyStringSchema.parse(raw["group_id"]) ?? OptionalNonEmptyStringSchema.parse(raw["external_id"]) ?? fallbackConversationId;
+  const internal = OptionalNonEmptyStringSchema.parse(raw["internal_id"]);
+  const parsedContact = JsonObjectSchema.safeParse(raw["contact"]);
+  const external = OptionalNonEmptyStringSchema.parse(raw["sender"]) ?? (parsedContact.success ? OptionalNonEmptyStringSchema.parse(parsedContact.data["identifier"]) : void 0) ?? OptionalNonEmptyStringSchema.parse(raw["external_id"]) ?? conversationId2;
+  const participants = participantValues(raw["participants"]);
+  const sender = direction === "inbound" ? address(external) : internal === void 0 ? configuredSender ?? address("unknown") : address(internal);
+  const recipients = direction === "inbound" ? [internal === void 0 ? configuredSender ?? address("unknown") : address(internal)] : (participants.length > 0 ? participants : [external]).map(address);
+  const providerStatus = OptionalNonEmptyStringSchema.parse(raw["status"]);
+  const parsedReply = JsonObjectSchema.safeParse(raw["reply_to"]);
+  const reply = parsedReply.success ? parsedReply.data : void 0;
+  const replyMessageId = reply === void 0 ? void 0 : OptionalNonEmptyStringSchema.parse(reply["message_id"]) ?? OptionalNonEmptyStringSchema.parse(reply["guid"]);
+  const sentAt = dateValue(raw["time_sent"] ?? raw["sent_at"]);
+  const deliveredAt = dateValue(raw["time_delivered"] ?? raw["delivered_at"]);
+  const readAt = dateValue(raw["read_at"]);
+  const partIndex = OptionalNumberSchema.parse(reply?.["part_index"]);
+  return {
+    providerMessageId: OptionalNonEmptyStringSchema.parse(raw["message_id"]) ?? OptionalNonEmptyStringSchema.parse(raw["id"]) ?? "unknown",
+    conversationId: conversationId2,
+    direction,
+    sender,
+    recipients,
+    text: typeof raw["text"] === "string" ? raw["text"] : "",
+    attachments: Array.isArray(raw["attachments"]) ? raw["attachments"].map(mapAttachment) : [],
+    ...replyMessageId === void 0 ? {} : {
+      replyTo: {
+        messageId: replyMessageId,
+        ...partIndex === void 0 ? {} : { partIndex }
+      }
+    },
+    service: mapService(raw["protocol"]),
+    status: mapStatus(providerStatus),
+    ...providerStatus === void 0 ? {} : { providerStatus },
+    createdAt: sentAt ?? dateValue(raw["received_at"]) ?? dateValue(raw["timestamp"]) ?? /* @__PURE__ */ new Date(),
+    ...sentAt === void 0 ? {} : { sentAt },
+    ...deliveredAt === void 0 ? {} : { deliveredAt },
+    ...readAt === void 0 ? {} : { readAt },
+    raw
+  };
+}
+function encodePath(value) {
+  return encodeURIComponent(value);
+}
+function conversationId(input) {
+  return input.participants.map((participant) => participant.value).join(",");
+}
+function parseSignature(header) {
+  let timestamp;
+  const signatures = [];
+  for (const component of header.split(",")) {
+    const separator = component.indexOf("=");
+    if (separator < 0) continue;
+    const key = component.slice(0, separator).trim();
+    const value = component.slice(separator + 1).trim();
+    if (key === "t") timestamp = value;
+    if (key === "v1") signatures.push(value);
+  }
+  return timestamp === void 0 || signatures.length === 0 ? void 0 : { timestamp, signatures };
+}
+function constantTimeEqual(left, right) {
+  if (left.length !== right.length) return false;
+  let result = 0;
+  for (let index = 0; index < left.length; index += 1) {
+    result |= left.charCodeAt(index) ^ right.charCodeAt(index);
+  }
+  return result === 0;
+}
+async function hmacSha256(secret, value) {
+  const encoder = new TextEncoder();
+  const key = await crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(value));
+  return Array.from(
+    new Uint8Array(signature),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+}
+function eventStatus(event, rawStatus) {
+  switch (event) {
+    case "message.received":
+      return "delivered";
+    case "message.sent":
+      return "sent";
+    case "message.delivered":
+      return "delivered";
+    case "message.read":
+      return "read";
+    case "message.failed":
+      return "failed";
+    default:
+      return mapStatus(rawStatus);
+  }
+}
+function mapWebhookEvent(raw) {
+  const event = OptionalNonEmptyStringSchema.parse(raw["event"]);
+  if (event === void 0) return void 0;
+  const timestamp = dateValue(raw["timestamp"]) ?? /* @__PURE__ */ new Date();
+  const messageId = OptionalNonEmptyStringSchema.parse(raw["message_id"]) ?? "unknown";
+  const conversation = OptionalNonEmptyStringSchema.parse(raw["group_id"]) ?? OptionalNonEmptyStringSchema.parse(raw["external_id"]) ?? "unknown";
+  const id = `${event}:${messageId}:${timestamp.valueOf()}`;
+  if (event === "message.reaction") {
+    const parsedReaction = ReactionSchema.safeParse(raw["reaction"]);
+    if (!parsedReaction.success) return void 0;
+    const reaction = parsedReaction.data;
+    const partIndex = OptionalNumberSchema.parse(raw["part_index"]);
+    return {
+      id,
+      type: raw["action"] === "remove" ? "reaction.removed" : "reaction.added",
+      timestamp,
+      conversationId: conversation,
+      messageId,
+      actor: requireAddress(raw["sender"] ?? raw["external_id"]),
+      reaction,
+      ...partIndex === void 0 ? {} : { partIndex },
+      raw
+    };
+  }
+  if (event === "typing.started" || event === "typing.stopped") {
+    const actorValue = OptionalNonEmptyStringSchema.parse(raw["sender"]);
+    return {
+      id,
+      type: event,
+      timestamp,
+      conversationId: conversation,
+      ...actorValue === void 0 ? {} : { actor: address(actorValue) },
+      raw
+    };
+  }
+  if (event !== "message.received" && event !== "message.sent" && event !== "message.delivered" && event !== "message.read" && event !== "message.failed") {
+    return void 0;
+  }
+  return {
+    id,
+    type: event,
+    timestamp,
+    message: mapProviderMessage(
+      { ...raw, direction: event === "message.received" ? "inbound" : "outbound", status: eventStatus(event, raw["status"]) },
+      conversation
+    ),
+    raw
+  };
+}
+function blooio(options = {}) {
+  const apiKey = options.apiKey ?? process.env["BLOOIO_API_KEY"];
+  const webhookSecret = options.webhookSecret ?? process.env["BLOOIO_WEBHOOK_SECRET"];
+  const configuredSender = process.env["BLOOIO_FROM_NUMBER"];
+  const sender = options.sender ?? (configuredSender === void 0 ? void 0 : address(configuredSender));
+  const config = {
+    ...options,
+    ...apiKey === void 0 ? {} : { apiKey },
+    ...webhookSecret === void 0 ? {} : { webhookSecret },
+    ...sender === void 0 ? {} : { sender }
+  };
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  const request = async (path, init = {}, requestOptions = {}) => {
+    if (config.apiKey === void 0 || config.apiKey.length === 0) {
+      throw new AuthenticationError("A Blooio API key is required.", {
+        provider: "blooio",
+        code: "missing_api_key"
+      });
+    }
+    let response;
+    try {
+      response = await fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: {
+          authorization: `Bearer ${config.apiKey}`,
+          accept: "application/json",
+          ...init.body === void 0 ? {} : { "content-type": "application/json" },
+          ...init.headers
+        }
+      });
+    } catch (cause) {
+      if (requestOptions.send === true) {
+        throw new AmbiguousDeliveryError(
+          "The Blooio send result is unknown; retry only with the same idempotency key.",
+          { provider: "blooio", code: "ambiguous_delivery", retryable: true, raw: cause }
+        );
+      }
+      throw new ProviderUnavailableError("Could not reach Blooio.", {
+        provider: "blooio",
+        code: "provider_unavailable",
+        retryable: true,
+        raw: cause
+      });
+    }
+    const rawText = await response.text();
+    let raw;
+    try {
+      raw = rawText.length === 0 ? void 0 : JSON.parse(rawText);
+    } catch {
+      raw = rawText;
+    }
+    if (response.ok) return raw ?? {};
+    if (response.status === 404 && requestOptions.notFoundNull === true) return null;
+    const parsedBody = JsonObjectSchema.safeParse(raw);
+    const body = parsedBody.success ? parsedBody.data : {};
+    const message = OptionalNonEmptyStringSchema.parse(body["message"]) ?? OptionalNonEmptyStringSchema.parse(body["error"]) ?? `Blooio request failed with HTTP ${response.status}.`;
+    const code = OptionalNonEmptyStringSchema.parse(body["code"]) ?? `http_${response.status}`;
+    const common = {
+      provider: "blooio",
+      code,
+      statusCode: response.status,
+      raw
+    };
+    if (response.status === 401 || response.status === 403) {
+      throw new AuthenticationError(message, common);
+    }
+    if (response.status === 404) throw new NotFoundError(message, common);
+    if (response.status === 409) throw new ConflictError(message, common);
+    if (response.status === 429) {
+      const retryAfterHeader = response.headers.get("retry-after");
+      const retryAfter = retryAfterHeader === null ? void 0 : Number(retryAfterHeader);
+      throw new RateLimitError(message, {
+        ...common,
+        retryable: true,
+        ...retryAfter !== void 0 && Number.isFinite(retryAfter) ? { retryAfter } : {}
+      });
+    }
+    if (response.status >= 500) {
+      throw new ProviderUnavailableError(message, {
+        ...common,
+        retryable: true
+      });
+    }
+    throw new IMessageSDKError(message, common);
+  };
+  const messages = {
+    async send(input) {
+      const destinations = input.to === void 0 ? [] : "value" in input.to ? [input.to] : input.to;
+      const chatId = input.conversationId ?? destinations.map((recipient) => recipient.value).join(",");
+      const attachments = input.attachments?.map((attachment) => {
+        if (attachment.source.type !== "url") {
+          throw new ValidationError(
+            "Blooio v2 requires attachments to use a publicly accessible URL.",
+            { provider: "blooio", code: "attachment_url_required" }
+          );
+        }
+        return attachment.filename === void 0 ? attachment.source.url : { url: attachment.source.url, name: attachment.filename };
+      });
+      const body = {
+        ...input.text === void 0 ? {} : { text: input.text },
+        ...attachments === void 0 || attachments.length === 0 ? {} : { attachments },
+        ...config.sender === void 0 ? {} : { from_number: config.sender.value },
+        ...input.replyTo === void 0 ? {} : {
+          reply_to: {
+            message_id: input.replyTo.messageId,
+            ...input.replyTo.partIndex === void 0 ? {} : { part_index: input.replyTo.partIndex }
+          }
+        }
+      };
+      const raw = await request(
+        `/chats/${encodePath(chatId)}/messages`,
+        {
+          method: "POST",
+          ...input.idempotencyKey === void 0 ? {} : { headers: { "idempotency-key": input.idempotencyKey } },
+          body: JSON.stringify(body)
+        },
+        { send: true }
+      );
+      const response = raw ?? {};
+      const providerMessageId = OptionalNonEmptyStringSchema.parse(
+        response["message_id"]
+      );
+      if (providerMessageId === void 0) {
+        throw new IMessageSDKError("Blooio did not return a message ID.", {
+          provider: "blooio",
+          code: "invalid_provider_response",
+          raw: response
+        });
+      }
+      const actualConversationId = OptionalNonEmptyStringSchema.parse(response["group_id"]) ?? chatId;
+      const providerStatus = OptionalNonEmptyStringSchema.parse(
+        response["status"]
+      );
+      const recipients = input.to === void 0 ? participantValues(response["participants"]).map(address) : destinations;
+      return {
+        providerMessageId,
+        conversationId: actualConversationId,
+        direction: "outbound",
+        sender: config.sender ?? address("unknown"),
+        recipients,
+        text: input.text ?? "",
+        attachments: input.attachments?.map((attachment) => {
+          const url = attachment.source.type === "url" ? attachment.source.url : void 0;
+          return {
+            kind: attachment.kind,
+            ...url === void 0 ? {} : { url },
+            ...attachment.filename === void 0 ? {} : { filename: attachment.filename },
+            ...attachment.contentType === void 0 ? {} : { contentType: attachment.contentType },
+            raw: attachment
+          };
+        }) ?? [],
+        ...input.replyTo === void 0 ? {} : { replyTo: input.replyTo },
+        service: "imessage",
+        status: mapStatus(response["status"]),
+        ...providerStatus === void 0 ? {} : { providerStatus },
+        createdAt: /* @__PURE__ */ new Date(),
+        raw: response
+      };
+    },
+    async get(message) {
+      const raw = await request(
+        `/chats/${encodePath(message.conversationId)}/messages/${encodePath(message.messageId)}`,
+        {},
+        { notFoundNull: true }
+      );
+      return raw === null ? null : mapProviderMessage(raw, message.conversationId, config.sender);
+    },
+    async getStatus(message) {
+      const raw = await request(
+        `/chats/${encodePath(message.conversationId)}/messages/${encodePath(message.messageId)}/status`,
+        {},
+        { notFoundNull: true }
+      );
+      if (raw === null) return null;
+      const providerStatus = OptionalNonEmptyStringSchema.parse(raw["status"]);
+      const sentAt = dateValue(raw["time_sent"]);
+      const deliveredAt = dateValue(raw["time_delivered"]);
+      const error = OptionalNonEmptyStringSchema.parse(raw["error"]);
+      return {
+        messageId: OptionalNonEmptyStringSchema.parse(raw["message_id"]) ?? message.messageId,
+        conversationId: OptionalNonEmptyStringSchema.parse(raw["chat_id"]) ?? message.conversationId,
+        status: mapStatus(providerStatus),
+        ...providerStatus === void 0 ? {} : { providerStatus },
+        service: mapService(raw["protocol"]),
+        ...sentAt === void 0 ? {} : { sentAt },
+        ...deliveredAt === void 0 ? {} : { deliveredAt },
+        ...error === void 0 ? {} : { error },
+        raw
+      };
+    }
+  };
+  const conversations = {
+    async open(input) {
+      const id = conversationId(input);
+      return {
+        providerConversationId: id,
+        participants: input.participants,
+        raw: { chat_id: id, resolved: false }
+      };
+    },
+    async get(id) {
+      const raw = await request(
+        `/chats/${encodePath(id)}`,
+        {},
+        { notFoundNull: true }
+      );
+      if (raw === null) return null;
+      const participantIdentifiers = participantValues(raw["participants"]);
+      const groupMembers = raw["is_group"] === true || id.startsWith("grp_") ? await request(
+        `/groups/${encodePath(id)}/members?limit=100`,
+        {},
+        { notFoundNull: true }
+      ) : null;
+      const groupMemberIdentifiers = groupMembers === null ? [] : participantValues(groupMembers["members"]);
+      const parsedContact = JsonObjectSchema.safeParse(raw["contact"]);
+      const contact = parsedContact.success ? parsedContact.data : void 0;
+      const contactIdentifier = contact === void 0 ? void 0 : OptionalNonEmptyStringSchema.parse(contact["identifier"]);
+      const participants = groupMemberIdentifiers.length > 0 ? groupMemberIdentifiers.map(address) : participantIdentifiers.length > 0 ? participantIdentifiers.map(address) : contactIdentifier === void 0 ? [address(OptionalNonEmptyStringSchema.parse(raw["id"]) ?? id)] : [address(contactIdentifier)];
+      const createdAt = dateValue(raw["first_message_time"]);
+      return {
+        providerConversationId: OptionalNonEmptyStringSchema.parse(raw["id"]) ?? id,
+        participants,
+        ...createdAt === void 0 ? {} : { createdAt },
+        raw
+      };
+    },
+    async markRead(id) {
+      await request(`/chats/${encodePath(id)}/read`, { method: "POST" });
+    }
+  };
+  const react = async (action, input) => {
+    await request(
+      `/chats/${encodePath(input.conversationId)}/messages/${encodePath(input.messageId)}/reactions`,
+      {
+        method: "POST",
+        body: JSON.stringify({ reaction: `${action}${input.reaction}` })
+      }
+    );
+  };
+  return defineProvider({
+    name: "blooio",
+    capabilities: BLOOIO_CAPABILITIES,
+    messages,
+    conversations,
+    reactions: {
+      async add(input) {
+        await react("+", input);
+      },
+      async remove(input) {
+        await react("-", input);
+      }
+    },
+    typing: {
+      async start(id) {
+        await request(`/chats/${encodePath(id)}/typing`, { method: "POST" });
+      },
+      async stop(id) {
+        await request(`/chats/${encodePath(id)}/typing`, { method: "DELETE" });
+      }
+    },
+    webhooks: {
+      async verify(webhookRequest) {
+        if (config.webhookSecret === void 0) return false;
+        const header = webhookRequest.headers.get("x-blooio-signature");
+        if (header === null) return false;
+        const parsed = parseSignature(header);
+        if (parsed === void 0) return false;
+        const timestamp = Number(parsed.timestamp);
+        if (!Number.isFinite(timestamp)) return false;
+        const age = Math.abs(Math.floor(Date.now() / 1e3) - timestamp);
+        if (age > DEFAULT_WEBHOOK_TOLERANCE_SECONDS) return false;
+        const rawBody = await webhookRequest.text();
+        const expected = await hmacSha256(
+          config.webhookSecret,
+          `${parsed.timestamp}.${rawBody}`
+        );
+        return parsed.signatures.some(
+          (signature) => constantTimeEqual(expected, signature.toLowerCase())
+        );
+      },
+      async parse(webhookRequest) {
+        const body = await webhookRequest.json();
+        const values = Array.isArray(body) ? body : [body];
+        return values.flatMap((value) => {
+          const parsedValue = JsonObjectSchema.safeParse(value);
+          if (!parsedValue.success) return [];
+          const event = mapWebhookEvent(parsedValue.data);
+          return event === void 0 ? [] : [event];
+        });
+      }
+    },
+    numbers: {
+      async list() {
+        const response = await request("/me/numbers");
+        const values = Array.isArray(response?.["numbers"]) ? response["numbers"] : [];
+        return values.flatMap((value) => {
+          const parsedValue = JsonObjectSchema.safeParse(value);
+          if (!parsedValue.success) return [];
+          const item = parsedValue.data;
+          const phoneNumber = OptionalNonEmptyStringSchema.parse(
+            item["phone_number"]
+          );
+          if (phoneNumber === void 0) return [];
+          const lastActive = dateValue(item["last_active"]);
+          const parsedPlanKind = PlanKindSchema.safeParse(item["plan_kind"]);
+          return [
+            {
+              phoneNumber,
+              active: item["is_active"] === true,
+              ...lastActive === void 0 ? {} : { lastActive },
+              ...parsedPlanKind.success ? { planKind: parsedPlanKind.data } : {},
+              raw: item
+            }
+          ];
+        });
+      }
+    }
+  });
+}
+
+export { BLOOIO_CAPABILITIES, blooio };
+//# sourceMappingURL=blooio.js.map
+//# sourceMappingURL=blooio.js.map