@remit/calendar-service 0.0.18 → 0.0.20

package/src/build.test.ts

@@ -1,113 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { CalendarEventStatus, CalendarTransparency } from "@remit/domain-enums";
-import { buildEventCalendar, type CalendarEventFields } from "./build.js";
-import { expandCalendar } from "./expand.js";
-import { parseCalendar } from "./parse.js";
-
-const fields = (
-	overrides: Partial<CalendarEventFields> = {},
-): CalendarEventFields => ({
-	summary: "Stand-up",
-	description: "",
-	location: "",
-	start: "2026-10-15T09:00:00+02:00",
-	end: "2026-10-15T10:00:00+02:00",
-	allDay: false,
-	timeZone: "",
-	status: CalendarEventStatus.Confirmed,
-	transparency: CalendarTransparency.Opaque,
-	recurrenceRule: "",
-	...overrides,
-});
-
-const build = async (overrides: Partial<CalendarEventFields> = {}) =>
-	buildEventCalendar(
-		fields(overrides),
-		"new@reader.remit",
-		new Date("2026-08-29T00:00:00Z"),
-	);
-
-describe("buildEventCalendar", () => {
-	it("writes an event with no zone as the instant it names", async () => {
-		const built = await build();
-
-		assert.ok(built.ok, JSON.stringify(built));
-		assert.ok(built.value.includes("DTSTART:20261015T070000Z"));
-		assert.ok(built.value.includes("DTEND:20261015T080000Z"));
-		assert.ok(built.value.includes("UID:new@reader.remit"));
-		assert.ok(built.value.includes("SUMMARY:Stand-up"));
-		assert.equal(
-			built.value.includes("DESCRIPTION"),
-			false,
-			"an empty field is left out rather than written blank",
-		);
-	});
-
-	it("anchors an event in the zone it names, not in the offset it arrived with", async () => {
-		const built = await build({ timeZone: "Europe/Amsterdam" });
-
-		assert.ok(built.ok);
-		assert.ok(
-			built.value.includes("DTSTART;TZID=Europe/Amsterdam:20261015T090000"),
-		);
-		assert.ok(
-			built.value.includes("DTEND;TZID=Europe/Amsterdam:20261015T100000"),
-		);
-	});
-
-	it("keeps a series at its local hour across a DST transition", async () => {
-		const built = await build({
-			timeZone: "Europe/Amsterdam",
-			recurrenceRule: "FREQ=WEEKLY;COUNT=4",
-		});
-		assert.ok(built.ok);
-
-		const parsed = await parseCalendar(built.value);
-		assert.ok(parsed.ok);
-		const expansion = expandCalendar(parsed.value, "Europe/Amsterdam");
-
-		assert.deepEqual(
-			expansion.occurrences.map((occurrence) => occurrence.startAt),
-			[
-				"2026-10-15T07:00:00Z",
-				"2026-10-22T07:00:00Z",
-				"2026-10-29T08:00:00Z",
-				"2026-11-05T08:00:00Z",
-			],
-		);
-	});
-
-	it("writes an all-day event as civil dates with an exclusive end", async () => {
-		const built = await build({
-			allDay: true,
-			start: "2026-10-15",
-			end: "2026-10-17",
-		});
-
-		assert.ok(built.ok);
-		assert.ok(built.value.includes("DTSTART;VALUE=DATE:20261015"));
-		assert.ok(built.value.includes("DTEND;VALUE=DATE:20261017"));
-	});
-
-	it("refuses a date-time with no zone offset", async () => {
-		const built = await build({ start: "2026-10-15T09:00:00" });
-
-		assert.ok(!built.ok);
-		assert.equal(built.error.code, "InvalidDateTime");
-	});
-
-	it("refuses a zone this server cannot resolve", async () => {
-		const built = await build({ timeZone: "W. Europe Standard Time" });
-
-		assert.ok(!built.ok);
-		assert.equal(built.error.code, "UnknownTimeZone");
-	});
-
-	it("refuses a recurrence rule it cannot read", async () => {
-		const built = await build({ recurrenceRule: "EVERY OTHER TUESDAY" });
-
-		assert.ok(!built.ok);
-		assert.equal(built.error.code, "InvalidRecurrenceRule");
-	});
-});

package/src/build.ts

@@ -1,311 +0,0 @@
-import type { CalendarObjectItem } from "@remit/data-ports";
-import { CalendarEventStatus, CalendarTransparency } from "@remit/domain-enums";
-import ICAL from "ical.js";
-import { type CalendarResult, calendarFailure } from "./errors.js";
-import { serializeCalendar } from "./parse.js";
-import {
-	civilInZone,
-	dtEndTzid,
-	dtStartTzid,
-	isResolvableZone,
-	resolveTime,
-} from "./time.js";
-
-/** Identifies this server in the PRODID of every VCALENDAR it writes. */
-export const CALENDAR_PRODID = "-//Remit//Reader Calendar//EN";
-
-/**
- * An event as a person describes it, before it is iCalendar.
- *
- * Deliberately not a subset of a VEVENT: a client should not have to know that
- * an all-day end is exclusive, that a duration and an end are the same fact
- * written twice, or that a zone lives in a parameter rather than in the value.
- * The server owns iCalendar; this is the shape the API takes and the shape a
- * patch is expressed in.
- */
-export interface CalendarEventFields {
-	summary: string;
-	description: string;
-	location: string;
-	/** ISO 8601 with a zone offset, or `YYYY-MM-DD` when `allDay`. */
-	start: string;
-	/** Same form as `start`. Exclusive for an all-day event. */
-	end: string;
-	allDay: boolean;
-	/** IANA zone the event is anchored in. `""` anchors it in UTC. */
-	timeZone: string;
-	status: CalendarObjectItem["status"];
-	transparency: CalendarObjectItem["transparency"];
-	/** RRULE value without the property name. `""` for a single event. */
-	recurrenceRule: string;
-}
-
-const STATUS_TO_ICAL: Record<CalendarObjectItem["status"], string> = {
-	[CalendarEventStatus.Confirmed]: "CONFIRMED",
-	[CalendarEventStatus.Tentative]: "TENTATIVE",
-	[CalendarEventStatus.Cancelled]: "CANCELLED",
-};
-
-const TRANSPARENCY_TO_ICAL: Record<CalendarObjectItem["transparency"], string> =
-	{
-		[CalendarTransparency.Opaque]: "OPAQUE",
-		[CalendarTransparency.Transparent]: "TRANSPARENT",
-	};
-
-const DATE_ONLY = /^\d{4}-\d{2}-\d{2}/;
-
-/**
- * An offset is required on a date-time. A wall time with no offset names no
- * instant — a client sending `2026-03-29T02:30:00` on the morning the clocks
- * move is asking for a time that happens twice, or not at all — and guessing
- * one is how a calendar quietly puts an event an hour out.
- */
-export const OFFSET_BEARING = /(Z|[+-]\d{2}:\d{2})$/;
-
-/**
- * Reads one API date-time into the iCalendar time the resource will carry.
- *
- * An all-day value becomes a DATE, which is a civil date and has no zone at
- * all. A timed value becomes the wall time it reads as in `timeZone`, so the
- * resource records the zone the event is anchored in rather than the offset
- * that zone happened to be at — which is the whole difference between a weekly
- * 09:00 meeting and a meeting that moves to 08:00 every autumn.
- */
-export const readEventTime = (
-	value: string,
-	allDay: boolean,
-	timeZone: string,
-): CalendarResult<ICAL.Time> => {
-	if (allDay) {
-		const date = DATE_ONLY.exec(value)?.[0];
-		if (!date) {
-			return calendarFailure(
-				"InvalidDateTime",
-				`an all-day event needs a YYYY-MM-DD date, and this one carries "${value}"`,
-			);
-		}
-		const [year, month, day] = date.split("-").map(Number) as [
-			number,
-			number,
-			number,
-		];
-		return {
-			ok: true,
-			value: ICAL.Time.fromData({ year, month, day, isDate: true }),
-		};
-	}
-
-	if (!OFFSET_BEARING.test(value)) {
-		return calendarFailure(
-			"InvalidDateTime",
-			`a date-time needs an explicit zone offset, and this one carries "${value}"`,
-		);
-	}
-	const instantMs = Date.parse(value);
-	if (Number.isNaN(instantMs)) {
-		return calendarFailure(
-			"InvalidDateTime",
-			`"${value}" is not a date-time this server can read`,
-		);
-	}
-	if (timeZone !== "" && !isResolvableZone(timeZone)) {
-		return calendarFailure(
-			"UnknownTimeZone",
-			`"${timeZone}" is not a time zone this server can resolve`,
-		);
-	}
-
-	const civil = civilInZone(instantMs, timeZone === "" ? "UTC" : timeZone);
-	return {
-		ok: true,
-		value: ICAL.Time.fromData(
-			{
-				year: civil.year,
-				month: civil.month,
-				day: civil.day,
-				hour: civil.hour,
-				minute: civil.minute,
-				second: civil.second,
-				isDate: false,
-			},
-			timeZone === "" ? ICAL.Timezone.utcTimezone : ICAL.Timezone.localTimezone,
-		),
-	};
-};
-
-const setTimeProperty = (
-	event: ICAL.Component,
-	name: string,
-	time: ICAL.Time,
-	timeZone: string,
-): void => {
-	event.removeAllProperties(name);
-	const property = new ICAL.Property(name);
-	event.addProperty(property);
-	property.setValue(time);
-	if (!time.isDate && timeZone !== "") {
-		property.setParameter("tzid", timeZone);
-	}
-};
-
-const setTextProperty = (
-	event: ICAL.Component,
-	name: string,
-	value: string,
-): void => {
-	event.removeAllProperties(name);
-	if (value === "") return;
-	event.addPropertyWithValue(name, value);
-};
-
-/** The time fields a stored VEVENT already carries, in the API's own form. */
-export const eventTimeFields = (
-	component: ICAL.Component,
-	collectionTimezone: string,
-): Pick<CalendarEventFields, "start" | "end" | "allDay" | "timeZone"> => {
-	const event = new ICAL.Event(component);
-	const startTzid = dtStartTzid(component);
-	const start = resolveTime(event.startDate, startTzid, collectionTimezone);
-	const end = resolveTime(
-		event.endDate,
-		dtEndTzid(component),
-		collectionTimezone,
-	);
-	return {
-		start: start.isoOffset,
-		end: end.isoOffset,
-		allDay: start.isDate,
-		timeZone: startTzid,
-	};
-};
-
-/**
- * ical.js's recurrence parser in a promise, so an unreadable rule arrives as a
- * value to branch on rather than a synchronous throw.
- *
- * A rule with no FREQ is refused rather than stored. ical.js reads text it
- * finds no parts in as a rule with a null frequency instead of failing, and
- * storing that would give somebody an event marked as recurring that produces
- * nothing — the failure a client cannot see and cannot fix.
- */
-export const readRecurrenceRule = (
-	recurrenceRule: string,
-): Promise<CalendarResult<ICAL.Recur>> =>
-	new Promise<ICAL.Recur>((resolve) => {
-		resolve(ICAL.Recur.fromString(recurrenceRule));
-	}).then(
-		(value) =>
-			value.freq
-				? ({ ok: true, value } as const)
-				: calendarFailure<ICAL.Recur>(
-						"InvalidRecurrenceRule",
-						`"${recurrenceRule}" names no FREQ, so it is not a recurrence rule`,
-					),
-		(error: unknown) =>
-			calendarFailure<ICAL.Recur>(
-				"InvalidRecurrenceRule",
-				error instanceof Error
-					? error.message
-					: `"${recurrenceRule}" is not a recurrence rule this server can read`,
-			),
-	);
-
-/**
- * Writes a patch onto a VEVENT.
- *
- * A field the patch does not carry is untouched, so renaming an event moves
- * nothing. The time fields are the exception: zone, all-day-ness, start and end
- * are one fact between them, so touching any of them rewrites DTSTART and DTEND
- * together from the values the event would then have. Rewriting only the one
- * the caller named is what produces an event that starts in one zone and ends
- * in another.
- */
-export const applyEventFields = async (
-	component: ICAL.Component,
-	patch: Partial<CalendarEventFields>,
-	collectionTimezone: string,
-): Promise<CalendarResult<null>> => {
-	if (patch.summary !== undefined) {
-		setTextProperty(component, "summary", patch.summary);
-	}
-	if (patch.description !== undefined) {
-		setTextProperty(component, "description", patch.description);
-	}
-	if (patch.location !== undefined) {
-		setTextProperty(component, "location", patch.location);
-	}
-	if (patch.status !== undefined) {
-		setTextProperty(component, "status", STATUS_TO_ICAL[patch.status]);
-	}
-	if (patch.transparency !== undefined) {
-		setTextProperty(
-			component,
-			"transp",
-			TRANSPARENCY_TO_ICAL[patch.transparency],
-		);
-	}
-
-	if (patch.recurrenceRule !== undefined) {
-		component.removeAllProperties("rrule");
-		if (patch.recurrenceRule !== "") {
-			const rule = await readRecurrenceRule(patch.recurrenceRule);
-			if (!rule.ok) return rule;
-			component.addPropertyWithValue("rrule", rule.value);
-		}
-	}
-
-	const touchesTime =
-		patch.start !== undefined ||
-		patch.end !== undefined ||
-		patch.allDay !== undefined ||
-		patch.timeZone !== undefined;
-	if (!touchesTime) return { ok: true, value: null };
-
-	// A VEVENT being built from nothing has no times to read back, and every one
-	// of them is in the patch. The empty start then refuses a create that left
-	// one out, which is the same answer reading it back would have given.
-	const current = component.hasProperty("dtstart")
-		? eventTimeFields(component, collectionTimezone)
-		: { start: "", end: "", allDay: false, timeZone: "" };
-	const allDay = patch.allDay ?? current.allDay;
-	const timeZone = patch.timeZone ?? current.timeZone;
-	const start = readEventTime(patch.start ?? current.start, allDay, timeZone);
-	if (!start.ok) return start;
-	const end = readEventTime(patch.end ?? current.end, allDay, timeZone);
-	if (!end.ok) return end;
-
-	// A duration says the same thing DTEND does, and leaving one behind beside a
-	// rewritten DTEND leaves two answers to how long the event is.
-	component.removeAllProperties("duration");
-	setTimeProperty(component, "dtstart", start.value, timeZone);
-	setTimeProperty(component, "dtend", end.value, timeZone);
-	return { ok: true, value: null };
-};
-
-/**
- * Builds the VCALENDAR text for a new event.
- *
- * The output goes straight to the single write path, which parses it again to
- * validate and project it. That second read is not waste: it is the same gate
- * every other writer passes, so an event this function got wrong is refused
- * here rather than stored.
- */
-export const buildEventCalendar = async (
-	fields: CalendarEventFields,
-	uid: string,
-	now: Date = new Date(),
-): Promise<CalendarResult<string>> => {
-	const calendar = new ICAL.Component("vcalendar");
-	calendar.addPropertyWithValue("version", "2.0");
-	calendar.addPropertyWithValue("prodid", CALENDAR_PRODID);
-
-	const event = new ICAL.Component("vevent");
-	calendar.addSubcomponent(event);
-	event.addPropertyWithValue("uid", uid);
-	event.addPropertyWithValue("dtstamp", ICAL.Time.fromJSDate(now, true));
-
-	const applied = await applyEventFields(event, fields, fields.timeZone);
-	if (!applied.ok) return applied;
-
-	return { ok: true, value: serializeCalendar(calendar) };
-};

package/src/correct.test.ts

@@ -1,173 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { CalendarSuggestionItem } from "@remit/data-ports";
-import {
-	CalendarInviteAnswer,
-	CalendarSuggestionSource,
-	CalendarSuggestionState,
-	ZoneCertainty,
-} from "@remit/domain-enums";
-import { acceptCalendarSuggestion } from "./accept.js";
-import type { CalendarEventFields } from "./build.js";
-import { correctCalendarSuggestion } from "./correct.js";
-import { ical } from "./fixtures.js";
-import { MemoryCalendarStore } from "./memory-store.js";
-import { provisionDefaultCalendar } from "./put.js";
-import { recordCalendarSuggestion } from "./suggest.js";
-
-const ACCOUNT_CONFIG_ID = "account-config-1";
-const ATTENDEE = "user@example.test";
-const UID = "invite-5120@example.test";
-
-const invitation = ({
-	method = "REQUEST",
-	start = "DTSTART:20260901T080000Z",
-	end = "DTEND:20260901T090000Z",
-}: {
-	method?: string;
-	start?: string;
-	end?: string;
-}): string =>
-	ical(
-		"BEGIN:VCALENDAR",
-		"VERSION:2.0",
-		"PRODID:-//Example Corp//Scheduler//EN",
-		`METHOD:${method}`,
-		"BEGIN:VEVENT",
-		`UID:${UID}`,
-		"DTSTAMP:20260801T090000Z",
-		"SEQUENCE:2",
-		start,
-		end,
-		"SUMMARY:Quarterly review",
-		"LOCATION:Room 4",
-		"ORGANIZER:mailto:organizer@example.test",
-		"ATTENDEE;PARTSTAT=NEEDS-ACTION:mailto:user@example.test",
-		"X-EXAMPLE-TICKET:AB-5120",
-		"END:VEVENT",
-		"END:VCALENDAR",
-	);
-
-const pendingIn = async (icalData: string) => {
-	const store = new MemoryCalendarStore();
-	const collection = await provisionDefaultCalendar(store, ACCOUNT_CONFIG_ID);
-	const recorded = await recordCalendarSuggestion(store.calendarSuggestion, {
-		accountConfigId: ACCOUNT_CONFIG_ID,
-		messageId: "message-1",
-		bodyPartId: "body-part-1",
-		source: CalendarSuggestionSource.IcalendarPart,
-		icalData,
-		timezone: "UTC",
-	});
-	assert.ok(recorded.ok);
-	return {
-		store,
-		calendarId: collection.calendarId,
-		suggestion: recorded.value.suggestion,
-	};
-};
-
-const acceptCorrected = async (
-	store: MemoryCalendarStore,
-	calendarId: string,
-	suggestion: CalendarSuggestionItem,
-	patch: Partial<CalendarEventFields>,
-) => {
-	const corrected = await correctCalendarSuggestion(suggestion, patch, "UTC");
-	if (!corrected.ok) return corrected;
-	return acceptCalendarSuggestion(store, {
-		accountConfigId: ACCOUNT_CONFIG_ID,
-		calendarId,
-		suggestion: corrected.value,
-		attendee: ATTENDEE,
-		answer: CalendarInviteAnswer.Accepted,
-	});
-};
-
-describe("correctCalendarSuggestion", () => {
-	it("writes the corrected event and settles the card as accepted", async () => {
-		const { store, calendarId, suggestion } = await pendingIn(invitation({}));
-
-		const accepted = await acceptCorrected(store, calendarId, suggestion, {
-			summary: "Quarterly review, moved",
-			start: "2026-09-01T13:00:00+00:00",
-			end: "2026-09-01T14:30:00+00:00",
-			allDay: false,
-			timeZone: "",
-		});
-
-		assert.ok(accepted.ok);
-		const object = accepted.value.object;
-		assert.ok(object);
-		assert.equal(object.summary, "Quarterly review, moved");
-		assert.equal(Date.parse(object.dtStart), Date.parse("2026-09-01T13:00Z"));
-		assert.equal(Date.parse(object.dtEnd), Date.parse("2026-09-01T14:30Z"));
-		assert.equal(object.icalUid, UID);
-		assert.match(object.icalData, /LOCATION:Room 4/);
-		assert.match(object.icalData, /X-EXAMPLE-TICKET:AB-5120/);
-		assert.match(object.icalData, /PARTSTAT=ACCEPTED/);
-
-		const settled = await store.calendarSuggestion.get(
-			ACCOUNT_CONFIG_ID,
-			suggestion.suggestionId,
-		);
-		assert.equal(settled.state, CalendarSuggestionState.Accepted);
-		assert.equal(settled.acceptedCalendarObjectId, object.calendarObjectId);
-	});
-
-	it("places an unresolvable zone on the clock the reader picked", async () => {
-		const { store, calendarId, suggestion } = await pendingIn(
-			invitation({
-				start: "DTSTART;TZID=Nowhere Standard Time:20260901T090000",
-				end: "DTEND;TZID=Nowhere Standard Time:20260901T100000",
-			}),
-		);
-		assert.equal(suggestion.zoneCertainty, ZoneCertainty.Ambiguous);
-
-		const accepted = await acceptCorrected(store, calendarId, suggestion, {
-			start: "2026-09-01T09:00:00+02:00",
-			end: "2026-09-01T10:00:00+02:00",
-			allDay: false,
-			timeZone: "Europe/Amsterdam",
-		});
-
-		assert.ok(accepted.ok);
-		const object = accepted.value.object;
-		assert.ok(object);
-		assert.equal(object.zoneCertainty, ZoneCertainty.Explicit);
-		assert.equal(Date.parse(object.dtStart), Date.parse("2026-09-01T07:00Z"));
-		assert.match(
-			object.icalData,
-			/DTSTART;TZID=Europe\/Amsterdam:20260901T090000/,
-		);
-	});
-
-	it("refuses a cancellation and leaves the card waiting", async () => {
-		const { store, calendarId, suggestion } = await pendingIn(
-			invitation({ method: "CANCEL" }),
-		);
-
-		const refused = await acceptCorrected(store, calendarId, suggestion, {
-			summary: "Anything",
-		});
-
-		assert.equal(refused.ok, false);
-		assert.equal(store.objects.size, 0);
-		const untouched = await store.calendarSuggestion.get(
-			ACCOUNT_CONFIG_ID,
-			suggestion.suggestionId,
-		);
-		assert.equal(untouched.state, CalendarSuggestionState.Pending);
-	});
-
-	it("refuses a correction the event cannot take and writes nothing", async () => {
-		const { store, calendarId, suggestion } = await pendingIn(invitation({}));
-
-		const refused = await acceptCorrected(store, calendarId, suggestion, {
-			start: "2026-09-01T13:00:00",
-		});
-
-		assert.equal(refused.ok, false);
-		assert.equal(store.objects.size, 0);
-	});
-});

package/src/correct.ts

@@ -1,40 +0,0 @@
-import type { CalendarSuggestionItem } from "@remit/data-ports";
-import { CalendarInviteMethod, RecurrenceScope } from "@remit/domain-enums";
-import type { CalendarEventFields } from "./build.js";
-import { type CalendarResult, calendarFailure } from "./errors.js";
-import { parseCalendar } from "./parse.js";
-import { applyScopedUpdate } from "./scope.js";
-
-export const correctCalendarSuggestion = async (
-	suggestion: CalendarSuggestionItem,
-	patch: Partial<CalendarEventFields>,
-	collectionTimezone: string,
-): Promise<CalendarResult<CalendarSuggestionItem>> => {
-	if (suggestion.method === CalendarInviteMethod.Cancel) {
-		return calendarFailure(
-			"UneditableCancellation",
-			"a cancellation names no event to correct — add it or dismiss it as it is",
-		);
-	}
-
-	const parsed = await parseCalendar(suggestion.icalData);
-	if (!parsed.ok) return parsed;
-
-	const edited = await applyScopedUpdate(
-		parsed.value,
-		collectionTimezone,
-		{ scope: RecurrenceScope.All, recurrenceId: "", followingUid: "" },
-		patch,
-	);
-	if (!edited.ok) return edited;
-	if (edited.value.kind !== "Replace") {
-		throw new Error(
-			`an edit to the whole invitation resolved to a ${edited.value.kind}`,
-		);
-	}
-
-	return {
-		ok: true,
-		value: { ...suggestion, icalData: edited.value.icalData },
-	};
-};

package/src/errors.ts

@@ -1,62 +0,0 @@
-/**
- * Why a VCALENDAR was refused. Every value names something the writer can act
- * on — a caller maps these to a 4xx and repeats the message.
- */
-export type CalendarValidationCode =
-	/** The bytes are not parseable iCalendar at all. */
-	| "MalformedIcalendar"
-	/** The document's root is not a VCALENDAR. */
-	| "NotACalendar"
-	/** A component this collection does not store, e.g. VTODO or VJOURNAL. */
-	| "UnsupportedComponent"
-	/** A VCALENDAR with no VEVENT in it. */
-	| "NoEvent"
-	/** No VEVENT without a RECURRENCE-ID: overrides with nothing to override. */
-	| "NoMasterEvent"
-	/** More than one VEVENT without a RECURRENCE-ID. */
-	| "MultipleMasterEvents"
-	/** A VEVENT with no UID, or an empty one. */
-	| "MissingUid"
-	/** VEVENTs in one resource declaring different UIDs. */
-	| "MismatchedUid"
-	/** A VEVENT with no DTSTART. */
-	| "MissingDtStart"
-	/** A VEVENT whose end precedes its start. */
-	| "BackwardsEnd"
-	/** A start or end that is not a date-time this server can read. */
-	| "InvalidDateTime"
-	/** A time zone name nothing on this platform resolves. */
-	| "UnknownTimeZone"
-	/** An RRULE value ical.js could not read. */
-	| "InvalidRecurrenceRule"
-	/** A scoped write that names one occurrence without saying which. */
-	| "MissingRecurrenceId"
-	/** A per-occurrence scope against an event that has one occurrence. */
-	| "NotRecurring"
-	/** A RECURRENCE-ID naming no occurrence this series produces. */
-	| "UnknownOccurrence"
-	| "UnmovableRecurrenceRule"
-	| "UneditableCancellation"
-	/** A subscription address that is not an http, https or webcal URL. */
-	| "InvalidSubscriptionUrl"
-	| "NotReopenable"
-	| "AnswerOvertaken";
-
-export interface CalendarValidationError {
-	code: CalendarValidationCode;
-	message: string;
-}
-
-/**
- * The outcome of reading a VCALENDAR. A refusal is a value, not a throw:
- * malformed input from a client is an expected outcome of this boundary, and
- * every caller has to render it rather than crash on it.
- */
-export type CalendarResult<T> =
-	| { ok: true; value: T }
-	| { ok: false; error: CalendarValidationError };
-
-export const calendarFailure = <T>(
-	code: CalendarValidationCode,
-	message: string,
-): CalendarResult<T> => ({ ok: false, error: { code, message } });