@columenlabs/lumen-people 0.0.0-stage → 0.1.67

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Columen Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,12 @@
+Lumen
+Copyright (c) 2026 Columen Labs. Licensed under the MIT License (see LICENSE).
+
+Lumen draws price and market charts with TradingView Lightweight Charts™
+(https://github.com/tradingview/lightweight-charts), Copyright (c) 2025
+TradingView, Inc., licensed under the Apache License 2.0. Lumen turns off the
+chart's own logo, so per that library's NOTICE, an app that shows these charts
+should link to https://www.tradingview.com/ somewhere a user can find it (an
+About page or footer is enough).
+
+The components under packages/ui/src/ui are based on shadcn/ui
+(https://ui.shadcn.com), MIT License, Copyright (c) 2023 shadcn.

package/README.md

@@ -1,3 +1,72 @@
-# Temporary Holding Version
+# @columenlabs/lumen-people
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lumen's people, access and invites, server side: who may sign in, what each person may do in each part of an app, invites with a single-use link that expires, and an audit log of every change. It pairs with the People screens in `@columenlabs/lumen-ui/people`. No dependencies beyond `@columenlabs/lumen-ui-types`: Web Crypto, `Request` and `Response`, so it runs in a Worker, a Durable Object, Bun or Node.
+
+- Source: https://github.com/columenlabs/lumen (`packages/people`). MIT.
+
+## Install
+
+```bash
+bun add @columenlabs/lumen-people @columenlabs/lumen-ui-types
+```
+
+Pin both to the same exact version as the other Lumen packages.
+
+## Scopes and levels
+
+A scope is anything access is given on: an app, or a construct inside one (a folder, a collection). Each has its own ordered levels, lowest first (`None, View, Edit, Admin` when it names none). A person holds one level per scope; no grant is the lowest. Admins hold the top level everywhere; disabled people and expired invites hold the lowest.
+
+```ts
+import type { Scope } from '@columenlabs/lumen-ui-types/people';
+
+export const SCOPES: Scope[] = [
+  { id: 'tools', name: 'Tools' },
+  { id: 'recipes', name: 'Recipes' },
+  { id: 'collections', name: 'Collections', parent: 'recipes', resourceLabel: 'Collection' },
+];
+```
+
+## The service
+
+```ts
+import { can, createPeople, doSql, sqlStore } from '@columenlabs/lumen-people';
+
+// In a Durable Object, so the admin floor check and its write never interleave:
+const people = createPeople({
+  store: sqlStore(doSql(ctx.storage.sql)),   // or sqlStore(d1Sql(env.DB))
+  scopes: SCOPES,
+  fixedAdmins: ['owner@example.com'],        // always an active admin
+  inviteDays: 7,
+});
+
+const person = await people.seen('a@example.com');   // on each sign-in: null = refuse
+can(person, SCOPES[0], 'view', SCOPES);              // the one check a route makes
+```
+
+The rules it keeps:
+
+- One active admin always; the built-in admins can never lose it.
+- Only an admin invites, changes access or removes; refusals are logged too.
+- An invite link is single use; only its SHA-256 hash is stored. Resend makes a new link and restarts the clock, revoke kills it. An invite past its life is refused at sign-in until resent.
+- Every change is one audit event (who, what, when, from where), kept a year.
+
+## The routes
+
+```ts
+import { peopleRoutes } from '@columenlabs/lumen-people/routes';
+
+const routes = peopleRoutes({
+  base: '/api/people',
+  people: () => people,                                 // or a Durable Object stub
+  actor: (req) => ({ email, admin, via: 'app' }),       // your verified caller
+  scopes: SCOPES,
+  appName: 'Example',
+  link: (token) => `https://app.example.com/invite/${token}`,
+  mailer: () => myMailer,                               // optional: (msg) => { ok, detail }
+  onRemove: async (person) => { /* delete their data */ },
+});
+
+app.all('/api/people/*', (c) => routes(c.req.raw));
+```
+
+Without a mailer every invite returns its link to copy by hand; a failed send never undoes an invite.

package/dist/email.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Email through a Resend-style API: `POST {url}/emails` with `Authorization: Bearer <key>`, which
+ * Resend and self-hosted servers that copy its API both answer. No SMTP. The app keeps the settings
+ * (sealed: the key never comes back) and says how each route is reached, e.g. a private tunnel's
+ * own fetch; the kit sends, checks and tests.
+ */
+import type { EmailCheck, EmailDraft, EmailRoute, EmailSettingsView, MailOutcome } from '@columenlabs/lumen-ui-types/people';
+import type { MailMessage, Mailer } from './mailer.js';
+type Fetch = (req: Request) => Promise<Response>;
+type Awaitable<T> = T | Promise<T>;
+export interface ResendConfig {
+    /** The API base without `/emails`: `https://api.resend.com`, `http://localhost:5000/api`. */
+    url: string;
+    apiKey: string;
+    from: string;
+    fromName?: string;
+    /** How requests reach the server (a tunnel binding's fetch); the global fetch by default. */
+    fetch?: Fetch;
+    timeoutMs?: number;
+}
+/** `https://api.resend.com/emails/` → `https://api.resend.com`; null for anything but a plain URL. */
+export declare function emailApiUrl(v: string): string | null;
+/** One email; never throws. */
+export declare function sendResend(c: ResendConfig, msg: MailMessage): Promise<MailOutcome>;
+export declare const resendMailer: (c: ResendConfig) => Mailer;
+/** Check connection: every step but sending. */
+export declare function checkResend(c: ResendConfig, where: string): Promise<EmailCheck>;
+/** Send test: a real email to `to`. */
+export declare function testResend(c: ResendConfig, where: string, to: string, appName: string): Promise<EmailCheck>;
+/** What the app stores: the draft with its key, sealed by the app. */
+export interface StoredEmail {
+    route: string;
+    url: string;
+    apiKey: string;
+    from: string;
+    fromName: string;
+}
+export interface EmailRouteDef extends EmailRoute {
+    /** Why an address will not do on this route (a tunnel that allows one port), or null. */
+    checkUrl?: (url: string) => string | null;
+    /** How this route reaches the server; the global fetch by default (then https only). */
+    fetch?: (req: Request) => Awaitable<Fetch | null>;
+    /** The server named in check lines ("the tunnel's machine"); the address's host by default. */
+    where?: string;
+}
+export interface EmailOptions {
+    routes: EmailRouteDef[];
+    store: {
+        get: (req: Request) => Promise<{
+            settings: StoredEmail;
+            updatedAt: number | null;
+            updatedBy: string | null;
+        } | null>;
+        put: (req: Request, settings: StoredEmail, by: string) => Promise<void>;
+        clear?: (req: Request) => Promise<void>;
+        lastTest?: (req: Request) => Promise<EmailCheck | null>;
+        putTest?: (req: Request, test: EmailCheck) => Promise<void>;
+    };
+}
+/** The draft as settings to try, with the saved key when the draft left it out; or why not. */
+export declare function resolveDraft(o: EmailOptions, req: Request, draft: Partial<EmailDraft>): Promise<{
+    ok: true;
+    settings: StoredEmail;
+    config: ResendConfig;
+    where: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+/** The saved settings as a mailer, or null when none are saved or their route is gone. */
+export declare function storedMailer(o: EmailOptions, req: Request): Promise<{
+    mailer: Mailer;
+    from: string;
+} | null>;
+export declare function emailView(o: EmailOptions, req: Request, me: string): Promise<EmailSettingsView>;
+export {};

package/dist/email.js

@@ -0,0 +1,210 @@
+const TIMEOUT_MS = 15_000;
+/** `https://api.resend.com/emails/` → `https://api.resend.com`; null for anything but a plain URL. */
+export function emailApiUrl(v) {
+    try {
+        const u = new URL(v.trim());
+        if (u.search || u.hash || u.username || u.password)
+            return null;
+        if (u.protocol !== 'https:' && u.protocol !== 'http:')
+            return null;
+        return `${u.origin}${u.pathname}`.replace(/\/+$/, '').replace(/\/emails$/, '');
+    }
+    catch {
+        return null;
+    }
+}
+const fromHeader = (c) => c.fromName ? `"${c.fromName.replace(/["<>]/g, '')}" <${c.from}>` : c.from;
+async function call(c, path, init) {
+    const t0 = Date.now();
+    const req = new Request(`${c.url}${path}`, {
+        ...init,
+        headers: { authorization: `Bearer ${c.apiKey}`, 'content-type': 'application/json' },
+        redirect: 'manual',
+        signal: AbortSignal.timeout(c.timeoutMs ?? TIMEOUT_MS),
+    });
+    try {
+        const res = await (c.fetch ?? ((r) => fetch(r)))(req);
+        return { res, ms: Date.now() - t0 };
+    }
+    catch {
+        return { res: null, ms: Date.now() - t0 };
+    }
+}
+const refused = (status) => status === 401 || status === 403
+    ? 'The server refused the API key'
+    : status === 400 || status === 422
+        ? 'The server refused the email (check the sender)'
+        : status === 429
+            ? 'The server is rate limiting; try again soon'
+            : `The server answered ${status}`;
+/** One email; never throws. */
+export async function sendResend(c, msg) {
+    const { res } = await call(c, '/emails', {
+        method: 'POST',
+        body: JSON.stringify({
+            from: fromHeader(c),
+            to: [msg.to],
+            subject: msg.subject,
+            html: msg.html,
+            text: msg.text,
+        }),
+    });
+    if (!res)
+        return { ok: false, detail: 'Could not reach the email server' };
+    await res.body?.cancel();
+    return res.ok
+        ? { ok: true, detail: `Emailed ${msg.to}` }
+        : { ok: false, detail: refused(res.status) };
+}
+export const resendMailer = (c) => (msg) => sendResend(c, msg);
+/** Reached the server and key accepted, from one request that cannot send: an empty email to
+ *  `/emails`. A refused key answers 401 or 403; a key that passes gets the empty email refused. */
+async function reachAndKey(c, where) {
+    const { res, ms } = await call(c, '/emails', { method: 'POST', body: '{}' });
+    if (!res)
+        return [{ id: 'reach', ok: false, text: `Could not reach ${where}`, ms }];
+    await res.body?.cancel();
+    const reach = { id: 'reach', ok: true, text: `Reached ${where}`, ms };
+    if (res.status === 404 || res.status === 405)
+        return [{ ...reach, ok: false, text: `${where} has no email API at this address` }];
+    if (res.status === 401 || res.status === 403)
+        return [reach, { id: 'key', ok: false, text: 'The server refused the API key', ms: null }];
+    if (res.status >= 500)
+        return [reach, { id: 'key', ok: false, text: `The server answered ${res.status}`, ms: null }];
+    if (res.status === 429)
+        return [reach, { id: 'key', ok: null, text: 'Rate limited: try again soon', ms: null }];
+    return [reach, { id: 'key', ok: true, text: 'API key accepted', ms: null }];
+}
+/** The sender's domain among the server's verified domains (`GET /domains`), where it lists them. */
+async function sender(c) {
+    const { res, ms } = await call(c, '/domains', { method: 'GET' });
+    const unknown = {
+        id: 'sender',
+        ok: null,
+        text: `${c.from}: this server does not list its senders, so Send test confirms it`,
+        ms,
+    };
+    if (!res?.ok) {
+        await res?.body?.cancel();
+        return unknown;
+    }
+    const body = (await res.json().catch(() => null));
+    if (!Array.isArray(body?.data))
+        return unknown;
+    const domain = c.from.split('@')[1]?.toLowerCase();
+    const d = body.data.find((x) => x.name?.toLowerCase() === domain);
+    if (!d)
+        return { id: 'sender', ok: false, text: `${domain} is not a domain on this server`, ms };
+    const ok = !d.status || d.status === 'verified';
+    return {
+        id: 'sender',
+        ok,
+        text: ok ? `${c.from} is allowed to send` : `${domain} is ${d.status} on this server`,
+        ms,
+    };
+}
+const passed = (steps) => steps.every((s) => s.ok !== false) && steps.some((s) => s.ok === true);
+/** Check connection: every step but sending. */
+export async function checkResend(c, where) {
+    const steps = await reachAndKey(c, where);
+    if (passed(steps))
+        steps.push(await sender(c));
+    return {
+        ok: passed(steps) && steps.some((s) => s.id === 'key' && s.ok),
+        kind: 'check',
+        steps,
+        at: Date.now(),
+    };
+}
+/** Send test: a real email to `to`. */
+export async function testResend(c, where, to, appName) {
+    const t0 = Date.now();
+    const r = await sendResend(c, {
+        to,
+        subject: `${appName} email test`,
+        html: `<!doctype html><html><body style="font-family:system-ui,sans-serif;font-size:15px;line-height:1.5"><p>This is a test from ${appName} settings.</p><p style="color:#78716c;font-size:13px">Sent as ${c.from}.</p></body></html>`,
+        text: `This is a test from ${appName} settings. Sent as ${c.from}.`,
+    });
+    const ms = Date.now() - t0;
+    const steps = r.ok
+        ? [
+            { id: 'reach', ok: true, text: `Reached ${where}`, ms: null },
+            { id: 'key', ok: true, text: 'API key accepted', ms: null },
+            { id: 'send', ok: true, text: `Sent to ${to} · check the inbox`, ms },
+        ]
+        : [{ id: 'send', ok: false, text: r.detail, ms }];
+    return { ok: r.ok, kind: 'test', steps, at: Date.now() };
+}
+const EMAIL_RE = /^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/;
+/** The draft as settings to try, with the saved key when the draft left it out; or why not. */
+export async function resolveDraft(o, req, draft) {
+    const route = o.routes.find((r) => r.id === draft.route);
+    if (!route)
+        return { ok: false, error: 'Pick how to reach the server.' };
+    const url = emailApiUrl(String(draft.url ?? ''));
+    if (!url)
+        return { ok: false, error: 'Enter the server address, like https://api.resend.com.' };
+    const own = route.checkUrl?.(url);
+    if (own)
+        return { ok: false, error: own };
+    const f = route.fetch ? await route.fetch(req) : null;
+    if (route.fetch && !f)
+        return { ok: false, error: `${route.label} is not connected.` };
+    if (!route.fetch && !url.startsWith('https://'))
+        return { ok: false, error: 'Use an https address on the public internet.' };
+    const saved = (await o.store.get(req))?.settings;
+    const apiKey = String(draft.apiKey ?? '').trim() || saved?.apiKey || '';
+    if (!apiKey || apiKey.length > 300)
+        return { ok: false, error: 'Enter the API key.' };
+    const from = String(draft.from ?? '')
+        .trim()
+        .toLowerCase();
+    if (!EMAIL_RE.test(from))
+        return { ok: false, error: 'Enter the address mail is sent from.' };
+    const fromName = String(draft.fromName ?? '')
+        .trim()
+        .slice(0, 80);
+    const settings = { route: route.id, url, apiKey, from, fromName };
+    return {
+        ok: true,
+        settings,
+        config: { url, apiKey, from, fromName, ...(f ? { fetch: f } : {}) },
+        where: route.where ?? new URL(url).host,
+    };
+}
+/** The saved settings as a mailer, or null when none are saved or their route is gone. */
+export async function storedMailer(o, req) {
+    const s = (await o.store.get(req))?.settings;
+    if (!s)
+        return null;
+    const r = await resolveDraft(o, req, s);
+    return r.ok
+        ? { mailer: resendMailer(r.config), from: s.fromName ? `${s.fromName} <${s.from}>` : s.from }
+        : null;
+}
+export async function emailView(o, req, me) {
+    const [got, lastTest] = await Promise.all([o.store.get(req), o.store.lastTest?.(req) ?? null]);
+    const current = got
+        ? {
+            route: got.settings.route,
+            url: got.settings.url,
+            keyHint: `…${got.settings.apiKey.slice(-4)}`,
+            from: got.settings.from,
+            fromName: got.settings.fromName,
+            updatedAt: got.updatedAt,
+            updatedBy: got.updatedBy,
+        }
+        : null;
+    return {
+        routes: o.routes.map(({ id, label, state, urlInfo, url }) => ({
+            id,
+            label,
+            state,
+            urlInfo,
+            url,
+        })),
+        current,
+        lastTest,
+        me,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { type Actor, createPeople, type InviteOutcome, type PeopleOptions, type PeopleService, type Result, } from './service.js';
+export { d1Sql, doSql, type PeopleStore, type SqlRunner, sqlStore, type StoredPerson, } from './store.js';
+export { type InviteMail, type InviteTemplate, inviteTemplate, type MailMessage, type Mailer, } from './mailer.js';
+export { type PeopleApi, type PeopleRoutesOptions, peopleRoutes } from './routes.js';
+export { atLeast, can, checkAdminFloor, DEFAULT_LEVELS, levelOf, normEmail, } from '@columenlabs/lumen-ui-types/people';
+export { checkResend, type EmailOptions, type EmailRouteDef, emailApiUrl, type ResendConfig, resendMailer, sendResend, type StoredEmail, testResend, } from './email.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+// Lumen's people, access and invites on the server. The screens are `@columenlabs/lumen-ui/people`;
+// the shapes and pure rules both share are `@columenlabs/lumen-ui-types/people`.
+export { createPeople, } from './service.js';
+export { d1Sql, doSql, sqlStore, } from './store.js';
+export { inviteTemplate, } from './mailer.js';
+export { peopleRoutes } from './routes.js';
+export { atLeast, can, checkAdminFloor, DEFAULT_LEVELS, levelOf, normEmail, } from '@columenlabs/lumen-ui-types/people';
+export { checkResend, emailApiUrl, resendMailer, sendResend, testResend, } from './email.js';

package/dist/mailer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The mailer is the app's: any function that sends one email and says whether it went. The
+ * people routes only build the invite email and hand it over, so an app plugs in whatever it
+ * sends with (an email API, an SMTP relay, a queue). With no mailer, every invite gives a link
+ * to send by hand.
+ */
+import type { MailOutcome } from '@columenlabs/lumen-ui-types/people';
+export interface MailMessage {
+    to: string;
+    subject: string;
+    html: string;
+    text: string;
+}
+export type Mailer = (message: MailMessage) => Promise<MailOutcome>;
+export interface InviteMail {
+    to: string;
+    /** The app's name, as the person knows it. */
+    appName: string;
+    /** Who invited them (a name or an email). */
+    inviter: string;
+    /** The single-use link. */
+    url: string;
+    /** What they get, in words: `Notes (View), Billing (Admin)`. */
+    access: string[];
+    expiresAt: number | null;
+    /** The inviter's own line. */
+    note?: string;
+}
+/** Builds the invite email; an app passes its own to change the words or the look. */
+export type InviteTemplate = (i: InviteMail) => Pick<MailMessage, 'subject' | 'html' | 'text'>;
+export declare const inviteTemplate: InviteTemplate;

package/dist/mailer.js

@@ -0,0 +1,21 @@
+const esc = (s) => s.replace(/[&<>"']/g, (ch) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[ch] ?? ch);
+const day = (ms) => new Date(ms).toLocaleDateString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
+export const inviteTemplate = (i) => {
+    const access = i.access.length ? `You get ${i.access.join(', ')}.` : '';
+    const until = i.expiresAt ? `The link works until ${day(i.expiresAt)}.` : '';
+    const text = [
+        `${i.inviter} invited you to ${i.appName}.`,
+        access,
+        i.note ? `"${i.note}"` : '',
+        `Accept: ${i.url}`,
+        `${until} Sign in with ${i.to}. Not expecting this? Ignore it.`,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+    const html = `<!doctype html><html><body style="font-family:system-ui,-apple-system,Segoe UI,sans-serif;font-size:15px;line-height:1.5;color:#1c1917;max-width:520px;margin:0 auto;padding:24px">
+<p><strong>${esc(i.inviter)}</strong> invited you to ${esc(i.appName)}.</p>${access ? `\n<p>${esc(access)}</p>` : ''}${i.note ? `\n<p style="border-left:3px solid #d6d3d1;padding-left:12px;color:#57534e">${esc(i.note)}</p>` : ''}
+<p style="margin:24px 0"><a href="${esc(i.url)}" style="background:#1c1917;color:#fff;text-decoration:none;padding:10px 18px;border-radius:6px;font-weight:600">Accept invite</a></p>
+<p style="color:#78716c;font-size:13px">${esc(until)} Sign in with ${esc(i.to)}. Not expecting this? Ignore it.</p>
+</body></html>`;
+    return { subject: `${i.inviter} invited you to ${i.appName}`, html, text };
+};

package/dist/routes.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The HTTP routes the People screens call (`peopleClient(url)` in `@columenlabs/lumen-ui/people`),
+ * as one fetch handler on Web `Request`/`Response`, so it mounts in any router:
+ *
+ *   app.all('/api/people/*', (c) => people(c.req.raw));        // Hono
+ *
+ * Everything but `GET /me` and the invitee's `/invite/:token` routes needs an admin. Writes must
+ * be same-origin JSON: a signed-in browser session is a cookie, so a foreign page's form or fetch
+ * is refused before it reaches a rule.
+ */
+import { type Person, type RemovePlan, type Scope, type SyncStatus } from '@columenlabs/lumen-ui-types/people';
+import { type EmailOptions } from './email.js';
+import { type InviteTemplate, type Mailer } from './mailer.js';
+import type { Actor, PeopleService } from './service.js';
+type Awaitable<T> = T | Promise<T>;
+type Methods = 'list' | 'invite' | 'resend' | 'revoke' | 'update' | 'setAccess' | 'removable' | 'remove' | 'linkFor' | 'accept' | 'audit' | 'log';
+/** The service's calls the routes make: the service itself, or a stub that forwards to it
+ *  (a Durable Object that runs it). */
+export type PeopleApi = {
+    [K in Methods]: PeopleService[K];
+};
+export interface PeopleRoutesOptions {
+    /** Where the routes are mounted (`/api/people`). */
+    base: string;
+    /** The people service for this request. */
+    people: (req: Request) => Awaitable<PeopleApi>;
+    /** The verified caller, or null (403). The app decides who is an admin. */
+    actor: (req: Request) => Awaitable<Actor | null>;
+    /** The same scopes, link life and built-in admins the service was made with. */
+    scopes: readonly Scope[];
+    inviteDays?: number;
+    fixedAdmins?: readonly string[];
+    /** The app's name in the invite email. */
+    appName: string;
+    /** The page an invite link opens, with its token (`https://app.example.com/invite/<token>`). */
+    link: (token: string, req: Request) => string;
+    /** Sends an email; null or left out: no mail, every invite gives its link instead. */
+    mailer?: (req: Request) => Awaitable<Mailer | null>;
+    /** Shown beside Send in the invite drawer (`hello@example.com`). */
+    mailFrom?: (req: Request) => Awaitable<string | undefined>;
+    template?: InviteTemplate;
+    /** What removing a person does in the app, shown before Remove (one line per app part). */
+    removeSteps?: (person: Person, req: Request) => Awaitable<RemovePlan['steps']>;
+    /** The app's own clean-up, before the person is dropped (delete their data). */
+    onRemove?: (person: Person, req: Request) => Promise<void>;
+    /** Email through a Resend-style API, set in the app's settings (`/email` routes); also the
+     *  invites' mailer when `mailer` is left out. */
+    email?: EmailOptions;
+    /** Keeps an outside sign-in provider's allow list in step; run after every change to who may sign in. */
+    sync?: {
+        run: (req: Request, by: string) => Promise<SyncStatus>;
+        status: (req: Request) => Promise<SyncStatus | null>;
+    };
+}
+export declare function peopleRoutes(o: PeopleRoutesOptions): (req: Request) => Promise<Response>;
+export {};