riverbankcms 0.4.3 → 0.6.0

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

@@ -1,962 +0,0 @@
-#!/usr/bin/env node
-import { B as parseUtcIsoDateTimeString, W as parseBookingTimeZone } from "./src-DKm0bLEA.mjs";
-import { z } from "zod";
-
-//#region ../api/src/bookingPaymentTermSchemas.ts
-const bookingDepositRefundPolicySchema = z.enum(["refundable", "non_refundable"]);
-const bookingInstalmentPlanSchema = z.discriminatedUnion("kind", [
-	z.object({
-		kind: z.literal("deposit_plus_one_remainder"),
-		depositAmountCents: z.number().int().nonnegative(),
-		depositRefundability: bookingDepositRefundPolicySchema,
-		remainderDueCount: z.number().int().positive(),
-		intervalUnit: z.enum([
-			"day",
-			"week",
-			"month"
-		])
-	}),
-	z.object({
-		kind: z.literal("deposit_plus_scheduled_instalments"),
-		depositAmountCents: z.number().int().nonnegative(),
-		depositRefundability: bookingDepositRefundPolicySchema,
-		instalmentCount: z.number().int().positive(),
-		intervalCount: z.number().int().positive(),
-		intervalUnit: z.enum([
-			"day",
-			"week",
-			"month"
-		])
-	}),
-	z.object({
-		kind: z.literal("equal_scheduled_instalments"),
-		instalmentCount: z.number().int().positive(),
-		intervalCount: z.number().int().positive(),
-		intervalUnit: z.enum([
-			"day",
-			"week",
-			"month"
-		])
-	})
-]);
-const bookingFlexibleBalanceDueDateRuleSchema = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("relative_to_start_date"),
-	daysBeforeStart: z.number().int().positive()
-}), z.object({
-	kind: z.literal("fixed_calendar_date"),
-	dueAt: z.string().datetime()
-})]);
-const bookingFlexibleBalanceConfigSchema = z.object({
-	upfrontAmountCents: z.number().int().nonnegative(),
-	dueDateRule: bookingFlexibleBalanceDueDateRuleSchema,
-	depositRefundability: bookingDepositRefundPolicySchema
-});
-const bookingPaymentCollectionOptionSchema = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("upfront") }),
-	z.object({ kind: z.literal("deferred_manual") }),
-	z.object({
-		kind: z.literal("instalment_plan"),
-		plan: bookingInstalmentPlanSchema
-	}),
-	z.object({
-		kind: z.literal("flexible_balance"),
-		config: bookingFlexibleBalanceConfigSchema
-	})
-]);
-
-//#endregion
-//#region ../api/src/sdk-event-payment-terms.ts
-const supportedKinds = new Set([
-	"upfront",
-	"deferred_manual",
-	"instalment_plan",
-	"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 validateInstalmentPlan(raw, path) {
-	if (!isRecord$1(raw)) {
-		return [issue$2(path, "Instalment plan must be an object")];
-	}
-	const parsed = bookingInstalmentPlanSchema.safeParse(raw);
-	return parsed.success ? parsed.data : parsed.error.issues.map((problem) => issue$2([...path, ...problem.path.map(String)], `Invalid instalment plan: ${problem.message}`));
-}
-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 (!isSupportedOptionKind(raw.kind)) {
-		return [issue$2([...path, "kind"], "Payment option kind must be upfront, deferred_manual, instalment_plan, or flexible_balance")];
-	}
-	switch (raw.kind) {
-		case "upfront":
-		case "deferred_manual": return { kind: raw.kind };
-		case "instalment_plan": {
-			const plan = validateInstalmentPlan(raw.plan, [...path, "plan"]);
-			return Array.isArray(plan) ? plan : {
-				kind: "instalment_plan",
-				plan
-			};
-		}
-		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("instalment_plan") && !seenKinds.has("flexible_balance"))) {
-		issues.push(issue$2(["allowedOptions"], "Event payment terms with two options must combine upfront with one alternative option"));
-	}
-	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 };