riverbankcms 0.2.0 → 0.2.2

package/dist/sdk-event-upsert-BCZUdIrL.mjs

@@ -0,0 +1,887 @@
+#!/usr/bin/env node
+import { A as parseUtcIsoDateTimeString, P as parseBookingTimeZone } from "./src-XEJYAKbQ.mjs";
+import { z } from "zod";
+
+//#region ../api/src/sdk-event-payment-terms.ts
+const supportedKinds = new Set([
+	"upfront",
+	"deferred_manual",
+	"flexible_balance"
+]);
+function issue$2(path, message) {
+	return {
+		path,
+		message
+	};
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWholeNumber$1(value) {
+	return typeof value === "number" && Number.isInteger(value);
+}
+function isPositiveWholeNumber(value) {
+	return isWholeNumber$1(value) && value > 0;
+}
+function isDepositRefundability(value) {
+	return value === "refundable" || value === "non_refundable";
+}
+function isSupportedOptionKind(value) {
+	return typeof value === "string" && supportedKinds.has(value);
+}
+function validateFlexibleBalanceDueDateRule(raw, path) {
+	if (!isRecord$1(raw)) {
+		return [issue$2(path, "Flexible balance dueDateRule must be an object")];
+	}
+	if (raw.kind === "relative_to_start_date") {
+		if (!isPositiveWholeNumber(raw.daysBeforeStart)) {
+			return [issue$2([...path, "daysBeforeStart"], "Flexible balance daysBeforeStart must be a positive integer")];
+		}
+		return {
+			kind: "relative_to_start_date",
+			daysBeforeStart: raw.daysBeforeStart
+		};
+	}
+	if (raw.kind === "fixed_calendar_date") {
+		if (typeof raw.dueAt !== "string" || !Number.isFinite(Date.parse(raw.dueAt))) {
+			return [issue$2([...path, "dueAt"], "Flexible balance fixed dueAt must be an ISO datetime")];
+		}
+		return {
+			kind: "fixed_calendar_date",
+			dueAt: raw.dueAt
+		};
+	}
+	return [issue$2([...path, "kind"], "Flexible balance dueDateRule kind must be relative_to_start_date or fixed_calendar_date")];
+}
+function validateFlexibleBalanceConfig(raw, path) {
+	if (!isRecord$1(raw)) {
+		return [issue$2(path, "Flexible balance config must be an object")];
+	}
+	const issues = [];
+	const upfrontAmountCents = raw.upfrontAmountCents;
+	const depositRefundability = raw.depositRefundability;
+	let validatedUpfrontAmountCents = null;
+	let validatedDepositRefundability = null;
+	if (!isWholeNumber$1(upfrontAmountCents) || upfrontAmountCents < 0) {
+		issues.push(issue$2([...path, "upfrontAmountCents"], "Flexible balance upfrontAmountCents must be a non-negative integer"));
+	} else {
+		validatedUpfrontAmountCents = upfrontAmountCents;
+	}
+	if (!isDepositRefundability(depositRefundability)) {
+		issues.push(issue$2([...path, "depositRefundability"], "Flexible balance depositRefundability must be refundable or non_refundable"));
+	} else {
+		validatedDepositRefundability = depositRefundability;
+	}
+	const dueDateRule = validateFlexibleBalanceDueDateRule(raw.dueDateRule, [...path, "dueDateRule"]);
+	if (Array.isArray(dueDateRule)) {
+		issues.push(...dueDateRule);
+	}
+	if (issues.length > 0 || Array.isArray(dueDateRule) || validatedUpfrontAmountCents === null || validatedDepositRefundability === null) {
+		return issues;
+	}
+	return {
+		upfrontAmountCents: validatedUpfrontAmountCents,
+		depositRefundability: validatedDepositRefundability,
+		dueDateRule
+	};
+}
+function validateCollectionOption(raw, index) {
+	const path = ["allowedOptions", String(index)];
+	if (!isRecord$1(raw)) {
+		return [issue$2(path, "Payment option must be an object")];
+	}
+	if (raw.kind === "instalment_plan") {
+		return [issue$2([...path, "kind"], "Event instalment plans are not supported yet. Use upfront, deferred_manual, or flexible_balance.")];
+	}
+	if (!isSupportedOptionKind(raw.kind)) {
+		return [issue$2([...path, "kind"], "Payment option kind must be upfront, deferred_manual, or flexible_balance")];
+	}
+	switch (raw.kind) {
+		case "upfront":
+		case "deferred_manual": return { kind: raw.kind };
+		case "flexible_balance": {
+			const config = validateFlexibleBalanceConfig(raw.config, [...path, "config"]);
+			if (Array.isArray(config)) {
+				return config;
+			}
+			return {
+				kind: "flexible_balance",
+				config
+			};
+		}
+	}
+}
+function optionCombinationIssues(options) {
+	const issues = [];
+	const seenKinds = new Set();
+	options.forEach((option, index) => {
+		if (seenKinds.has(option.kind)) {
+			issues.push(issue$2([
+				"allowedOptions",
+				String(index),
+				"kind"
+			], `Duplicate payment option kind "${option.kind}"`));
+		}
+		seenKinds.add(option.kind);
+	});
+	if (options.length > 2) {
+		issues.push(issue$2(["allowedOptions"], "Event payment terms can offer one option, or a choice between upfront and one alternative option"));
+	}
+	if (options.length === 2 && (!seenKinds.has("upfront") || !seenKinds.has("deferred_manual") && !seenKinds.has("flexible_balance"))) {
+		issues.push(issue$2(["allowedOptions"], "Event payment terms with two options must combine upfront with deferred_manual or flexible_balance"));
+	}
+	return issues;
+}
+function classifySdkEventPaymentTerms(rawInput) {
+	if (rawInput === undefined || rawInput === null) {
+		return {
+			ok: true,
+			paymentTerms: undefined
+		};
+	}
+	if (!isRecord$1(rawInput)) {
+		return {
+			ok: false,
+			issues: [issue$2([], "Event paymentTerms must be an object")]
+		};
+	}
+	if (!Array.isArray(rawInput.allowedOptions)) {
+		return {
+			ok: false,
+			issues: [issue$2(["allowedOptions"], "Event paymentTerms.allowedOptions is required")]
+		};
+	}
+	if (rawInput.allowedOptions.length === 0) {
+		return {
+			ok: false,
+			issues: [issue$2(["allowedOptions"], "Event paymentTerms.allowedOptions must include at least one option")]
+		};
+	}
+	const options = [];
+	const issues = [];
+	rawInput.allowedOptions.forEach((option, index) => {
+		const validated = validateCollectionOption(option, index);
+		if (Array.isArray(validated)) {
+			issues.push(...validated);
+			return;
+		}
+		options.push(validated);
+	});
+	issues.push(...optionCombinationIssues(options));
+	if (issues.length > 0) {
+		return {
+			ok: false,
+			issues
+		};
+	}
+	return {
+		ok: true,
+		paymentTerms: { allowedOptions: options }
+	};
+}
+
+//#endregion
+//#region ../api/src/sdk-event-pricing.ts
+const identifierRegex = /^[a-z0-9][a-z0-9-]*$/;
+const currencyRegex = /^[A-Z]{3}$/;
+const isoDateTimeRegex = /^\d{4}-\d{2}-\d{2}T.+/;
+function issue$1(path, message) {
+	return {
+		path,
+		message
+	};
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isCurrency(value) {
+	return typeof value === "string" && currencyRegex.test(value);
+}
+function isWholeNumber(value) {
+	return typeof value === "number" && Number.isInteger(value);
+}
+function isWholeMinuteIsoDateTime(value) {
+	if (!isoDateTimeRegex.test(value)) return false;
+	const epochMs = Date.parse(value);
+	return Number.isFinite(epochMs) && epochMs % 6e4 === 0;
+}
+function validateTicketType(raw, index, currency) {
+	const path = ["ticketTypes", String(index)];
+	if (!isRecord(raw)) return [issue$1(path, "Ticket type must be an object")];
+	const issues = [];
+	const identifier = raw.identifier;
+	if (typeof identifier !== "string" || !identifierRegex.test(identifier)) {
+		issues.push(issue$1([...path, "identifier"], "Ticket identifier must use lowercase letters, numbers, and hyphens"));
+	}
+	const name = raw.name;
+	if (typeof name !== "string" || name.trim().length === 0) {
+		issues.push(issue$1([...path, "name"], "Ticket name is required"));
+	}
+	const priceAmount = raw.priceAmount;
+	if (!isWholeNumber(priceAmount) || priceAmount < 0) {
+		issues.push(issue$1([...path, "priceAmount"], "Ticket priceAmount must be a non-negative integer"));
+	}
+	const priceCurrency = raw.priceCurrency;
+	if (priceCurrency !== undefined && priceCurrency !== null && priceCurrency !== currency) {
+		issues.push(issue$1([...path, "priceCurrency"], "Ticket priceCurrency must match pricing.priceCurrency"));
+	}
+	const sortOrder = raw.sortOrder;
+	if (sortOrder !== undefined && (!isWholeNumber(sortOrder) || sortOrder < 0)) {
+		issues.push(issue$1([...path, "sortOrder"], "Ticket sortOrder must be a non-negative integer"));
+	}
+	const capacityLimit = raw.capacityLimit;
+	if (capacityLimit !== undefined && capacityLimit !== null && (!isWholeNumber(capacityLimit) || capacityLimit < 1)) {
+		issues.push(issue$1([...path, "capacityLimit"], "Ticket capacityLimit must be a positive integer"));
+	}
+	const attendanceScope = raw.attendanceScope;
+	if (attendanceScope !== undefined && attendanceScope !== "in_person" && attendanceScope !== "online" && attendanceScope !== "both") {
+		issues.push(issue$1([...path, "attendanceScope"], "Ticket attendanceScope must be in_person, online, or both"));
+	}
+	const saleStartsAt = raw.saleStartsAt;
+	if (saleStartsAt !== undefined && saleStartsAt !== null && (typeof saleStartsAt !== "string" || !isWholeMinuteIsoDateTime(saleStartsAt))) {
+		issues.push(issue$1([...path, "saleStartsAt"], "Ticket saleStartsAt must be an ISO datetime aligned to a whole minute"));
+	}
+	const saleEndsAt = raw.saleEndsAt;
+	if (saleEndsAt !== undefined && saleEndsAt !== null && (typeof saleEndsAt !== "string" || !isWholeMinuteIsoDateTime(saleEndsAt))) {
+		issues.push(issue$1([...path, "saleEndsAt"], "Ticket saleEndsAt must be an ISO datetime aligned to a whole minute"));
+	}
+	if (typeof saleStartsAt === "string" && typeof saleEndsAt === "string" && Date.parse(saleEndsAt) <= Date.parse(saleStartsAt)) {
+		issues.push(issue$1([...path, "saleEndsAt"], "Ticket saleEndsAt must be after saleStartsAt"));
+	}
+	const cmsTicketTypeId = raw.cmsTicketTypeId;
+	if (cmsTicketTypeId !== undefined && cmsTicketTypeId !== null && (typeof cmsTicketTypeId !== "string" || cmsTicketTypeId.length === 0)) {
+		issues.push(issue$1([...path, "cmsTicketTypeId"], "Ticket cmsTicketTypeId must be a non-empty string"));
+	}
+	if (issues.length > 0) return issues;
+	return {
+		identifier,
+		...cmsTicketTypeId ? { cmsTicketTypeId } : {},
+		name,
+		description: typeof raw.description === "string" ? raw.description : null,
+		priceAmount,
+		isActive: typeof raw.isActive === "boolean" ? raw.isActive : true,
+		sortOrder: isWholeNumber(sortOrder) ? sortOrder : index,
+		capacityLimit: isWholeNumber(capacityLimit) ? capacityLimit : null,
+		attendanceScope: attendanceScope === "in_person" || attendanceScope === "online" || attendanceScope === "both" ? attendanceScope : "both",
+		saleStartsAt: typeof saleStartsAt === "string" ? saleStartsAt : null,
+		saleEndsAt: typeof saleEndsAt === "string" ? saleEndsAt : null
+	};
+}
+function validateTicketTypes(rawTicketTypes, currency) {
+	if (!Array.isArray(rawTicketTypes) || rawTicketTypes.length === 0) {
+		return [issue$1(["ticketTypes"], "Ticket-type pricing requires at least one ticket type")];
+	}
+	const issues = [];
+	const ticketTypes = [];
+	const seenIdentifiers = new Set();
+	rawTicketTypes.forEach((rawTicketType, index) => {
+		const rawIdentifier = isRecord(rawTicketType) ? rawTicketType.identifier : undefined;
+		const hasValidIdentifier = typeof rawIdentifier === "string" && identifierRegex.test(rawIdentifier);
+		const isDuplicateIdentifier = hasValidIdentifier && seenIdentifiers.has(rawIdentifier);
+		if (isDuplicateIdentifier) {
+			issues.push(issue$1([
+				"ticketTypes",
+				String(index),
+				"identifier"
+			], `Duplicate ticket identifier "${rawIdentifier}"`));
+		} else if (hasValidIdentifier) {
+			seenIdentifiers.add(rawIdentifier);
+		}
+		const parsed = validateTicketType(rawTicketType, index, currency);
+		if (Array.isArray(parsed)) {
+			issues.push(...parsed);
+			return;
+		}
+		if (isDuplicateIdentifier) {
+			return;
+		}
+		ticketTypes.push(parsed);
+	});
+	if (issues.length > 0) return issues;
+	return sortSdkEventTicketTypes(ticketTypes);
+}
+function isPricingIssueArray(value) {
+	const first = value[0];
+	return first !== undefined && "message" in first;
+}
+function sortSdkEventTicketTypes(ticketTypes) {
+	return [...ticketTypes].sort((left, right) => {
+		const leftOrder = left.sortOrder ?? Number.MAX_SAFE_INTEGER;
+		const rightOrder = right.sortOrder ?? Number.MAX_SAFE_INTEGER;
+		if (leftOrder !== rightOrder) return leftOrder - rightOrder;
+		const identifierCompare = left.identifier.localeCompare(right.identifier);
+		if (identifierCompare !== 0) return identifierCompare;
+		return left.name.localeCompare(right.name);
+	});
+}
+function suggestSdkEventTicketIdentifier(name, usedIdentifiers) {
+	const base = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "ticket";
+	let candidate = base;
+	let suffix = 2;
+	while (usedIdentifiers.has(candidate)) {
+		candidate = `${base}-${suffix}`;
+		suffix += 1;
+	}
+	return candidate;
+}
+function classifySdkEventPricing(rawInput) {
+	if (rawInput === undefined || rawInput === null) {
+		return {
+			ok: true,
+			pricing: { kind: "free" }
+		};
+	}
+	if (!isRecord(rawInput)) {
+		return {
+			ok: false,
+			issues: [issue$1([], "Pricing must be an object")]
+		};
+	}
+	const record = rawInput;
+	const kind = typeof record.kind === "string" ? record.kind : record.pricingMode === "ticket_types" ? "ticket_types" : record.pricingMode === "fixed_price" ? "fixed_price" : record.pricingMode === "free" ? "free" : record.requiresPayment || typeof record.priceAmount === "number" && record.priceAmount > 0 ? "fixed_price" : "free";
+	const acceptsPasses = typeof record.acceptsPasses === "boolean" ? record.acceptsPasses : undefined;
+	const acceptsMemberships = typeof record.acceptsMemberships === "boolean" ? record.acceptsMemberships : undefined;
+	const priceDisplay = typeof record.priceDisplay === "string" ? record.priceDisplay : null;
+	switch (kind) {
+		case "free": return {
+			ok: true,
+			pricing: {
+				kind: "free",
+				priceDisplay,
+				...acceptsPasses !== undefined ? { acceptsPasses } : {},
+				...acceptsMemberships !== undefined ? { acceptsMemberships } : {}
+			}
+		};
+		case "fixed_price": {
+			const issues = [];
+			const priceAmount = record.priceAmount;
+			if (!isWholeNumber(priceAmount) || priceAmount < 0) {
+				issues.push(issue$1(["priceAmount"], "Fixed-price events require a non-negative integer priceAmount"));
+			}
+			const rawPriceCurrency = record.priceCurrency;
+			const priceCurrency = rawPriceCurrency === undefined || rawPriceCurrency === null ? "USD" : isCurrency(rawPriceCurrency) ? rawPriceCurrency : null;
+			if (rawPriceCurrency !== undefined && rawPriceCurrency !== null && !isCurrency(rawPriceCurrency)) {
+				issues.push(issue$1(["priceCurrency"], "priceCurrency must be a 3-letter uppercase currency code"));
+			}
+			if (issues.length > 0) return {
+				ok: false,
+				issues
+			};
+			if (!isWholeNumber(priceAmount) || priceCurrency === null) {
+				return {
+					ok: false,
+					issues: [issue$1(["priceAmount"], "Invalid fixed-price event pricing")]
+				};
+			}
+			return {
+				ok: true,
+				pricing: {
+					kind: "fixed_price",
+					priceAmount,
+					priceCurrency,
+					priceDisplay,
+					...acceptsPasses !== undefined ? { acceptsPasses } : {},
+					...acceptsMemberships !== undefined ? { acceptsMemberships } : {}
+				}
+			};
+		}
+		case "ticket_types": {
+			const priceCurrency = record.priceCurrency;
+			if (!isCurrency(priceCurrency)) {
+				return {
+					ok: false,
+					issues: [issue$1(["priceCurrency"], "Ticket-type pricing requires a 3-letter uppercase priceCurrency")]
+				};
+			}
+			const ticketTypes = record.ticketTypes === undefined || record.ticketTypes === null ? [] : validateTicketTypes(record.ticketTypes, priceCurrency);
+			if (isPricingIssueArray(ticketTypes)) {
+				return {
+					ok: false,
+					issues: ticketTypes
+				};
+			}
+			return {
+				ok: true,
+				pricing: {
+					kind: "ticket_types",
+					priceCurrency,
+					priceDisplay,
+					...acceptsPasses !== undefined ? { acceptsPasses } : {},
+					...acceptsMemberships !== undefined ? { acceptsMemberships } : {},
+					ticketTypes
+				}
+			};
+		}
+		default: return {
+			ok: false,
+			issues: [issue$1(["kind"], "Pricing kind must be free, fixed_price, or ticket_types")]
+		};
+	}
+}
+
+//#endregion
+//#region ../api/src/sdk-event-schedule.ts
+const timeRegex = /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/;
+const explicitOffsetDateTimeRegex = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?(\.\d{1,3})?(Z|[+-]([01]\d|2[0-3]):[0-5]\d)$/;
+const localDateTimeRegex = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d)(?::([0-5]\d))?(\.\d{1,3})?$/;
+function issue(path, message) {
+	return {
+		path,
+		message
+	};
+}
+function isValidDateParts(year, month, day) {
+	const date = new Date(Date.UTC(year, month - 1, day));
+	return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+function isZeroFraction(fraction) {
+	return fraction === undefined || /^\.0+$/.test(fraction);
+}
+function datePart(year, month, day) {
+	return `${year}-${month}-${day}`;
+}
+function timePart(hours, minutes, seconds = "00") {
+	return `${hours}:${minutes}:${seconds}`;
+}
+function parseSdkEventDateTime(value) {
+	const explicitMatch = explicitOffsetDateTimeRegex.exec(value);
+	if (explicitMatch) {
+		const [, yearRaw$1, monthRaw$1, dayRaw$1, hours$1, minutes$1, seconds$1 = "00", fraction$1] = explicitMatch;
+		if (!yearRaw$1 || !monthRaw$1 || !dayRaw$1 || !hours$1 || !minutes$1) return null;
+		const year$1 = Number(yearRaw$1);
+		const month$1 = Number(monthRaw$1);
+		const day$1 = Number(dayRaw$1);
+		if (!isValidDateParts(year$1, month$1, day$1) || !isZeroFraction(fraction$1)) return null;
+		const epochMs$1 = Date.parse(value);
+		if (!Number.isFinite(epochMs$1)) return null;
+		return {
+			epochMs: epochMs$1,
+			date: datePart(yearRaw$1, monthRaw$1, dayRaw$1),
+			time: timePart(hours$1, minutes$1, seconds$1),
+			iso: new Date(epochMs$1).toISOString()
+		};
+	}
+	const localMatch = localDateTimeRegex.exec(value);
+	if (!localMatch) return null;
+	const [, yearRaw, monthRaw, dayRaw, hours, minutes, seconds = "00", fraction] = localMatch;
+	if (!yearRaw || !monthRaw || !dayRaw || !hours || !minutes) return null;
+	const year = Number(yearRaw);
+	const month = Number(monthRaw);
+	const day = Number(dayRaw);
+	if (!isValidDateParts(year, month, day) || !isZeroFraction(fraction)) return null;
+	const epochMs = Date.UTC(year, month - 1, day, Number(hours), Number(minutes), Number(seconds));
+	return {
+		epochMs,
+		date: datePart(yearRaw, monthRaw, dayRaw),
+		time: timePart(hours, minutes, seconds),
+		iso: new Date(epochMs).toISOString()
+	};
+}
+function durationMinutesBetween(startsAt, endsAt) {
+	if (endsAt.epochMs <= startsAt.epochMs) return null;
+	const durationMs = endsAt.epochMs - startsAt.epochMs;
+	if (durationMs % 6e4 !== 0) return null;
+	return durationMs / 6e4;
+}
+function exceedsMaxDuration(durationMinutes, options) {
+	return options.maxDurationMinutes !== undefined && durationMinutes > options.maxDurationMinutes;
+}
+function maxDurationMessage(options) {
+	return options.maxDurationDays === undefined ? "Duration is above the allowed maximum" : `Duration must be ${options.maxDurationDays} days or less`;
+}
+function classifyCanonicalSchedule(input, options) {
+	const issues = [];
+	if (options.requireCanonicalFields && input.recurrenceRule === undefined) {
+		issues.push(issue(["recurrenceRule"], "recurrenceRule is required"));
+	}
+	if (input.defaultStartTime !== undefined && input.defaultStartTime !== null && !timeRegex.test(input.defaultStartTime)) {
+		issues.push(issue(["defaultStartTime"], "Invalid time format (HH:MM or HH:MM:SS)"));
+	}
+	if (options.requireCanonicalFields && !input.defaultStartTime) {
+		issues.push(issue(["defaultStartTime"], "defaultStartTime is required"));
+	}
+	if (options.requireCanonicalFields && input.durationMinutes === undefined) {
+		issues.push(issue(["durationMinutes"], "durationMinutes is required"));
+	}
+	if (input.durationMinutes !== undefined && input.durationMinutes !== null) {
+		if (input.durationMinutes < 1) {
+			issues.push(issue(["durationMinutes"], "durationMinutes must be at least 1"));
+		} else if (exceedsMaxDuration(input.durationMinutes, options)) {
+			issues.push(issue(["durationMinutes"], maxDurationMessage(options)));
+		}
+	}
+	if (issues.length > 0) return {
+		ok: false,
+		issues
+	};
+	return {
+		ok: true,
+		kind: "canonical",
+		canonical: {
+			recurrenceRule: input.recurrenceRule ?? null,
+			startDate: input.startDate,
+			timezone: input.timezone,
+			defaultStartTime: input.defaultStartTime ?? "09:00:00",
+			durationMinutes: input.durationMinutes ?? 60
+		}
+	};
+}
+function classifySdkEventSchedule(input, options = {}) {
+	const issues = [];
+	const hasStartsAt = input.startsAt !== undefined && input.startsAt !== null;
+	const hasEndsAt = input.endsAt !== undefined && input.endsAt !== null;
+	const hasDateTimeDuration = hasStartsAt && input.durationMinutes !== undefined && input.durationMinutes !== null;
+	const hasCanonicalStart = input.startDate !== undefined || input.defaultStartTime !== undefined;
+	if (!hasStartsAt && !hasEndsAt) {
+		return classifyCanonicalSchedule(input, options);
+	}
+	if (hasStartsAt && hasCanonicalStart) {
+		issues.push(issue(["startsAt"], "Use either startsAt or startDate/defaultStartTime, not both"));
+	}
+	if (input.recurrenceRule) {
+		issues.push(issue(["recurrenceRule"], "startsAt schedules are only supported for one-off events"));
+	}
+	if (!hasStartsAt) {
+		issues.push(issue(["startsAt"], "startsAt is required when endsAt is provided"));
+	}
+	if (!hasEndsAt && !hasDateTimeDuration) {
+		issues.push(issue(["endsAt"], "Provide either endsAt or durationMinutes with startsAt"));
+	}
+	if (hasEndsAt && hasDateTimeDuration) {
+		issues.push(issue(["endsAt"], "Use either endsAt or durationMinutes with startsAt, not both"));
+	}
+	const startsAt = typeof input.startsAt === "string" ? parseSdkEventDateTime(input.startsAt) : null;
+	const endsAt = typeof input.endsAt === "string" ? parseSdkEventDateTime(input.endsAt) : null;
+	if (hasStartsAt && !startsAt) {
+		issues.push(issue(["startsAt"], "Invalid datetime format. Use ISO datetime format, e.g. 2026-06-01T10:00:00Z"));
+	}
+	if (hasEndsAt && !endsAt) {
+		issues.push(issue(["endsAt"], "Invalid datetime format. Use ISO datetime format, e.g. 2026-06-07T10:00:00Z"));
+	}
+	if (startsAt && endsAt) {
+		const durationMinutes = durationMinutesBetween(startsAt, endsAt);
+		if (durationMinutes === null) {
+			issues.push(issue(["endsAt"], "endsAt must be after startsAt and align to a whole minute"));
+		} else if (exceedsMaxDuration(durationMinutes, options)) {
+			issues.push(issue(["endsAt"], maxDurationMessage(options)));
+		}
+		if (issues.length === 0 && durationMinutes !== null) {
+			return {
+				ok: true,
+				kind: "start-end",
+				canonical: {
+					recurrenceRule: null,
+					startDate: startsAt.date,
+					timezone: input.timezone,
+					defaultStartTime: startsAt.time,
+					durationMinutes
+				},
+				startsAtIso: startsAt.iso,
+				endsAtIso: endsAt.iso
+			};
+		}
+	}
+	if (startsAt && hasDateTimeDuration && input.durationMinutes !== undefined && input.durationMinutes !== null) {
+		if (input.durationMinutes < 1) {
+			issues.push(issue(["durationMinutes"], "durationMinutes must be at least 1"));
+		} else if (exceedsMaxDuration(input.durationMinutes, options)) {
+			issues.push(issue(["durationMinutes"], maxDurationMessage(options)));
+		}
+		if (issues.length === 0) {
+			const endsAtMs = startsAt.epochMs + input.durationMinutes * 6e4;
+			return {
+				ok: true,
+				kind: "start-duration",
+				canonical: {
+					recurrenceRule: null,
+					startDate: startsAt.date,
+					timezone: input.timezone,
+					defaultStartTime: startsAt.time,
+					durationMinutes: input.durationMinutes
+				},
+				startsAtIso: startsAt.iso,
+				endsAtIso: new Date(endsAtMs).toISOString()
+			};
+		}
+	}
+	return {
+		ok: false,
+		issues
+	};
+}
+
+//#endregion
+//#region ../api/src/sdk-event-upsert.ts
+const sdkEventOccurrenceWireSchema = z.object({
+	startsAt: z.string(),
+	endsAt: z.string(),
+	timeZone: z.string()
+});
+const sdkEventOccurrenceInputSchema = z.object({
+	startsAt: z.string().datetime({ offset: true }),
+	endsAt: z.string().datetime({ offset: true }),
+	timeZone: z.string().min(1).refine((value) => parseBookingTimeZone(value).ok, "Invalid IANA timezone")
+}).refine(({ startsAt, endsAt }) => Date.parse(endsAt) > Date.parse(startsAt), {
+	path: ["endsAt"],
+	message: "endsAt must be after startsAt"
+});
+const sdkEventUpsertOptionalFieldSchemas = {
+	path: z.string().startsWith("/", "path must start with /").nullable().optional(),
+	status: z.enum([
+		"draft",
+		"active",
+		"archived",
+		"cancelled",
+		"completed"
+	]).optional(),
+	visibility: z.enum([
+		"private",
+		"public",
+		"unlisted"
+	]).optional(),
+	preset: z.enum([
+		"event",
+		"class",
+		"course",
+		"term",
+		"workshop",
+		"retreat",
+		"performance"
+	]).optional(),
+	bookingScope: z.enum(["single_occurrence", "whole_series"]).optional(),
+	occurrences: z.array(sdkEventOccurrenceWireSchema).optional(),
+	capacity: z.number().int().positive().nullable().optional()
+};
+function timingIssue(path, message) {
+	return {
+		path,
+		message
+	};
+}
+function parseExplicitOccurrence(occurrence, index) {
+	const startsAt = parseUtcIsoDateTimeString(occurrence.startsAt);
+	const endsAt = parseUtcIsoDateTimeString(occurrence.endsAt);
+	const timeZone = parseBookingTimeZone(occurrence.timeZone);
+	const path = ["occurrences", String(index)];
+	const issues = [];
+	if (!startsAt.ok) issues.push(timingIssue([...path, "startsAt"], "startsAt must be a valid offset-aware ISO datetime"));
+	if (!endsAt.ok) issues.push(timingIssue([...path, "endsAt"], "endsAt must be a valid offset-aware ISO datetime"));
+	if (!timeZone.ok) issues.push(timingIssue([...path, "timeZone"], "Invalid IANA timezone"));
+	if (!startsAt.ok || !endsAt.ok || !timeZone.ok) return {
+		ok: false,
+		issues
+	};
+	if (Date.parse(endsAt.value) <= Date.parse(startsAt.value)) {
+		return {
+			ok: false,
+			issues: [timingIssue([...path, "endsAt"], "endsAt must be after startsAt")]
+		};
+	}
+	return {
+		ok: true,
+		value: {
+			startsAt: startsAt.value,
+			endsAt: endsAt.value,
+			timeZone: timeZone.value
+		}
+	};
+}
+function classifySdkEventTiming(input, options = {}) {
+	if (input.occurrences && input.occurrences.length > 0) {
+		if (input.bookingScope === undefined) {
+			return {
+				ok: false,
+				issues: [timingIssue(["bookingScope"], "bookingScope is required when occurrences are provided")]
+			};
+		}
+		const occurrences = [];
+		const starts = new Set();
+		let timeZone;
+		const issues = [];
+		input.occurrences.forEach((occurrence, index) => {
+			const parsed = parseExplicitOccurrence(occurrence, index);
+			if (!parsed.ok) {
+				issues.push(...parsed.issues);
+				return;
+			}
+			if (starts.has(parsed.value.startsAt)) {
+				issues.push(timingIssue([
+					"occurrences",
+					String(index),
+					"startsAt"
+				], "Occurrence start times must be unique within a series"));
+				return;
+			}
+			if (timeZone && timeZone !== parsed.value.timeZone) {
+				issues.push(timingIssue([
+					"occurrences",
+					String(index),
+					"timeZone"
+				], "All event occurrences must use the same timezone"));
+				return;
+			}
+			starts.add(parsed.value.startsAt);
+			timeZone ??= parsed.value.timeZone;
+			occurrences.push(parsed.value);
+		});
+		const [first, ...rest] = occurrences;
+		if (issues.length > 0 || !first || !timeZone) return {
+			ok: false,
+			issues
+		};
+		return {
+			ok: true,
+			timingAuthority: {
+				kind: "explicit_occurrences",
+				bookingScope: input.bookingScope,
+				occurrences: [first, ...rest],
+				timeZone
+			}
+		};
+	}
+	if (input.schedule === undefined || typeof input.schedule !== "object" || input.schedule === null || Array.isArray(input.schedule)) {
+		return {
+			ok: false,
+			issues: [timingIssue(["schedule"], "Either schedule or a non-empty occurrences list is required")]
+		};
+	}
+	const schedule = classifySdkEventSchedule(input.schedule, options);
+	return schedule.ok ? {
+		ok: true,
+		timingAuthority: {
+			kind: "authored_schedule",
+			schedule: schedule.canonical,
+			bookingScope: input.bookingScope
+		}
+	} : {
+		ok: false,
+		issues: schedule.issues.map((issue$3) => timingIssue(["schedule", ...issue$3.path], issue$3.message))
+	};
+}
+function parseSdkEventUpsertInput(input, options = {}) {
+	const runRefs = new Set(input.runRefs);
+	const runsByIdentifier = new Map(input.runs.map((run) => [run.identifier, run]));
+	if (input.runRefs.length !== runRefs.size || runsByIdentifier.size !== input.runs.length || input.runRefs.length !== input.runs.length || input.runRefs.some((ref) => !runsByIdentifier.has(ref)) || input.runs.some((run) => run.eventRef !== input.identifier)) {
+		return {
+			ok: false,
+			issues: [{
+				source: "graph",
+				path: ["runRefs"],
+				message: "Event runRefs and runs must form one complete parent graph",
+				issue: { kind: "incoherentParentRunGraph" }
+			}]
+		};
+	}
+	const runForRef = (ref) => {
+		const run = runsByIdentifier.get(ref);
+		if (!run) throw new Error("Unreachable missing Event run after graph validation");
+		return run;
+	};
+	const firstRun = runForRef(input.runRefs[0]);
+	const remainingRuns = input.runRefs.slice(1).map(runForRef);
+	if (firstRun.bookingScope === "single_occurrence" && remainingRuns.length > 0 || remainingRuns.some((run) => run.bookingScope !== firstRun.bookingScope)) {
+		return {
+			ok: false,
+			issues: [{
+				source: "graph",
+				path: ["runs"],
+				message: "An Event must contain one ordinary run or one or more whole-series runs",
+				issue: { kind: "incoherentParentRunGraph" }
+			}]
+		};
+	}
+	const firstResult = parseSdkEventRunUpsertInput(firstRun, 0, options);
+	const remainingResults = remainingRuns.map((run, index) => parseSdkEventRunUpsertInput(run, index + 1, options));
+	const issues = [firstResult, ...remainingResults].flatMap((result) => result.ok ? [] : result.issues);
+	if (issues.length > 0) return {
+		ok: false,
+		issues
+	};
+	if (!firstResult.ok) return {
+		ok: false,
+		issues: firstResult.issues
+	};
+	const parsedRemaining = remainingResults.flatMap((result) => result.ok ? [result.value] : []);
+	return {
+		ok: true,
+		value: {
+			...input,
+			runs: [firstResult.value, ...parsedRemaining]
+		}
+	};
+}
+function toSdkEventRunUpsertBody(input) {
+	const { timingAuthority, ...common } = input;
+	switch (timingAuthority.kind) {
+		case "authored_schedule": return {
+			...common,
+			...timingAuthority.bookingScope === undefined ? {} : { bookingScope: timingAuthority.bookingScope },
+			schedule: timingAuthority.schedule
+		};
+		case "explicit_occurrences": return {
+			...common,
+			bookingScope: timingAuthority.bookingScope,
+			occurrences: timingAuthority.occurrences
+		};
+		default: return timingAuthority;
+	}
+}
+function toSdkEventUpsertBody(input) {
+	const [first, ...rest] = input.runs;
+	return {
+		...input,
+		runs: [toSdkEventRunUpsertBody(first), ...rest.map(toSdkEventRunUpsertBody)]
+	};
+}
+function parseSdkEventRunUpsertInput(input, runIndex, options) {
+	const timingResult = classifySdkEventTiming(input, options.schedule);
+	const pricingResult = classifySdkEventPricing(input.pricing);
+	const paymentTermsResult = classifySdkEventPaymentTerms(input.paymentTerms);
+	const issues = [];
+	if (timingResult.ok && pricingResult.ok && paymentTermsResult.ok) {
+		const { schedule: _schedule, occurrences: _occurrences, bookingScope: _bookingScope, pricing: _pricing, paymentTerms: _paymentTerms, ...common } = input;
+		return {
+			ok: true,
+			value: {
+				...common,
+				timingAuthority: timingResult.timingAuthority,
+				pricing: pricingResult.pricing,
+				paymentTerms: paymentTermsResult.paymentTerms
+			}
+		};
+	}
+	if (!timingResult.ok) {
+		issues.push(...timingResult.issues.map((timing) => ({
+			runIndex,
+			source: "timing",
+			path: timing.path,
+			message: timing.message,
+			issue: timing
+		})));
+	}
+	if (!pricingResult.ok) {
+		issues.push(...pricingResult.issues.map((pricingIssue) => ({
+			runIndex,
+			source: "pricing",
+			path: pricingIssue.path,
+			message: pricingIssue.message,
+			issue: pricingIssue
+		})));
+	}
+	if (!paymentTermsResult.ok) {
+		issues.push(...paymentTermsResult.issues.map((paymentTermsIssue) => ({
+			runIndex,
+			source: "paymentTerms",
+			path: paymentTermsIssue.path,
+			message: paymentTermsIssue.message,
+			issue: paymentTermsIssue
+		})));
+	}
+	return {
+		ok: false,
+		issues
+	};
+}
+
+//#endregion
+export { classifySdkEventPricing as a, classifySdkEventSchedule as i, sdkEventOccurrenceInputSchema as n, classifySdkEventPaymentTerms as o, sdkEventUpsertOptionalFieldSchemas as r, classifySdkEventTiming as t };