qarpeo 0.0.0-alpha.10

package/dist/runtime/server/utils/mail.mjs

@@ -0,0 +1,366 @@
+import { resolveRuntimeBinding } from "../../bindings.mjs";
+import { sendEmail } from "../../email.mjs";
+import { useQueue } from "../../queue.mjs";
+import { renderEmailTemplate, renderMarkdownEmail } from "./email-templates.mjs";
+import {
+  buildListUnsubscribeHeaders,
+  isEmailSuppressed
+} from "./mail-suppression.mjs";
+function getSharedMailbox() {
+  return globalThis.__qarpeo_dev_mailbox__ ||= [];
+}
+export function getDevMailbox() {
+  return [...getSharedMailbox()];
+}
+export function getDevEmail(id) {
+  return getSharedMailbox().find((m) => m.id === id);
+}
+export function clearDevMailbox() {
+  getSharedMailbox().length = 0;
+}
+export function recordEmailOpen(id) {
+  const email = getDevEmail(id);
+  if (!email) return false;
+  email.opened = true;
+  email.openedAt = email.openedAt || Date.now();
+  email.openCount = (email.openCount || 0) + 1;
+  return true;
+}
+export function recordEmailClick(id, url) {
+  const email = getDevEmail(id);
+  if (!email) return false;
+  email.clicks = email.clicks || [];
+  email.clicks.push({ url, timestamp: Date.now() });
+  return true;
+}
+export function recordEmailBounce(id, reason = "Delivery failure") {
+  const email = getDevEmail(id);
+  if (!email) return false;
+  email.bounced = true;
+  email.bounceReason = reason;
+  return true;
+}
+export function injectEmailTracking(html, options) {
+  let result = html;
+  const base = options.baseUrl.replace(/\/$/, "");
+  if (options.clicks !== false) {
+    result = result.replace(/<a\b([^>]*)\bhref=["']([^"']+)["']([^>]*)>/gi, (match, prefix, href, suffix) => {
+      if (/^(?:mailto:|tel:|#|javascript:)/i.test(href) || href.includes("/__qarpeo/mail/track/")) {
+        return match;
+      }
+      const trackUrl = `${base}/__qarpeo/mail/track/click/${encodeURIComponent(options.messageId)}?url=${encodeURIComponent(href)}`;
+      return `<a${prefix}href="${trackUrl}"${suffix}>`;
+    });
+  }
+  if (options.opens !== false) {
+    const pixelUrl = `${base}/__qarpeo/mail/track/open/${encodeURIComponent(options.messageId)}`;
+    const pixelHtml = `<img src="${pixelUrl}" width="1" height="1" alt="" style="display:none !important; max-height:1px; max-width:1px; border:0; outline:none;" />`;
+    if (result.includes("</body>")) {
+      result = result.replace("</body>", `${pixelHtml}</body>`);
+    } else {
+      result += pixelHtml;
+    }
+  }
+  return result;
+}
+export async function deliverMailDirect(options, event) {
+  const { provider, apiKey, from, to, subject, html, text, replyTo, cc, bcc, headers, messageId } = options;
+  if (provider === "resend") {
+    if (!apiKey) {
+      throw new Error("[qarpeo:mail] Missing Resend API key. Set mail.apiKey or RESEND_API_KEY.");
+    }
+    const res = await fetch("https://api.resend.com/emails", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        from,
+        to: Array.isArray(to) ? to : [to],
+        subject,
+        html,
+        text,
+        reply_to: replyTo,
+        cc,
+        bcc
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`[qarpeo:mail] Resend delivery failed: ${err}`);
+    }
+    const json = await res.json();
+    return json.id || messageId;
+  }
+  if (provider === "postmark") {
+    if (!apiKey) {
+      throw new Error(
+        "[qarpeo:mail] Missing Postmark token. Set mail.apiKey or POSTMARK_SERVER_TOKEN."
+      );
+    }
+    const res = await fetch("https://api.postmarkapp.com/email", {
+      method: "POST",
+      headers: {
+        "X-Postmark-Server-Token": apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        From: from,
+        To: Array.isArray(to) ? to.join(", ") : to,
+        Subject: subject,
+        HtmlBody: html,
+        TextBody: text,
+        ReplyTo: replyTo,
+        Cc: cc ? Array.isArray(cc) ? cc.join(", ") : cc : void 0,
+        Bcc: bcc ? Array.isArray(bcc) ? bcc.join(", ") : bcc : void 0
+      })
+    });
+    if (!res.ok) {
+      const err = await res.text();
+      throw new Error(`[qarpeo:mail] Postmark delivery failed: ${err}`);
+    }
+    const json = await res.json();
+    return json.MessageID || messageId;
+  }
+  const cfResult = await sendEmail(
+    {
+      from,
+      to,
+      subject,
+      html,
+      text,
+      replyTo,
+      cc,
+      bcc,
+      headers
+    },
+    event
+  );
+  return cfResult.id || cfResult.messageId || messageId;
+}
+export async function sendMail(request, event) {
+  const procEnv = globalThis.process?.env || {};
+  const isDev = procEnv.NODE_ENV !== "production";
+  const runtimeConfig = globalThis.__NUXT_RUNTIME_CONFIG__ || {};
+  const mailConfig = runtimeConfig.qarpeo?.mail || {};
+  const branding = {
+    brandColor: mailConfig.branding?.brandColor,
+    companyName: mailConfig.branding?.companyName || runtimeConfig.public?.qarpeo?.site?.name,
+    logoUrl: mailConfig.branding?.logoUrl,
+    supportEmail: mailConfig.branding?.supportEmail
+  };
+  const from = request.from || mailConfig.from || procEnv.QARPEO_EMAIL_FROM || procEnv.EMAIL_FROM || "noreply@qarpeo.local";
+  let html = request.html || "";
+  let text = request.text || "";
+  let subject = request.subject || "";
+  if (request.markdown) {
+    const mdRendered = renderMarkdownEmail(request.markdown, {
+      title: subject,
+      branding
+    });
+    html = html || mdRendered.html;
+    text = text || mdRendered.text;
+  }
+  if (request.template) {
+    const tmplRendered = await renderEmailTemplate(request.template, request.data || {}, branding);
+    html = html || tmplRendered.html;
+    text = text || tmplRendered.text;
+    subject = subject || tmplRendered.subject || "Notification";
+  }
+  if (!subject) {
+    subject = "Notification";
+  }
+  const messageId = `mail_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  const timestamp = Date.now();
+  const recipients = Array.isArray(request.to) ? request.to : [request.to];
+  const suppressionConfig = typeof mailConfig.suppression === "object" ? mailConfig.suppression : {};
+  const shouldEnforceSuppression = mailConfig.suppression !== false && suppressionConfig.enforce !== false && request.suppression !== false;
+  let activeRecipients = [...recipients];
+  const suppressedRecipients = [];
+  if (shouldEnforceSuppression) {
+    const kept = [];
+    for (const recipient of recipients) {
+      const check = await isEmailSuppressed(event, recipient);
+      if (check.suppressed) {
+        suppressedRecipients.push(recipient);
+      } else {
+        kept.push(recipient);
+      }
+    }
+    activeRecipients = kept;
+    if (activeRecipients.length === 0) {
+      return {
+        success: false,
+        messageId,
+        timestamp,
+        suppressed: true,
+        suppressedRecipients
+      };
+    }
+  }
+  const unsubsConfig = typeof mailConfig.unsubscribe === "object" ? mailConfig.unsubscribe : {};
+  const shouldAddUnsubscribe = mailConfig.unsubscribe !== false && unsubsConfig.enabled !== false && request.unsubscribe !== false;
+  const effectiveHeaders = { ...request.headers || {} };
+  if (shouldAddUnsubscribe && activeRecipients.length > 0) {
+    const trackConfig2 = mailConfig.tracking || {};
+    const baseUrl = trackConfig2.baseUrl || (event?.node?.req?.headers?.host ? `http://${event.node.req.headers.host}` : "") || runtimeConfig.public?.qarpeo?.site?.url || "http://localhost:3000";
+    const customOpts = typeof request.unsubscribe === "object" ? request.unsubscribe : {};
+    const unsubsHeaders = await buildListUnsubscribeHeaders({
+      to: activeRecipients[0],
+      baseUrl,
+      config: { ...unsubsConfig, ...customOpts }
+    });
+    Object.assign(effectiveHeaders, unsubsHeaders);
+  }
+  const finalTo = Array.isArray(request.to) ? activeRecipients : activeRecipients[0];
+  const trackConfig = mailConfig.tracking || {};
+  const shouldTrack = request.track !== false && (Boolean(request.track) || Boolean(trackConfig.opens) || Boolean(trackConfig.clicks));
+  if (shouldTrack && html) {
+    const baseUrl = trackConfig.baseUrl || (event?.node?.req?.headers?.host ? `http://${event.node.req.headers.host}` : "") || runtimeConfig.public?.qarpeo?.site?.url || "";
+    if (baseUrl) {
+      const opens = typeof request.track === "object" ? request.track.opens !== false : trackConfig.opens !== false;
+      const clicks = typeof request.track === "object" ? request.track.clicks !== false : trackConfig.clicks !== false;
+      html = injectEmailTracking(html, {
+        messageId,
+        baseUrl,
+        opens,
+        clicks
+      });
+    }
+  }
+  if (isDev || mailConfig.devMailbox) {
+    const mailbox = getSharedMailbox();
+    mailbox.unshift({
+      id: messageId,
+      to: finalTo,
+      from,
+      subject,
+      html,
+      text,
+      timestamp,
+      headers: effectiveHeaders,
+      template: request.template,
+      metadata: request.metadata
+    });
+    if (mailbox.length > 100) {
+      mailbox.pop();
+    }
+  }
+  const shouldQueue = request.queue === true || Boolean(mailConfig.queue) && request.queue !== false;
+  if (shouldQueue && !isDev) {
+    const queueBinding = resolveRuntimeBinding(
+      "queue",
+      typeof mailConfig.queue === "string" ? mailConfig.queue : void 0,
+      "QUEUE"
+    );
+    try {
+      const q = useQueue(queueBinding, event);
+      await q.send({
+        __jobName: "__qarpeo_mail",
+        id: messageId,
+        timestamp,
+        data: {
+          from,
+          to: finalTo,
+          subject,
+          html,
+          text,
+          replyTo: request.replyTo,
+          cc: request.cc,
+          bcc: request.bcc,
+          headers: effectiveHeaders,
+          messageId,
+          provider: mailConfig.provider || "cloudflare",
+          apiKey: mailConfig.apiKey || procEnv.RESEND_API_KEY || procEnv.POSTMARK_SERVER_TOKEN
+        }
+      });
+      const captured = getDevEmail(messageId);
+      if (captured) captured.queued = true;
+      return {
+        success: true,
+        messageId,
+        timestamp,
+        queued: true
+      };
+    } catch (queueErr) {
+      console.warn(
+        `[qarpeo:mail] Failed to enqueue email to "${queueBinding}", falling back to direct delivery:`,
+        queueErr
+      );
+    }
+  }
+  const provider = mailConfig.provider || (isDev ? "dev" : "cloudflare");
+  if (provider === "dev" || isDev && !procEnv.CLOUDFLARE_EMAIL_FORCE) {
+    return {
+      success: true,
+      messageId,
+      timestamp,
+      previewUrl: `/api/mail/inbox/${messageId}`
+    };
+  }
+  const apiKey = mailConfig.apiKey || procEnv.RESEND_API_KEY || procEnv.POSTMARK_SERVER_TOKEN;
+  const waitUntilContext = event?.context?.cloudflare?.context;
+  const canWaitUntil = !!(waitUntilContext && typeof waitUntilContext.waitUntil === "function");
+  const sendDirectPromise = deliverMailDirect(
+    {
+      from,
+      to: finalTo,
+      subject,
+      html,
+      text,
+      replyTo: request.replyTo,
+      cc: request.cc,
+      bcc: request.bcc,
+      headers: effectiveHeaders,
+      messageId,
+      provider,
+      apiKey
+    },
+    event
+  );
+  if (canWaitUntil) {
+    waitUntilContext.waitUntil(
+      sendDirectPromise.catch(
+        (err) => console.error(`[qarpeo:mail] Async ${provider} delivery failed:`, err?.message || err)
+      )
+    );
+    return { success: true, messageId, timestamp, suppressedRecipients: suppressedRecipients.length > 0 ? suppressedRecipients : void 0 };
+  }
+  try {
+    const finalId = await sendDirectPromise;
+    return {
+      success: true,
+      messageId: finalId || messageId,
+      timestamp
+    };
+  } catch (err) {
+    if (isDev) {
+      return {
+        success: true,
+        messageId,
+        timestamp,
+        previewUrl: `/api/mail/inbox/${messageId}`
+      };
+    }
+    throw err;
+  }
+}
+export function useMail(event) {
+  return {
+    send: (request) => sendMail(request, event),
+    getMailbox: getDevMailbox,
+    getEmail: getDevEmail,
+    clearMailbox: clearDevMailbox
+  };
+}
+export {
+  suppressEmail,
+  isEmailSuppressed,
+  unsuppressEmail,
+  listSuppressedEmails,
+  recordSoftBounce,
+  generateUnsubscribeToken,
+  verifyUnsubscribeToken,
+  buildListUnsubscribeHeaders
+} from "./mail-suppression.mjs";

package/dist/runtime/server/utils/notifications.d.ts

@@ -0,0 +1,51 @@
+import type { NotificationRecord, PushSubscriptionRecord, SendNotificationRequest } from "../../../types";
+/**
+ * Send a notification via one or more channels (in-app, push, email).
+ * Persists to D1 for in-app channel.
+ */
+export declare function sendNotification(request: SendNotificationRequest, event?: any): Promise<void>;
+/** Alias for sendNotification */
+export declare const notify: typeof sendNotification;
+export interface GetNotificationsOptions {
+    limit?: number;
+    offset?: number;
+    unreadOnly?: boolean;
+    tenantId?: string;
+}
+/**
+ * Get paginated notifications for a user from D1.
+ */
+export declare function getNotifications(userId: string, options?: GetNotificationsOptions, event?: any): Promise<{
+    notifications: NotificationRecord[];
+    total: number;
+    unread: number;
+}>;
+/**
+ * Mark a single notification as read.
+ */
+export declare function markNotificationRead(id: string, userId: string, event?: any): Promise<void>;
+/**
+ * Mark all notifications as read for a user.
+ */
+export declare function markAllNotificationsRead(userId: string, event?: any): Promise<void>;
+/**
+ * Delete a notification.
+ */
+export declare function deleteNotification(id: string, userId: string, event?: any): Promise<void>;
+/**
+ * Save a Web Push subscription for a user.
+ */
+export declare function savePushSubscription(userId: string, subscription: PushSubscriptionRecord, tenantId?: string, event?: any): Promise<void>;
+/**
+ * Remove a Web Push subscription by endpoint.
+ */
+export declare function removePushSubscription(endpoint: string, event?: any): Promise<void>;
+/**
+ * Send a Web Push notification to all subscriptions for a user.
+ */
+export declare function sendWebPush(userId: string, payload: {
+    title: string;
+    body?: string;
+    icon?: string;
+    data?: Record<string, any>;
+}, event?: any): Promise<void>;

package/dist/runtime/server/utils/notifications.mjs

@@ -0,0 +1,215 @@
+import { getCloudflareEnv } from "../../bindings.mjs";
+import { sendMail } from "./mail.mjs";
+import { signVapidHeader, encryptWebPushPayload } from "./vapid.mjs";
+function getD1(event) {
+  const env = getCloudflareEnv(event);
+  const db = env[process.env.QARPEO_DEFAULT_DB_BINDING || "DB"];
+  if (!db) throw new Error("[qarpeo/notifications] D1 database binding not found");
+  return db;
+}
+function getTable() {
+  return process.env.QARPEO_NOTIFICATIONS_TABLE || "_qarpeo_notifications";
+}
+function getPushTable() {
+  return "_qarpeo_push_subscriptions";
+}
+function nanoid() {
+  return crypto.randomUUID().replace(/-/g, "");
+}
+function parseChannels(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return ["in-app"];
+  }
+}
+function rowToRecord(row) {
+  return {
+    id: row.id,
+    userId: row.user_id,
+    tenantId: row.tenant_id ?? void 0,
+    title: row.title,
+    body: row.body ?? void 0,
+    icon: row.icon ?? void 0,
+    actionUrl: row.action_url ?? void 0,
+    channels: parseChannels(row.channels),
+    read: Boolean(row.read),
+    readAt: row.read_at ?? void 0,
+    createdAt: row.created_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : void 0
+  };
+}
+export async function sendNotification(request, event) {
+  const channels = request.channels || (process.env.QARPEO_NOTIFICATIONS_DEFAULT_CHANNELS ? JSON.parse(process.env.QARPEO_NOTIFICATIONS_DEFAULT_CHANNELS) : ["in-app"]);
+  const id = nanoid();
+  const now = Date.now();
+  if (channels.includes("in-app")) {
+    try {
+      const db = getD1(event);
+      const table = getTable();
+      await db.prepare(
+        `INSERT INTO ${table} (id, user_id, tenant_id, title, body, icon, action_url, channels, read, created_at, metadata)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?)`
+      ).bind(
+        id,
+        request.userId,
+        request.tenantId ?? null,
+        request.title,
+        request.body ?? null,
+        request.icon ?? null,
+        request.actionUrl ?? null,
+        JSON.stringify(channels),
+        now,
+        request.metadata ? JSON.stringify(request.metadata) : null
+      ).run();
+    } catch (err) {
+      console.error("[qarpeo/notifications] Failed to persist in-app notification:", err);
+    }
+  }
+  if (channels.includes("push")) {
+    try {
+      await sendWebPush(
+        request.userId,
+        {
+          title: request.title,
+          body: request.body,
+          icon: request.icon,
+          data: { actionUrl: request.actionUrl, notificationId: id }
+        },
+        event
+      );
+    } catch (err) {
+      console.error("[qarpeo/notifications] Failed to send web push:", err);
+    }
+  }
+  if (channels.includes("email")) {
+    try {
+      const emailOpts = request.emailOptions || {};
+      await sendMail(
+        {
+          to: request.userId,
+          // userId should be an email when using email channel
+          subject: emailOpts.subject || request.title,
+          from: emailOpts.from,
+          markdown: `# ${request.title}
+
+${request.body || ""}
+
+${request.actionUrl ? `[View \u2192](${request.actionUrl})` : ""}`
+        },
+        event
+      );
+    } catch (err) {
+      console.error("[qarpeo/notifications] Failed to send email notification:", err);
+    }
+  }
+}
+export const notify = sendNotification;
+export async function getNotifications(userId, options = {}, event) {
+  const db = getD1(event);
+  const table = getTable();
+  const limit = options.limit ?? 20;
+  const offset = options.offset ?? 0;
+  let where = "WHERE user_id = ?";
+  const binds = [userId];
+  if (options.tenantId) {
+    where += " AND tenant_id = ?";
+    binds.push(options.tenantId);
+  }
+  if (options.unreadOnly) {
+    where += " AND read = 0";
+  }
+  const [rows, countRow, unreadRow] = await Promise.all([
+    db.prepare(`SELECT * FROM ${table} ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`).bind(...binds, limit, offset).all(),
+    db.prepare(`SELECT COUNT(*) as cnt FROM ${table} WHERE user_id = ?`).bind(userId).first(),
+    db.prepare(`SELECT COUNT(*) as cnt FROM ${table} WHERE user_id = ? AND read = 0`).bind(userId).first()
+  ]);
+  return {
+    notifications: (rows.results || []).map(rowToRecord),
+    total: countRow?.cnt ?? 0,
+    unread: unreadRow?.cnt ?? 0
+  };
+}
+export async function markNotificationRead(id, userId, event) {
+  const db = getD1(event);
+  const table = getTable();
+  await db.prepare(`UPDATE ${table} SET read = 1, read_at = ? WHERE id = ? AND user_id = ?`).bind(Date.now(), id, userId).run();
+}
+export async function markAllNotificationsRead(userId, event) {
+  const db = getD1(event);
+  const table = getTable();
+  await db.prepare(`UPDATE ${table} SET read = 1, read_at = ? WHERE user_id = ? AND read = 0`).bind(Date.now(), userId).run();
+}
+export async function deleteNotification(id, userId, event) {
+  const db = getD1(event);
+  const table = getTable();
+  await db.prepare(`DELETE FROM ${table} WHERE id = ? AND user_id = ?`).bind(id, userId).run();
+}
+export async function savePushSubscription(userId, subscription, tenantId, event) {
+  const db = getD1(event);
+  const table = getPushTable();
+  await db.prepare(
+    `INSERT OR REPLACE INTO ${table} (endpoint, user_id, tenant_id, keys_p256dh, keys_auth, created_at)
+       VALUES (?, ?, ?, ?, ?, ?)`
+  ).bind(
+    subscription.endpoint,
+    userId,
+    tenantId ?? null,
+    subscription.keys.p256dh,
+    subscription.keys.auth,
+    Date.now()
+  ).run();
+}
+export async function removePushSubscription(endpoint, event) {
+  const db = getD1(event);
+  const table = getPushTable();
+  await db.prepare(`DELETE FROM ${table} WHERE endpoint = ?`).bind(endpoint).run();
+}
+export async function sendWebPush(userId, payload, event) {
+  const db = getD1(event);
+  const table = getPushTable();
+  const rows = await db.prepare(`SELECT * FROM ${table} WHERE user_id = ?`).bind(userId).all();
+  if (!rows.results?.length) return;
+  const vapidPublicKey = process.env.NUXT_VAPID_PUBLIC_KEY || process.env.VAPID_PUBLIC_KEY;
+  const vapidPrivateKey = process.env.NUXT_VAPID_PRIVATE_KEY || process.env.VAPID_PRIVATE_KEY;
+  const vapidSubject = process.env.NUXT_VAPID_SUBJECT || process.env.VAPID_SUBJECT || "mailto:push@qarpeo.com";
+  if (!vapidPublicKey || !vapidPrivateKey) {
+    console.warn("[qarpeo/notifications] VAPID keys not configured \u2014 skipping web push");
+    return;
+  }
+  await Promise.allSettled(
+    rows.results.map(async (row) => {
+      const subscription = {
+        endpoint: row.endpoint,
+        keys: { p256dh: row.keys_p256dh, auth: row.keys_auth }
+      };
+      try {
+        const authHeader = await signVapidHeader(
+          subscription.endpoint,
+          vapidSubject,
+          vapidPublicKey,
+          vapidPrivateKey
+        );
+        const { body, headers } = await encryptWebPushPayload(subscription, payload);
+        const response = await fetch(subscription.endpoint, {
+          method: "POST",
+          headers: {
+            Authorization: authHeader,
+            TTL: "86400",
+            ...headers
+          },
+          body
+        });
+        if (response.status === 410 || response.status === 404) {
+          await removePushSubscription(subscription.endpoint, event);
+        } else if (!response.ok) {
+          console.warn(
+            `[qarpeo/notifications] Push failed for ${subscription.endpoint}: ${response.status}`
+          );
+        }
+      } catch (err) {
+        console.error(`[qarpeo/notifications] Push error for ${subscription.endpoint}:`, err);
+      }
+    })
+  );
+}

package/dist/runtime/server/utils/organization.d.ts

@@ -0,0 +1,54 @@
+import type { QarpeoOrganization, QarpeoMember } from "../../types/auth";
+export declare function slugify(text: string): string;
+/** Creates a new organization with the current authenticated user as "owner". */
+export declare function createOrganization(event: any, input: {
+    name: string;
+    slug?: string;
+    logoUrl?: string | null;
+}): Promise<{
+    organization: QarpeoOrganization;
+    member: QarpeoMember;
+}>;
+/** Lists all organizations the authenticated user belongs to. */
+export declare function listUserOrganizations(event: any, userId: string): Promise<Array<QarpeoOrganization & {
+    role: string;
+    memberId: string;
+}>>;
+/** Switches the active organization for the current user's session. */
+export declare function switchActiveOrganization(event: any, organizationId: string): Promise<{
+    success: boolean;
+    organization: QarpeoOrganization;
+    role: string;
+}>;
+/** Invites a new member to an organization via email. */
+export declare function inviteOrganizationMember(event: any, input: {
+    organizationId: string;
+    email: string;
+    role?: string;
+}): Promise<{
+    invitationId: string;
+    token: string;
+    expiresAt: number;
+    inviteUrl: string;
+    sent: boolean;
+    error?: string;
+}>;
+/** Removes a member from an organization. */
+export declare function removeOrganizationMember(event: any, input: {
+    organizationId: string;
+    memberId: string;
+}): Promise<{
+    success: boolean;
+}>;
+/** Accepts an invitation token and adds user as a member. */
+export declare function acceptOrganizationInvitation(event: any, token: string): Promise<{
+    success: boolean;
+    organizationId: string;
+    role: string;
+}>;
+/** Lists all members for a given organization (requires organization membership). */
+export declare function listOrganizationMembers(event: any, organizationId: string): Promise<Array<QarpeoMember & {
+    email?: string;
+    name?: string;
+    avatarUrl?: string;
+}>>;