@christian-ek/sweego 0.1.0

package/README.md

@@ -0,0 +1,357 @@
+# Sweego Convex Component
+
+[![npm version](https://badge.fury.io/js/@christian-ek%2Fsweego.svg)](https://www.npmjs.com/package/@christian-ek/sweego)
+
+A [Convex component](https://www.convex.dev/components) for sending
+**transactional email and SMS** through [Sweego](https://www.sweego.io), with
+durable delivery and webhook-based delivery tracking.
+
+Features:
+
+- **Email + SMS** through Sweego's unified `/send` API, plus personalized
+  **bulk email** (`/send/bulk/email`).
+- **Durable execution** — sends run in a [workpool](https://www.convex.dev/components/workpool)
+  and are retried automatically through transient failures (429s, 5xx, network
+  blips). Permanent failures (4xx) are recorded without futile retries.
+- **Delivery tracking** — verifies Sweego's HMAC-SHA256 webhook signatures and
+  maintains per-recipient delivery state (delivered / bounced / opened /
+  clicked / complained / unsubscribed; SMS undelivered / stopped / clicked).
+- **Templates, attachments, custom headers, List-Unsubscribe, expiry, and
+  campaign metadata** — the full send surface.
+- **Event callbacks** — register a mutation that runs whenever a delivery event
+  arrives.
+- **Status, cancellation, and retention cleanup** out of the box.
+
+No `svix` dependency and no Sweego SDK — the component calls the REST API with
+`fetch` and verifies signatures with the Web Crypto API.
+
+## Installation
+
+```bash
+npm install @christian-ek/sweego
+```
+
+Create a [Sweego](https://app.sweego.io) account, verify a sending domain (and
+set up an SMS channel if you want SMS), and create an API key. Set it in your
+Convex deployment:
+
+```bash
+npx convex env set SWEEGO_API_KEY swg_xxxxxxxx
+```
+
+Add the component to your app in `convex/convex.config.ts`:
+
+```ts
+import { defineApp } from "convex/server";
+import sweego from "@christian-ek/sweego/convex.config";
+
+const app = defineApp();
+app.use(sweego);
+
+export default app;
+```
+
+## Get started
+
+```ts
+// convex/sweego.ts
+import { components } from "./_generated/api";
+import { Sweego } from "@christian-ek/sweego";
+import { internalMutation } from "./_generated/server";
+
+export const sweego = new Sweego(components.sweego, {});
+
+export const sendWelcome = internalMutation({
+  handler: async (ctx) => {
+    await sweego.sendEmail(ctx, {
+      from: "Acme <hello@yourdomain.com>",
+      to: "user@example.com",
+      subject: "Welcome!",
+      text: "Welcome to Acme!", // Sweego requires text (or a template)
+      html: "<h1>Welcome to Acme</h1>", // html is supplementary
+    });
+  },
+});
+```
+
+`sendEmail` (and `sendSms` / `sendBulkEmail`) can be called from a **mutation or
+an action**. It enqueues the message and returns a `MessageId` immediately; the
+component delivers it durably in the background.
+
+`from`/`to`/`cc`/`bcc`/`replyTo` accept either `"Name <email>"` strings or
+`{ email, name }` objects.
+
+## Sending SMS
+
+SMS goes through the same component. Sweego requires a `campaignType`
+(`"transac"` or `"market"`), and a region for each recipient:
+
+```ts
+await sweego.sendSms(ctx, {
+  to: "+33600000000",
+  region: "FR", // ISO-3166 alpha-2; applied to bare-string recipients
+  campaignType: "transac",
+  senderId: "Acme", // 3–11 chars; required if you have multiple sender IDs
+  text: "Your code is 123456",
+});
+```
+
+You can also pass structured recipients: `to: [{ num: "+1...", region: "US" }]`.
+
+Estimate cost/segments before sending (from an action):
+
+```ts
+const estimate = await sweego.estimateSms(ctx, {
+  campaign_type: "transac",
+  message_txt: "Your code is 123456",
+  recipients: [{ num: "+33600000000", region: "FR" }],
+});
+```
+
+## Templates
+
+Reference a Sweego-hosted template by id and pass `variables` for
+`{{ placeholder }}` interpolation:
+
+```ts
+await sweego.sendEmail(ctx, {
+  from: "Acme <hello@yourdomain.com>",
+  to: "user@example.com",
+  subject: "Your receipt",
+  templateId: "your-template-uuid",
+  variables: { name: "Ada", amount: 42 },
+});
+```
+
+> You cannot combine `templateId` with `html`. On a single `/send`, `variables`
+> are only applied for a single recipient — use `sendBulkEmail` for
+> per-recipient personalization.
+
+## Bulk personalized email
+
+```ts
+await sweego.sendBulkEmail(ctx, {
+  from: "Acme <hello@yourdomain.com>",
+  subject: "Newsletter",
+  templateId: "your-template-uuid",
+  recipients: [
+    { email: "alice@example.com", variables: { name: "Alice" } },
+    { email: "bob@example.com", variables: { name: "Bob" } },
+  ],
+});
+```
+
+Bulk sends require ≥2 recipients and do not support `cc`/`bcc`/`replyTo`.
+
+## Attachments, headers, and more
+
+```ts
+await sweego.sendEmail(ctx, {
+  from: "Acme <hello@yourdomain.com>",
+  to: "user@example.com",
+  subject: "Your invoice",
+  text: "Your invoice is attached.",
+  html: "<p>See attached.</p>",
+  attachments: [
+    { filename: "invoice.pdf", content: base64Pdf /* base64-encoded bytes */ },
+  ],
+  headers: { "Ref-1": "643524" }, // omit the X- prefix; max 5 headers
+  listUnsub: { method: "one-click", value: "<mailto:unsub@acme.com>,<https://acme.com/u>" },
+  expires: "2026-07-26T19:30:00+02:00", // or a delta like "1 day"
+  campaignType: "transac",
+  campaignTags: ["welcome"],
+});
+```
+
+> **Attachment size:** attachment bytes are stored inline with the message, so
+> the whole message must fit within Convex's ~1 MiB document limit. Keep
+> attachments small; host large files elsewhere and link to them.
+
+## Tracking status
+
+`sendEmail`/`sendSms` return a branded `MessageId`. Use it to:
+
+```ts
+const status = await sweego.status(ctx, messageId);
+// {
+//   status: "queued" | "sent" | "failed" | "cancelled",
+//   channel, transactionId, errorMessage, creditLeft,
+//   deliveries: [
+//     { swgUid, recipientKey, status, delivered, bounced, opened, clicked, ... }
+//   ],
+// }
+
+const full = await sweego.get(ctx, messageId); // full message + deliveries
+const cancelled = await sweego.cancel(ctx, messageId); // true if not yet sent
+```
+
+A message produces one **delivery** per recipient (Sweego returns one `swg_uid`
+per recipient), each tracked independently.
+
+## Webhooks (delivery events)
+
+Sending alone won't tell you whether a message was delivered, bounced, opened,
+or clicked — for that, set up a webhook.
+
+1. Mount an HTTP route in `convex/http.ts`:
+
+   ```ts
+   import { httpRouter } from "convex/server";
+   import { httpAction } from "./_generated/server";
+   import { sweego } from "./sweego";
+
+   const http = httpRouter();
+   http.route({
+     path: "/sweego-webhook",
+     method: "POST",
+     handler: httpAction(async (ctx, req) => sweego.handleSweegoWebhook(ctx, req)),
+   });
+   export default http;
+   ```
+
+   Your endpoint is then `https://<your-deployment>.convex.site/sweego-webhook`.
+
+2. In the Sweego dashboard, create a webhook pointing at that URL and select the
+   email/SMS events you care about.
+
+3. Copy the webhook's **signing secret** and set it in your deployment:
+
+   ```bash
+   npx convex env set SWEEGO_WEBHOOK_SECRET <secret>
+   ```
+
+The component verifies Sweego's `webhook-id` / `webhook-timestamp` /
+`webhook-signature` HMAC-SHA256 signature against the raw request body before
+processing anything. Set `webhookToleranceSeconds` in the options to also reject
+stale (replayed) requests.
+
+### Reacting to events
+
+Register an `onEvent` mutation that runs whenever a delivery event arrives:
+
+```ts
+import { components } from "./_generated/api";
+import { internal } from "./_generated/api";
+import { Sweego, vOnEventArgs } from "@christian-ek/sweego";
+import { internalMutation } from "./_generated/server";
+
+export const sweego = new Sweego(components.sweego, {
+  onEvent: internal.sweego.handleEvent,
+});
+
+export const handleEvent = internalMutation({
+  args: vOnEventArgs, // { messageId, swgUid, event }
+  handler: async (ctx, { messageId, swgUid, event }) => {
+    // event.eventType e.g. "delivered", "hard_bounce", "email_opened",
+    //   "sms_undelivered", ...; event.raw holds the full Sweego payload.
+    console.log(messageId, swgUid, event.eventType);
+  },
+});
+```
+
+> With `vOnEventArgs`, `event` is loosely typed. For a fully-typed `event`
+> (`SweegoEvent`), define the handler with `sweego.defineEventHandler(async (ctx, { messageId, swgUid, event }) => { ... })`
+> instead — it registers an internal mutation with the right argument types.
+
+> No webhooks yet? `sweego.refreshStatus(ctx, messageId)` (from an action) polls
+> Sweego's logs and updates delivery state on demand.
+
+## Options
+
+```ts
+new Sweego(components.sweego, {
+  apiKey,                   // default: process.env.SWEEGO_API_KEY
+  webhookSecret,            // default: process.env.SWEEGO_WEBHOOK_SECRET
+  provider,                 // default: "sweego"
+  testMode,                 // default: false — see below
+  initialBackoffMs,         // default: 30000
+  retryAttempts,            // default: 5
+  webhookToleranceSeconds,  // default: 0 (disabled)
+  onEvent,                  // your event-handler mutation reference
+});
+```
+
+**`testMode`** — when `true`, email sends are submitted with Sweego's `dry-run`
+(validated by Sweego but never delivered) and SMS sends use BAT test mode. It is
+**off by default**: because `dry-run` produces no real delivery and no webhooks,
+you must opt in. You can also set `dryRun: true` (email) or `bat: true` (SMS) on
+an individual send.
+
+## Data retention
+
+The component retains messages, deliveries, and raw events. Clean them up on a
+schedule with the built-in mutations:
+
+```ts
+// convex/crons.ts
+import { cronJobs } from "convex/server";
+import { components, internal } from "./_generated/api";
+import { internalMutation } from "./_generated/server";
+import { v } from "convex/values";
+
+const crons = cronJobs();
+crons.interval(
+  "Clean up old Sweego messages",
+  { hours: 1 },
+  internal.crons.cleanupSweego,
+);
+
+const ONE_WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+export const cleanupSweego = internalMutation({
+  args: {},
+  returns: v.null(),
+  handler: async (ctx) => {
+    await ctx.scheduler.runAfter(0, components.sweego.lib.cleanupOldMessages, {
+      olderThan: ONE_WEEK_MS,
+    });
+    await ctx.scheduler.runAfter(
+      0,
+      components.sweego.lib.cleanupAbandonedMessages,
+      { olderThan: 4 * ONE_WEEK_MS },
+    );
+  },
+});
+
+export default crons;
+```
+
+`cleanupOldMessages` deletes finalized messages (and their deliveries/events)
+older than the cutoff (default 7 days); `cleanupAbandonedMessages` clears
+never-finalized messages (default 30 days).
+
+## Notes & gotchas
+
+- **Email body:** Sweego requires **`text`** (the plain-text part) *or* a
+  **`templateId`**. `html` is supplementary — sending `html` **alone** is
+  rejected with `Either 'message-txt' or 'template-id' is required`. The
+  component enforces this locally (it throws before sending), so you get a clear
+  error instead of a 422. Always include `text` alongside `html`.
+- **Auth:** Sweego authenticates with an `Api-Key:` header (not
+  `Authorization: Bearer`) — handled for you.
+- **Field names:** Sweego's API uses hyphenated keys (`message-html`,
+  `template-id`, `campaign-type`, …). The component maps your camelCase options
+  to the exact wire format.
+- **SMS:** there's no bulk SMS endpoint — multi-recipient SMS goes through one
+  `/send` call. `campaignType` is required, and each recipient's `region` must
+  match the number's country (e.g. `+46…` → `SE`) or Sweego 422s. SMS
+  `variables` are shared across all recipients.
+- **Senders must be authorized by Sweego (account-level):** the email `from`
+  must be on a domain verified for your API key, and SMS sender IDs must be
+  registered — some regions (e.g. Sweden) *require* a verified alphanumeric
+  sender ID and reject the default numeric sender, and US/Canada require a
+  Toll-Free Number passed as `senderId`. These are dashboard settings; the
+  component surfaces Sweego's rejection but can't pre-validate them.
+- **Open/click tracking** is enabled per-domain in the Sweego dashboard, not per
+  send. Tracking events can be delayed up to ~10 minutes.
+- **Rate limiting:** Sweego does not publish API limits, so the component bounds
+  throughput via the send workpool's parallelism and retries 429s with backoff
+  rather than guessing a fixed rate.
+- **Delivery is at-least-once.** Sweego's `/send` exposes no idempotency key, so
+  the component never retries once a request has been accepted (only transient
+  failures *before* acceptance are retried). In the rare event the process dies
+  between Sweego accepting a request and the component recording it, a retry
+  could re-send. This window is kept as small as possible.
+
+## License
+
+Apache-2.0

package/dist/client/_generated/_ignore.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=_ignore.d.ts.map

package/dist/client/_generated/_ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.d.ts","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":""}

package/dist/client/_generated/_ignore.js

@@ -0,0 +1,3 @@
+"use strict";
+// This is only here so convex-test can detect a _generated folder
+//# sourceMappingURL=_ignore.js.map

package/dist/client/_generated/_ignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_ignore.js","sourceRoot":"","sources":["../../../src/client/_generated/_ignore.ts"],"names":[],"mappings":";AAAA,kEAAkE"}

package/dist/client/index.d.ts

@@ -0,0 +1,282 @@
+import { type FunctionReference, type FunctionVisibility, type GenericDataModel, type GenericMutationCtx } from "convex/server";
+import { type VString } from "convex/values";
+import type { ComponentApi } from "../component/_generated/component.js";
+import { type ActionCtx, type Attachment, type EmailAddress, type ListUnsub, type MutationCtx, type QueryCtx, type SmsCampaignType, type SmsRecipient, type SweegoEvent, type Variables } from "../component/shared.js";
+export type SweegoComponent = ComponentApi;
+export type MessageId = string & {
+    __isSweegoMessageId: true;
+};
+export declare const vMessageId: VString<MessageId>;
+export { vSweegoEvent } from "../component/shared.js";
+export type { Attachment, Channel, DeliveryStatus, EmailAddress, ListUnsub, SendStatus, SmsCampaignType, SmsRecipient, SweegoEvent, Variables, } from "../component/shared.js";
+export declare const vOnEventArgs: {
+    messageId: VString<MessageId, "required">;
+    swgUid: VString<string, "required">;
+    event: import("convex/values").VAny<any, "required", string>;
+};
+type EventHandlerRef = FunctionReference<"mutation", FunctionVisibility, {
+    messageId: MessageId;
+    swgUid: string;
+    event: SweegoEvent;
+}>;
+export type SweegoOptions = {
+    /** Sweego API key. Defaults to `process.env.SWEEGO_API_KEY`. */
+    apiKey?: string;
+    /**
+     * Webhook signing secret (from the Sweego dashboard). Defaults to
+     * `process.env.SWEEGO_WEBHOOK_SECRET`. Required only to verify webhooks.
+     */
+    webhookSecret?: string;
+    /** The Sweego provider. Defaults to "sweego". */
+    provider?: string;
+    /**
+     * When true, email sends are submitted with `dry-run` (Sweego validates but
+     * does not send) and SMS sends use BAT test mode. Defaults to false.
+     */
+    testMode?: boolean;
+    /** Initial retry backoff in ms for the send workpool. Defaults to 30000. */
+    initialBackoffMs?: number;
+    /** Max send attempts before giving up. Defaults to 5. */
+    retryAttempts?: number;
+    /**
+     * Reject webhooks whose timestamp differs from now by more than this many
+     * seconds (replay protection). Defaults to 300 (5 minutes), per the Standard
+     * Webhooks recommendation. Set to 0 to disable the timestamp check (not
+     * recommended — webhook-id deduplication still applies either way).
+     */
+    webhookToleranceSeconds?: number;
+    /** A mutation in your app to run after each delivery event. */
+    onEvent?: EventHandlerRef | null;
+};
+type ResolvedConfig = {
+    provider: string;
+    testMode: boolean;
+    initialBackoffMs: number;
+    retryAttempts: number;
+    webhookToleranceSeconds: number;
+};
+type AddressInput = string | EmailAddress;
+type CommonEmailOptions = {
+    /** Plain-text body. Required unless `templateId` is set. */
+    text?: string;
+    /**
+     * Supplementary HTML body. Sweego rejects an email sent with `html` but no
+     * `text`/`templateId` — always pair `html` with `text` (or use a template).
+     */
+    html?: string;
+    templateId?: string;
+    attachments?: Attachment[];
+    headers?: Record<string, string>;
+    listUnsub?: ListUnsub;
+    expires?: string;
+    campaignId?: string;
+    campaignTags?: string[];
+    campaignType?: "market" | "newsletter" | "transac";
+    compressStyle?: boolean;
+    forceInlineStyle?: boolean;
+    dryRun?: boolean;
+};
+export type SendEmailOptions = CommonEmailOptions & {
+    from: AddressInput;
+    to: AddressInput | AddressInput[];
+    cc?: AddressInput | AddressInput[];
+    bcc?: AddressInput | AddressInput[];
+    replyTo?: AddressInput;
+    subject?: string;
+    /** Template variables. Only applied for a single recipient on /send. */
+    variables?: Variables;
+};
+export type BulkEmailRecipient = {
+    email: string;
+    name?: string;
+    variables?: Variables;
+};
+export type SendBulkEmailOptions = CommonEmailOptions & {
+    from: AddressInput;
+    subject?: string;
+    /** At least 2 recipients; each may carry its own `variables`. */
+    recipients: Array<BulkEmailRecipient | string>;
+};
+export type SendSmsOptions = {
+    to: SmsRecipient | SmsRecipient[] | string | string[];
+    /** Default ISO region (e.g. "FR") for recipients given as bare strings. */
+    region?: string;
+    text?: string;
+    templateId?: string;
+    variables?: Variables;
+    /** REQUIRED by Sweego for SMS. */
+    campaignType: SmsCampaignType;
+    senderId?: string;
+    shortenUrls?: boolean;
+    shortenWithProtocol?: boolean;
+    /** BAT test mode. */
+    bat?: boolean;
+    campaignId?: string;
+};
+export declare class Sweego {
+    component: SweegoComponent;
+    readonly config: ResolvedConfig;
+    private readonly _apiKey?;
+    private readonly _webhookSecret?;
+    readonly onEvent?: EventHandlerRef | null;
+    /**
+     * @param component The mounted component, e.g. `components.sweego`.
+     * @param options {@link SweegoOptions}.
+     */
+    constructor(component: SweegoComponent, options?: SweegoOptions);
+    private get apiKey();
+    private get webhookSecret();
+    private runtimeConfig;
+    /**
+     * Enqueue an email. It is sent durably (with retries) by the component's
+     * workpool. Returns the {@link MessageId} you can use to check status,
+     * cancel, or correlate webhook events.
+     */
+    sendEmail(ctx: MutationCtx | ActionCtx, options: SendEmailOptions): Promise<MessageId>;
+    /**
+     * Enqueue a personalized bulk email (Sweego's `/send/bulk/email`). Each
+     * recipient may carry its own `variables`. No cc/bcc/replyTo support.
+     */
+    sendBulkEmail(ctx: MutationCtx | ActionCtx, options: SendBulkEmailOptions): Promise<MessageId>;
+    /** Enqueue an SMS (Sweego's `/send` with `channel: "sms"`). */
+    sendSms(ctx: MutationCtx | ActionCtx, options: SendSmsOptions): Promise<MessageId>;
+    private enqueue;
+    /** Aggregate status of a message plus per-recipient delivery state. */
+    status(ctx: QueryCtx | MutationCtx | ActionCtx, messageId: MessageId): Promise<{
+        channel: "email" | "sms";
+        creditLeft: string | null;
+        deliveries: Array<{
+            bounced: boolean;
+            channel: "email" | "sms";
+            clicked: boolean;
+            complained: boolean;
+            delivered: boolean;
+            errorMessage: string | null;
+            lastEventType: string | null;
+            opened: boolean;
+            recipientKey: string;
+            softBounced: boolean;
+            status: "pending" | "sent" | "delivered" | "soft_bounced" | "bounced" | "undelivered" | "stopped";
+            stopped: boolean;
+            swgUid: string;
+            unsubscribed: boolean;
+        }>;
+        errorMessage: string | null;
+        status: "queued" | "sent" | "failed" | "cancelled";
+        transactionId: string | null;
+    } | null>;
+    /** The full stored message plus its deliveries. */
+    get(ctx: QueryCtx | MutationCtx | ActionCtx, messageId: MessageId): Promise<{
+        _creationTime: number;
+        _id: string;
+        attachments?: Array<{
+            content: string;
+            contentId?: string;
+            disposition?: "attachment" | "inline";
+            filename: string;
+            isRelated?: boolean;
+        }>;
+        bat?: boolean;
+        bcc?: Array<{
+            email: string;
+            name?: string;
+        }>;
+        bulk: boolean;
+        campaignId?: string;
+        campaignTags?: Array<string>;
+        campaignType?: string;
+        cc?: Array<{
+            email: string;
+            name?: string;
+        }>;
+        channel: "email" | "sms";
+        compressStyle?: boolean;
+        creditLeft?: string;
+        deliveries: Array<{
+            bounced: boolean;
+            channel: "email" | "sms";
+            clicked: boolean;
+            complained: boolean;
+            delivered: boolean;
+            errorMessage: string | null;
+            lastEventType: string | null;
+            opened: boolean;
+            recipientKey: string;
+            softBounced: boolean;
+            status: "pending" | "sent" | "delivered" | "soft_bounced" | "bounced" | "undelivered" | "stopped";
+            stopped: boolean;
+            swgUid: string;
+            unsubscribed: boolean;
+        }>;
+        dryRun?: boolean;
+        emailRecipients?: Array<{
+            email: string;
+            name?: string;
+            variables?: Record<string, string | number | boolean>;
+        }>;
+        errorMessage?: string;
+        expires?: string;
+        finalizedAt: number;
+        forceInlineStyle?: boolean;
+        from?: {
+            email: string;
+            name?: string;
+        };
+        headers?: Record<string, string>;
+        html?: string;
+        listUnsub?: {
+            method?: "mailto" | "one-click";
+            value: string;
+        };
+        provider: string;
+        replyTo?: {
+            email: string;
+            name?: string;
+        };
+        senderId?: string;
+        shortenUrls?: boolean;
+        shortenWithProtocol?: boolean;
+        smsRecipients?: Array<{
+            num: string;
+            region: string;
+        }>;
+        status: "queued" | "sent" | "failed" | "cancelled";
+        subject?: string;
+        templateId?: string;
+        text?: string;
+        transactionId?: string;
+        variables?: Record<string, string | number | boolean>;
+    } | null>;
+    /**
+     * Cancel a message if it has not yet been handed to Sweego. Returns true if
+     * it was cancelled, false if it had already been sent.
+     */
+    cancel(ctx: MutationCtx | ActionCtx, messageId: MessageId): Promise<boolean>;
+    /** Estimate the cost/segments of an SMS send (Sweego `/sms/estimate`). */
+    estimateSms(ctx: ActionCtx, body: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Poll Sweego's logs to refresh delivery status without webhooks. Returns the
+     * number of deliveries updated. Prefer webhooks where possible.
+     */
+    refreshStatus(ctx: ActionCtx, messageId: MessageId): Promise<number>;
+    /**
+     * Verify and handle a Sweego webhook. Mount this on an HTTP route. Verifies
+     * the HMAC signature against the raw body, then updates delivery state and
+     * dispatches your `onEvent` handler.
+     */
+    handleSweegoWebhook(ctx: MutationCtx | ActionCtx, request: Request): Promise<Response>;
+    /**
+     * Helper to define your `onEvent` mutation with the right argument validator.
+     * Equivalent to declaring an `internalMutation` with {@link vOnEventArgs}.
+     */
+    defineEventHandler<DataModel extends GenericDataModel>(handler: (ctx: GenericMutationCtx<DataModel>, args: {
+        messageId: MessageId;
+        swgUid: string;
+        event: SweegoEvent;
+    }) => Promise<void>): import("convex/server").RegisteredMutation<"internal", {
+        messageId: MessageId;
+        swgUid: string;
+        event: SweegoEvent;
+    }, Promise<void>>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"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"}