@remit/backend 0.0.142 → 0.0.144

package/dist/src/handlers/calendar-feed.js

@@ -0,0 +1,192 @@
+import { buildCalendarFeed, calendarFeedIsUnchanged, calendarFeedIsUnmodifiedSince, hashCalendarFeedToken, isCalendarFeedToken, mintCalendarFeedToken, readCalendarFeedToken, } from "@remit/calendar-service";
+import { NotFoundError } from "@remit/data-ports/errors";
+import { getAccountConfigIdFromEvent } from "../auth.js";
+import { rawApiResponse } from "../response.js";
+import { getClient } from "../service/data-client.js";
+import { calendarDepsOf, findCalendarFor, notFound, refuseCalendar, } from "./calendar.js";
+const toFeedState = (token) => ({
+    calendarId: token.calendarId,
+    createdAt: token.createdAt,
+    rotatedAt: token.rotatedAt,
+});
+/**
+ * Mints the calendar's feed address, or replaces the one it has.
+ *
+ * The plaintext exists here and nowhere else: the store keeps a digest, so this
+ * return value is the only chance anybody has to read the token. Ownership is
+ * settled before the mint — a calendar the caller does not hold is absent, not
+ * forbidden, which is the same answer `getCalendar` gives it.
+ */
+export const putCalendarFeedFor = async (deps, accountConfigId, calendarId) => {
+    const calendar = await findCalendarFor(deps, accountConfigId, calendarId);
+    if (!calendar.ok)
+        return calendar;
+    const secret = mintCalendarFeedToken();
+    const stored = await deps.calendarFeedToken.put({
+        accountConfigId,
+        calendarId,
+        tokenHash: secret.tokenHash,
+    });
+    return {
+        ok: true,
+        value: {
+            calendarId: stored.calendarId,
+            feedToken: secret.token,
+            createdAt: stored.createdAt,
+            rotatedAt: stored.rotatedAt,
+        },
+    };
+};
+/** Whether the calendar has a feed address, and how old it is. */
+export const findCalendarFeedFor = async (deps, accountConfigId, calendarId) => {
+    const calendar = await findCalendarFor(deps, accountConfigId, calendarId);
+    if (!calendar.ok)
+        return calendar;
+    const stored = await deps.calendarFeedToken.findByCalendar(accountConfigId, calendarId);
+    if (!stored) {
+        return refuseCalendar("NotFound", `no feed on calendar ${calendarId}`);
+    }
+    return { ok: true, value: toFeedState(stored) };
+};
+/**
+ * Revokes the calendar's feed address.
+ *
+ * A calendar with no feed is refused rather than answered 204: the caller asked
+ * for a subscription to stop working, and reporting success for one that was
+ * never there reads as confirmation that it has.
+ */
+export const revokeCalendarFeedFor = async (deps, accountConfigId, calendarId) => {
+    const calendar = await findCalendarFor(deps, accountConfigId, calendarId);
+    if (!calendar.ok)
+        return calendar;
+    const stored = await deps.calendarFeedToken.findByCalendar(accountConfigId, calendarId);
+    if (!stored) {
+        return refuseCalendar("NotFound", `no feed on calendar ${calendarId}`);
+    }
+    await deps.calendarFeedToken.delete(accountConfigId, calendarId);
+    return { ok: true, value: null };
+};
+/**
+ * No feed answers to this address.
+ *
+ * One answer for an unknown token, a revoked one and a malformed one, with a
+ * body that says the same thing to all three: a caller probing addresses learns
+ * only whether the one it sent works, which is what it was going to find out
+ * anyway.
+ */
+const feedNotFound = () => rawApiResponse({
+    statusCode: 404,
+    headers: { "Content-Type": "text/plain; charset=utf-8" },
+    body: "no calendar feed at this address\n",
+});
+/**
+ * Serves a calendar to whoever holds its secret address.
+ *
+ * The token is the whole credential, so a value that cannot be one is refused
+ * before anything is hashed, and the digest of what arrived is what the store is
+ * asked about — the plaintext is never compared against a stored one because
+ * none is stored.
+ *
+ * `Last-Modified` is the collection's own timestamp, not the newest event in
+ * it: an event deleted from a calendar leaves every survivor older than the
+ * change, and a validator that moves backwards tells a subscriber its cached
+ * copy is still good. The collection is stamped by the same sequence bump every
+ * write and every delete goes through, so it only ever moves forward.
+ *
+ * A row whose collection is gone is the same 404. It should not exist — a
+ * calendar's delete takes its token with it, in one batch — and serving a
+ * blank calendar for one would be worse than saying nothing.
+ */
+export const serveCalendarFeed = async (deps, feedToken, conditions) => {
+    if (!isCalendarFeedToken(feedToken))
+        return feedNotFound();
+    const stored = await deps.calendarFeedToken.findByTokenHash(hashCalendarFeedToken(feedToken));
+    if (!stored)
+        return feedNotFound();
+    const collection = await deps.calendarCollection
+        .get(stored.accountConfigId, stored.calendarId)
+        .catch((error) => {
+        if (error instanceof NotFoundError)
+            return null;
+        throw error;
+    });
+    if (!collection)
+        return feedNotFound();
+    const objects = await deps.calendarObject.listByCalendar(stored.calendarId);
+    const feed = buildCalendarFeed(collection, objects);
+    const etag = `"${feed.etag}"`;
+    const lastModified = new Date(collection.updatedAt).toUTCString();
+    // `If-None-Match` wins outright when both arrive (RFC 9110 13.2.2): the tag
+    // is exact where the date is truncated to the second, so honouring the date
+    // as well could only turn a 200 the tag asked for into a 304.
+    const unchanged = conditions.ifNoneMatch === undefined
+        ? calendarFeedIsUnmodifiedSince(conditions.ifModifiedSince, collection.updatedAt)
+        : calendarFeedIsUnchanged(conditions.ifNoneMatch, feed.etag);
+    if (unchanged) {
+        return rawApiResponse({
+            statusCode: 304,
+            headers: { ETag: etag, "Last-Modified": lastModified },
+            body: "",
+        });
+    }
+    return rawApiResponse({
+        statusCode: 200,
+        headers: {
+            "Content-Type": "text/calendar; charset=utf-8",
+            ETag: etag,
+            "Last-Modified": lastModified,
+        },
+        body: feed.icalData,
+    });
+};
+export const CalendarFeedDetailOperations = {
+    CalendarDetailOperations_getCalendarFeed: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { calendarId } = context.request.params;
+        const deps = calendarDepsOf(await getClient());
+        const found = await findCalendarFeedFor(deps, accountConfigId, calendarId);
+        if (!found.ok)
+            return notFound(found.error.message);
+        return found.value;
+    },
+    CalendarDetailOperations_putCalendarFeed: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { calendarId } = context.request.params;
+        const deps = calendarDepsOf(await getClient());
+        const minted = await putCalendarFeedFor(deps, accountConfigId, calendarId);
+        if (!minted.ok)
+            return notFound(minted.error.message);
+        return minted.value;
+    },
+    CalendarDetailOperations_revokeCalendarFeed: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { calendarId } = context.request.params;
+        const deps = calendarDepsOf(await getClient());
+        const revoked = await revokeCalendarFeedFor(deps, accountConfigId, calendarId);
+        if (!revoked.ok)
+            return notFound(revoked.error.message);
+        return { statusCode: 204 };
+    },
+};
+export const CalendarFeedOperations = {
+    CalendarFeedOperations_getCalendarFeedIcal: async (context, ...args) => {
+        // From the raw path, not from the router's captured parameter: the matcher
+        // substitutes the parameter into the literal path and leaves the dot of
+        // ".ics" as a regex dot, so /feeds/calendar/<token>Xics routes here too —
+        // and answering it would serve the feed at an address nobody was handed.
+        const event = args[0];
+        const feedToken = readCalendarFeedToken(event.path);
+        if (feedToken === null)
+            return feedNotFound();
+        const ifNoneMatch = context.request.headers["if-none-match"];
+        const ifModifiedSince = context.request.headers["if-modified-since"];
+        const deps = calendarDepsOf(await getClient());
+        return serveCalendarFeed(deps, feedToken, {
+            ifNoneMatch: typeof ifNoneMatch === "string" ? ifNoneMatch : undefined,
+            ifModifiedSince: typeof ifModifiedSince === "string" ? ifModifiedSince : undefined,
+        });
+    },
+};

package/dist/src/handlers/calendar-suggestion.d.ts

@@ -0,0 +1,47 @@
+import type { CalendarSuggestionResponse } from "@remit/api-openapi-types";
+import { type CalendarSuggestionItem, type ICalendarSuggestionRepository, type IEnvelopeRepository, type IFilterRepository, type IThreadMessageRepository } from "@remit/data-ports";
+import type { CalendarSuggestionActionOperationIds, CalendarSuggestionOperationIds, MessageCalendarSuggestionOperationIds, OperationHandler } from "../types.js";
+/**
+ * The raw invitation bytes stay on the server. A client renders the projected
+ * fields; the bytes exist so accepting can write them into a calendar
+ * unchanged, and shipping them would invite a second, divergent renderer.
+ */
+export declare const toCalendarSuggestionResponse: (item: CalendarSuggestionItem, answerOvertakenBy: CalendarSuggestionResponse["answerOvertakenBy"]) => CalendarSuggestionResponse;
+export declare const toCalendarSuggestionResponses: (deps: {
+    threadMessage: Pick<IThreadMessageRepository, "findByMessageId">;
+    calendarSuggestion: Pick<ICalendarSuggestionRepository, "listByAcceptedCalendarObjects">;
+}, accountConfigId: string, items: CalendarSuggestionItem[]) => Promise<CalendarSuggestionResponse[]>;
+/**
+ * The states a person can move a pending card into. `Superseded` is the
+ * producer's alone — a revision retires a card, a person never does — and the
+ * rest are terminal.
+ */
+export declare const assertSettleable: (suggestion: CalendarSuggestionItem, target: CalendarSuggestionItem["state"]) => void;
+/** What muting a sender needs, so it can be driven without a live table. */
+export interface MuteSenderDeps {
+    envelope: Pick<IEnvelopeRepository, "getMessageData">;
+    filter: Pick<IFilterRepository, "create" | "listByAccountAndState">;
+}
+/**
+ * The standing rule `dismiss{muteSender:true}` writes: the user saying they do
+ * not want this sender's invitations offered. It goes through the existing
+ * `Filter` entity rather than a second rules table, so it is visible and
+ * editable beside every other rule the user has, and matches on the message's
+ * From address rather than on the invitation's ORGANIZER — a `PUBLISH` names
+ * no organizer at all, and the sender is who the user is refusing.
+ *
+ * At most one rule per sender. Dismissing the same card twice, or muting a
+ * sender already muted from another card, is the same instruction repeated —
+ * a second identical rule would only be a second row for the settings page to
+ * show and the user to delete twice.
+ */
+export declare const muteSender: (deps: MuteSenderDeps, accountConfigId: string, messageId: string) => Promise<void>;
+/**
+ * Moves a card to a decision. Idempotent by design: a client that retries a
+ * decline gets the same answer rather than a 400, and only a card in a
+ * different terminal state is refused.
+ */
+export declare const settleSuggestion: (repo: ICalendarSuggestionRepository, accountConfigId: string, suggestionId: string, state: CalendarSuggestionItem["state"]) => Promise<CalendarSuggestionItem>;
+export declare const CalendarSuggestionOperations: Record<CalendarSuggestionOperationIds, OperationHandler<CalendarSuggestionOperationIds>>;
+export declare const MessageCalendarSuggestionOperations: Record<MessageCalendarSuggestionOperationIds, OperationHandler<MessageCalendarSuggestionOperationIds>>;
+export declare const CalendarSuggestionActionOperations: Record<CalendarSuggestionActionOperationIds, OperationHandler<CalendarSuggestionActionOperationIds>>;

package/dist/src/handlers/calendar-suggestion.js

@@ -0,0 +1,212 @@
+import { acceptCalendarSuggestion, answersOvertakenBy, correctCalendarSuggestion, reopenCalendarSuggestion, } from "@remit/calendar-service";
+import { isSenderMuted, } from "@remit/data-ports";
+import { BadRequestError } from "@remit/data-ports/errors";
+import { CalendarInviteAnswer, CalendarInviteMethod, CalendarSource, CalendarSuggestionState, FilterClauseField, FilterMatchOperator, FilterScope, FilterState, } from "@remit/domain-enums";
+import { getAccountConfigIdFromEvent } from "../auth.js";
+import { getClient } from "../service/data-client.js";
+import { pickEventUpdate } from "./calendar-event.js";
+/**
+ * The raw invitation bytes stay on the server. A client renders the projected
+ * fields; the bytes exist so accepting can write them into a calendar
+ * unchanged, and shipping them would invite a second, divergent renderer.
+ */
+export const toCalendarSuggestionResponse = (item, answerOvertakenBy) => {
+    const { icalData: _icalData, ...response } = item;
+    return { ...response, supersededByThreadId: "", answerOvertakenBy };
+};
+export const toCalendarSuggestionResponses = async (deps, accountConfigId, items) => Promise.all((await answersOvertakenBy(deps.calendarSuggestion, accountConfigId, items)).map(async ({ suggestion, answerOvertakenBy }) => {
+    const response = toCalendarSuggestionResponse(suggestion, answerOvertakenBy);
+    if (suggestion.supersededByMessageId === "")
+        return response;
+    const newer = await deps.threadMessage.findByMessageId(accountConfigId, suggestion.supersededByMessageId);
+    return { ...response, supersededByThreadId: newer?.threadId ?? "" };
+}));
+const respondOne = async (client, accountConfigId, item) => {
+    const [response] = await toCalendarSuggestionResponses(client, accountConfigId, [item]);
+    if (!response)
+        throw new Error("unreachable: one item in, one response out");
+    return response;
+};
+/**
+ * The states a person can move a pending card into. `Superseded` is the
+ * producer's alone — a revision retires a card, a person never does — and the
+ * rest are terminal.
+ */
+export const assertSettleable = (suggestion, target) => {
+    if (suggestion.state === CalendarSuggestionState.Pending)
+        return;
+    if (suggestion.state === target)
+        return;
+    throw new BadRequestError(`This suggestion was already ${suggestion.state.toLowerCase()}, so it can't be ${target.toLowerCase()}.`);
+};
+/**
+ * The mail address the card's event should name as the accepting attendee: the
+ * account the invitation arrived on. Resolved from the message rather than
+ * asked of the client, so an ATTENDEE line can never name an address the user
+ * does not own.
+ */
+const accountEmailForMessage = async (client, messageId) => {
+    const message = await client.message.get(messageId);
+    const accountId = await client.mailbox.resolveAccountId(message.mailboxId);
+    if (!accountId) {
+        throw new BadRequestError("The folder this invitation arrived in is gone, so there is no address to accept as.");
+    }
+    const account = await client.account.get(accountId);
+    return account.email;
+};
+/**
+ * The standing rule `dismiss{muteSender:true}` writes: the user saying they do
+ * not want this sender's invitations offered. It goes through the existing
+ * `Filter` entity rather than a second rules table, so it is visible and
+ * editable beside every other rule the user has, and matches on the message's
+ * From address rather than on the invitation's ORGANIZER — a `PUBLISH` names
+ * no organizer at all, and the sender is who the user is refusing.
+ *
+ * At most one rule per sender. Dismissing the same card twice, or muting a
+ * sender already muted from another card, is the same instruction repeated —
+ * a second identical rule would only be a second row for the settings page to
+ * show and the user to delete twice.
+ */
+export const muteSender = async (deps, accountConfigId, messageId) => {
+    const data = await deps.envelope.getMessageData(messageId);
+    const from = data.envelopeAddress.find((address) => address.addressRole === "from");
+    if (!from) {
+        throw new BadRequestError("This message names no sender, so there is nobody to mute.");
+    }
+    const active = await deps.filter.listByAccountAndState(accountConfigId, FilterState.Active);
+    if (isSenderMuted(active, from.normalizedEmail))
+        return;
+    await deps.filter.create({
+        accountConfigId,
+        name: `Muted invitations from ${from.normalizedEmail}`,
+        scope: FilterScope.Standing,
+        matchOperator: FilterMatchOperator.And,
+        literalClauses: [
+            { field: FilterClauseField.From, value: from.normalizedEmail },
+        ],
+    });
+};
+/**
+ * Moves a card to a decision. Idempotent by design: a client that retries a
+ * decline gets the same answer rather than a 400, and only a card in a
+ * different terminal state is refused.
+ */
+export const settleSuggestion = async (repo, accountConfigId, suggestionId, state) => {
+    const suggestion = await repo.get(accountConfigId, suggestionId);
+    assertSettleable(suggestion, state);
+    if (suggestion.state === state)
+        return suggestion;
+    return repo.settle(accountConfigId, suggestionId, {
+        state,
+        acceptedCalendarObjectId: "",
+    });
+};
+export const CalendarSuggestionOperations = {
+    CalendarSuggestionOperations_listCalendarSuggestions: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { state, continuationToken } = context.request.query;
+        const client = await getClient();
+        const page = await client.calendarSuggestion.listByState(accountConfigId, state, {
+            continuationToken,
+            endsAfter: state === CalendarSuggestionState.Pending
+                ? new Date().toISOString()
+                : new Date(0).toISOString(),
+        });
+        return {
+            items: await toCalendarSuggestionResponses(client, accountConfigId, page.items),
+            continuationToken: page.continuationToken,
+        };
+    },
+};
+export const MessageCalendarSuggestionOperations = {
+    MessageCalendarSuggestionOperations_listMessageCalendarSuggestions: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { messageId } = context.request.params;
+        const client = await getClient();
+        const items = await client.calendarSuggestion.listByMessage(accountConfigId, messageId);
+        return {
+            items: await toCalendarSuggestionResponses(client, accountConfigId, items),
+            continuationToken: undefined,
+        };
+    },
+};
+export const CalendarSuggestionActionOperations = {
+    CalendarSuggestionActionOperations_acceptCalendarSuggestion: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { suggestionId } = context.request.params;
+        const { calendarId, answer = CalendarInviteAnswer.Accepted } = context
+            .request.requestBody;
+        const client = await getClient();
+        const suggestion = await client.calendarSuggestion.get(accountConfigId, suggestionId);
+        if (answer === CalendarInviteAnswer.Tentative &&
+            suggestion.method === CalendarInviteMethod.Cancel) {
+            throw new BadRequestError("This is a cancellation, so there is nothing to answer maybe to.");
+        }
+        assertSettleable(suggestion, answer === CalendarInviteAnswer.Tentative
+            ? CalendarSuggestionState.Tentative
+            : CalendarSuggestionState.Accepted);
+        // Reads the collection through the caller's own account config, so a
+        // calendarId naming somebody else's collection is a 404 before anything
+        // is written into it.
+        const collection = await client.calendarCollection.get(accountConfigId, calendarId);
+        if (collection.source === CalendarSource.Subscribed) {
+            throw new BadRequestError(`"${collection.displayName}" is subscribed to a feed and is read-only — accept the invitation into another calendar`);
+        }
+        const { event: corrections } = context.request.requestBody;
+        const corrected = corrections === undefined
+            ? { ok: true, value: suggestion }
+            : await correctCalendarSuggestion(suggestion, pickEventUpdate(corrections), collection.timezone);
+        if (!corrected.ok) {
+            throw new BadRequestError(corrected.error.message);
+        }
+        const accepted = await acceptCalendarSuggestion(client.calendarStore, {
+            accountConfigId,
+            calendarId,
+            suggestion: corrected.value,
+            attendee: await accountEmailForMessage(client, suggestion.messageId),
+            answer,
+        });
+        if (!accepted.ok) {
+            throw new BadRequestError(accepted.error.message);
+        }
+        return respondOne(client, accountConfigId, accepted.value.suggestion);
+    },
+    CalendarSuggestionActionOperations_declineCalendarSuggestion: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { suggestionId } = context.request.params;
+        const client = await getClient();
+        const declined = await settleSuggestion(client.calendarSuggestion, accountConfigId, suggestionId, CalendarSuggestionState.Declined);
+        return respondOne(client, accountConfigId, declined);
+    },
+    CalendarSuggestionActionOperations_dismissCalendarSuggestion: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { suggestionId } = context.request.params;
+        const body = (context.request.requestBody ?? {});
+        const client = await getClient();
+        const dismissed = await settleSuggestion(client.calendarSuggestion, accountConfigId, suggestionId, CalendarSuggestionState.Dismissed);
+        if (body.muteSender) {
+            await muteSender(client, accountConfigId, dismissed.messageId);
+        }
+        return respondOne(client, accountConfigId, dismissed);
+    },
+    CalendarSuggestionActionOperations_reopenCalendarSuggestion: async (context, ...args) => {
+        const event = args[0];
+        const accountConfigId = getAccountConfigIdFromEvent(event);
+        const { suggestionId } = context.request.params;
+        const client = await getClient();
+        const suggestion = await client.calendarSuggestion.get(accountConfigId, suggestionId);
+        const reopened = await reopenCalendarSuggestion(client.calendarStore, {
+            accountConfigId,
+            suggestion,
+        });
+        if (!reopened.ok) {
+            throw new BadRequestError(reopened.error.message);
+        }
+        return respondOne(client, accountConfigId, reopened.value);
+    },
+};

package/dist/src/handlers/calendar.d.ts

@@ -0,0 +1,116 @@
+import type { CreateCalendarInput, UpdateCalendarInput } from "@remit/api-openapi-types";
+import { type CalendarFeedFetcher } from "@remit/calendar-service";
+import type { CalendarCollectionItem, ICalendarCollectionRepository, ICalendarEventIndexRepository, ICalendarFeedTokenRepository, ICalendarObjectRepository, ICalendarStore, UpdateCalendarCollectionInput } from "@remit/data-ports";
+import type { RemitClient } from "../service/data-client.js";
+import type { CalendarCollectionDetailOperationIds, CalendarDetailOperationIds, CalendarOperationIds, OperationHandler } from "../types.js";
+/** The calendar store, as the handlers reach it. */
+export interface CalendarDeps {
+    calendarCollection: ICalendarCollectionRepository;
+    calendarObject: ICalendarObjectRepository;
+    calendarEventIndex: ICalendarEventIndexRepository;
+    calendarFeedToken: ICalendarFeedTokenRepository;
+    calendarStore: ICalendarStore;
+}
+/** Why a calendar request was refused, in a form a client can branch on. */
+export interface CalendarRefusal {
+    code: string;
+    message: string;
+}
+/**
+ * A refusal is a value here, not a throw. Every one of these is something the
+ * caller sent — a window that runs backwards, a segment already taken, a
+ * RECURRENCE-ID naming no occurrence — so it is an ordinary outcome of the
+ * request rather than a fault of the server's.
+ */
+export type CalendarOutcome<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: CalendarRefusal;
+};
+export declare const refuseCalendar: <T>(code: string, message: string) => CalendarOutcome<T>;
+/**
+ * A 400 keeps the refusal's own code — `unknown_time_zone` and
+ * `url_segment_taken` are what a client branches on, and the status class alone
+ * would not distinguish them. A 404 and a 412 have nothing to add to their
+ * status, so they take the shared token.
+ */
+export declare const badRequest: (error: CalendarRefusal) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+export declare const notFound: (message: string) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+export declare const preconditionFailed: (message: string) => {
+    statusCode: number;
+    body: {
+        code: string;
+        message: string;
+    };
+};
+/** The calendar half of the client, named so a handler takes only what it uses. */
+export declare const calendarDepsOf: (client: RemitClient) => CalendarDeps;
+/**
+ * Every collection the account config holds, provisioning the default one when
+ * it holds none.
+ *
+ * Safe to race with itself: `calendarId` is derived from the account config and
+ * the URL segment, so two first reads arriving together write the same row
+ * rather than two, and the loser's write is a no-op instead of a second
+ * calendar nobody asked for.
+ */
+export declare const listCalendarsFor: (deps: CalendarDeps, accountConfigId: string) => Promise<CalendarCollectionItem[]>;
+/** One of the caller's collections, or a refusal naming the one they asked for. */
+export declare const findCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * One of the caller's collections that a person may write events into. A
+ * subscribed collection holds what its feed holds: an edit made here would be
+ * overwritten by the next refresh, so it is refused rather than accepted and
+ * silently lost.
+ */
+export declare const findWritableCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * A collection's timezone is what every floating time in it is read in, so a
+ * name this server cannot resolve is not a cosmetic setting — it silently moves
+ * every all-day and unzoned event in the calendar. A Windows zone name, which
+ * is what a client that has not normalised its input sends, is refused here
+ * rather than stored and quietly read as UTC.
+ */
+export declare const readCollectionTimezone: (timezone: string | undefined) => CalendarOutcome<string>;
+export declare const createCalendarFor: (deps: CalendarDeps, accountConfigId: string, input: CreateCalendarInput, fetcher?: CalendarFeedFetcher, now?: number) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+/**
+ * Removes a collection with everything in it, in one unit.
+ *
+ * The default collection stays: it is where an accepted invitation and a first
+ * event land, and an account config with no calendar has nowhere to put one.
+ */
+export declare const deleteCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string) => Promise<CalendarOutcome<null>>;
+/**
+ * Reduce a PATCH body to the fields a collection update may set. `urlSegment`
+ * is deliberately absent: it is the collection's identity and the path a client
+ * has bookmarked, so moving it is making a different calendar.
+ */
+export declare const pickCalendarUpdate: (body: Partial<UpdateCalendarInput>) => UpdateCalendarCollectionInput;
+/**
+ * Applies a collection patch, rewriting what the collection's timezone decides.
+ *
+ * The timezone is not a label. Every floating and all-day time in the
+ * collection is read in it, so changing it moves every occurrence row those
+ * resources produced — and a row left at the old zone is an event drawn hours
+ * from where the calendar now says it is. Each resource is therefore written
+ * again from its own stored bytes, which re-projects and re-expands it and
+ * bumps the collection's sequence so a syncing client sees the change. The
+ * whole set is one unit: a half-converted calendar is worse than either zone.
+ */
+export declare const updateCalendarFor: (deps: CalendarDeps, accountConfigId: string, calendarId: string, body: Partial<UpdateCalendarInput>) => Promise<CalendarOutcome<CalendarCollectionItem>>;
+export declare const CalendarOperations: Record<CalendarOperationIds, OperationHandler<CalendarOperationIds>>;
+export declare const CalendarDetailOperations: Record<CalendarCollectionDetailOperationIds, OperationHandler<CalendarDetailOperationIds>>;