@riverbankcms/sdk 0.136.0 → 0.138.0

package/dist/_dts/blocks/src/pageRenderPreparation.d.ts

@@ -0,0 +1,109 @@
+import type { SystemBlockComponent } from './system';
+import type { RouteMap } from './system/transforms';
+import type { ResolveImageUrlContext } from './system/runtime/nodes/media';
+import { type PageThemeResources } from './pageRenderingMode';
+import type { PresentationBlock } from './pageRenderAdmission';
+import type { RenderAudience } from './pageRenderAudience';
+import type { PageRuntimeBoundary } from './pageRendererBoundaries';
+import type { BlockOverrideProps, PageRendererDataContext } from './pageRendererContracts';
+import { type PageBlockRenderPlanEntry, type PageRenderPlan } from './pageRenderPlan';
+/**
+ * What preparing a block produced.
+ *
+ * - `plan-decided`         — nothing to prepare; the plan already settled this
+ *                            entry (a diagnostic, or an override with no
+ *                            definition behind it).
+ * - `content`              — the props and component the block will render with.
+ * - `editor-unpreviewable` — relaxed editor validation rejected the draft.
+ * - `render-threw`         — building the element threw. Authoring keeps the
+ *                            entry and diagnoses it; public drops the entry
+ *                            entirely (see `preparePageRender`).
+ */
+export type PreparedBlockRender = Readonly<{
+    kind: 'plan-decided';
+}> | Readonly<{
+    kind: 'content';
+    baseProps: BlockOverrideProps;
+    component: SystemBlockComponent<Record<string, unknown>> | undefined;
+    hasResolvedData: boolean;
+    routes: RouteMap | undefined;
+}> | Readonly<{
+    kind: 'editor-unpreviewable';
+}> | Readonly<{
+    kind: 'render-threw';
+}>;
+export type PreparedPlanEntry = Readonly<{
+    entry: PageBlockRenderPlanEntry;
+    prepared: PreparedBlockRender;
+}>;
+export type PageRenderPreparation = Readonly<{
+    entries: readonly PreparedPlanEntry[];
+    /**
+     * Plan entries whose element construction threw, in page order.
+     *
+     * The whole entry rather than its block, because a public render drops these
+     * from `entries` before anything downstream can guard them, so the render edge
+     * has to replay the overrides-only guard over the entry's own `override`.
+     */
+    constructionFailures: readonly PageBlockRenderPlanEntry[];
+    runtimeBoundaries: readonly PageRuntimeBoundary[] | undefined;
+}>;
+export type PreparePageRenderInput = Readonly<{
+    plan: PageRenderPlan;
+    audience: RenderAudience;
+    dataContext: PageRendererDataContext | undefined;
+    routeMap: RouteMap | undefined;
+    themeResources: PageThemeResources;
+    imageResolveContext: ResolveImageUrlContext;
+    previewStage: 'published' | 'preview';
+}>;
+/**
+ * Stage two of the render plan.
+ *
+ * `buildPageRenderPlan` decides everything knowable from the page and the block
+ * registries. This pass decides everything knowable once the *render* inputs are
+ * in scope — routes, resolved data, theme resources — which is where content
+ * parsing, link hydration and data resolution can throw.
+ *
+ * Why a second stage rather than folding `render-threw` into `buildPageRenderPlan`
+ * with the other three reasons: the work that throws reads `dataContext`,
+ * `routeMap` and `themeResources`, none of which are plan inputs. Adding them
+ * would make every plan entry a fresh object on every render whose `dataContext`
+ * identity changed, and entry identity is exactly what `MemoBlockSection`'s
+ * comparator uses to skip a block subtree. So the decision moves as early as its
+ * inputs allow — before any wrapper markup exists — and no earlier.
+ *
+ * Pure, and memoised by the caller. Failures come back as data so the logging
+ * stays at the edge (decision D3), matching `buildPageRenderPlan`.
+ */
+export declare function preparePageRender(input: PreparePageRenderInput): PageRenderPreparation;
+/**
+ * The serialisable prop bundle every block component and override receives.
+ *
+ * Shared by the with-definition and override-without-definition paths, which
+ * differ only in the content and resolved data they pass in.
+ */
+export declare function buildBlockOverrideProps(input: Readonly<{
+    content: Record<string, unknown>;
+    data: Record<string, unknown> | undefined;
+    block: PresentationBlock;
+    themeResources: PageThemeResources;
+    dataContext: PageRendererDataContext | undefined;
+    imageResolveContext: ResolveImageUrlContext;
+}>): BlockOverrideProps;
+/** What this render is *about* — the entry, occurrence or surface in scope. */
+export declare function blockSubjectProps(dataContext: PageRendererDataContext | undefined): {
+    occurrenceContext: Readonly<{
+        id: string;
+        seriesId: string;
+        startsAt: string;
+        endsAt: string;
+        timeZone: string;
+        capacityOverride?: number | null;
+        overrides?: Record<string, unknown> | null;
+    }> | null;
+    entrySubrouteContext: import("../../core/src/index").EventPageSubrouteContext | null;
+    contentEntry: Record<string, unknown> | null;
+    pageSurface: Record<string, unknown> | null;
+    subject: import("../../core/src/index").EventPageSurfaceSubjectWire | null;
+};

package/dist/_dts/blocks/src/pageRendererBoundaries.d.ts

@@ -4,6 +4,7 @@ import type { Block } from './structure/schema';
 export type PageBlockPosition = 'only' | 'first' | 'middle' | 'last';
 export type PageRuntimeBoundary = CompiledBoundaryRuntime<string>;
 export type PageBoundaryWrapper = (boundary: PageRuntimeBoundary, rendered: React.ReactNode) => React.ReactNode;
+export declare const boundaryKey: (previousBlockId: string, nextBlockId: string) => string;
 export declare function isSiteStyleTransitionStyleGroup(value: string | undefined): value is string;
 export declare function boundaryMapForAdjacentBlockIds(boundaries: readonly PageRuntimeBoundary[]): ReadonlyMap<string, PageRuntimeBoundary>;
 export declare function boundaryBetweenBlocks(previousBlock: Block | null, nextBlock: Block | null, boundaries: ReadonlyMap<string, PageRuntimeBoundary>): PageRuntimeBoundary | null;

package/dist/_dts/blocks/src/pageRendererContracts.d.ts

@@ -0,0 +1,154 @@
+import type * as React from 'react';
+import type { Theme } from '../../theme-core/src/schema';
+import type { ThemeTokens } from './system/theme';
+import type { SdkCustomBlock } from './system/manifest/schema';
+import type { MediaAssetIndexItem, ResolveImageUrlContext, ResolveImageUrlContextInput } from './system/runtime/nodes/media';
+import type { RouteMap } from './system/transforms';
+import type { BookingOfferingPresetSummary } from './system/blocks/offerings-preview/model';
+/**
+ * Occurrence context for event pages.
+ * Passed through to blocks that need occurrence information (e.g., event-registration).
+ */
+export type OccurrenceContextData = import('../../core/src/index').EventOccurrenceContextData;
+/**
+ * Event-occurrence subroute context.
+ */
+export type EntrySubrouteContextData = import('../../core/src/index').EventPageSubrouteContext;
+/**
+ * Props passed to block override components.
+ *
+ * These props are RSC-safe (no functions) so overrides can be Client Components.
+ * Unlike internal SDK block components, overrides don't receive `registry` or
+ * `fragmentRegistry` which contain function references that can't cross the
+ * RSC serialization boundary.
+ *
+ * @example
+ * ```tsx
+ * 'use client';
+ *
+ * import type { BlockOverrideProps, HeroContent } from '@riverbankcms/sdk/rendering';
+ *
+ * export function CustomHero({ content, theme, data }: BlockOverrideProps<HeroContent>) {
+ *   const [expanded, setExpanded] = useState(false);
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+export type BlockOverrideProps<TContent = Record<string, unknown>> = {
+    /** Block content data */
+    content: TContent;
+    /** Theme tokens for styling */
+    theme?: ThemeTokens;
+    /** Full theme configuration */
+    themeConfig?: Theme;
+    /** Pre-fetched data from data loaders */
+    data?: Record<string, unknown>;
+    /** Site UUID (useful for media URL resolution in override components) */
+    siteId?: string;
+    /** Dashboard API URL for client-side block runtime calls. */
+    apiBaseUrl?: string;
+    /** Canonical site timezone for calendar/date behavior. */
+    bookingTimeZone?: string;
+    /** Customer portal token for Bearer-authenticated block runtime calls. */
+    portalToken?: string | null;
+    /** Preview bearer token for preview-aware block runtime calls. */
+    previewToken?: string | null;
+    /** Render stage for preview-aware block runtime calls. */
+    stage?: 'published' | 'preview';
+    /** Event-occurrence context for template-aware block overrides. */
+    occurrenceContext?: OccurrenceContextData | null;
+    /** Generic entry subroute context for template-aware block overrides. */
+    entrySubrouteContext?: EntrySubrouteContextData | null;
+    /** Content entry context for template-aware block overrides. */
+    contentEntry?: Record<string, unknown> | null;
+    /** Native page-surface context for template-aware block overrides. */
+    pageSurface?: Record<string, unknown> | null;
+    /** Subject descriptor for native page-surface block overrides. */
+    subject?: import('../../core/src/index').EventPageSurfaceSubjectWire | null;
+    /** Supabase project URL (useful for media URL resolution in override components) */
+    supabaseUrl?: string;
+    /** Full image-resolution context including canonical media sidecars. */
+    imageResolveContext?: ResolveImageUrlContext;
+    /** Block instance ID (null for unsaved blocks) */
+    blockId: string | null;
+    /** Block kind identifier (e.g., "block.hero" or "custom.my-block") */
+    blockKind: string;
+};
+/**
+ * Block override component type.
+ *
+ * Override components can be either Server Components or Client Components.
+ * They receive only serializable props (no functions) to support RSC boundaries.
+ *
+ * @example Server Component override
+ * ```tsx
+ * export function CustomHero({ content, theme, data }: BlockOverrideProps<HeroContent>) {
+ *   return <div className="custom-hero">...</div>;
+ * }
+ * ```
+ *
+ * @example Client Component override
+ * ```tsx
+ * 'use client';
+ *
+ * export function CustomHero({ content, theme, data }: BlockOverrideProps<HeroContent>) {
+ *   const [state, setState] = useState(null);
+ *   return <div className="custom-hero">...</div>;
+ * }
+ * ```
+ */
+export type BlockOverrideComponent = React.ComponentType<BlockOverrideProps<unknown>>;
+/**
+ * Map of block kinds to custom override components.
+ * Keys can be either:
+ * - Full block kind: "block.hero"
+ * - Short form: "hero" (will match "block.hero")
+ *
+ * @example
+ * ```tsx
+ * const overrides: BlockOverrides = {
+ *   'hero': CustomHero,        // CustomHero uses BlockOverrideProps<HeroContent>
+ *   'body-text': CustomBodyText, // CustomBodyText uses BlockOverrideProps<BodyTextContent>
+ * };
+ * ```
+ */
+export type BlockOverrides = Record<string, BlockOverrideComponent>;
+/**
+ * SDK site configuration for custom block rendering.
+ * Minimal type containing only what PageRenderer needs.
+ */
+export type SdkConfigForRenderer = {
+    customBlocks?: SdkCustomBlock[];
+};
+/**
+ * Everything a render pass knows that the page outline does not: routing, the
+ * subject in scope, session tokens and pre-resolved block data.
+ *
+ * Lives here rather than in `PageRenderer.tsx` because the preparation pass
+ * needs it too, and a type shared by two modules should not be owned by one of
+ * them. Not part of the package's public surface — the SDK re-declares its own.
+ */
+export type PageRendererDataContext = {
+    siteId?: string;
+    pageId?: string;
+    resolvedData?: Record<string, Record<string, unknown>>;
+    previewStage?: 'published' | 'preview';
+    previewToken?: string | null;
+    routes?: RouteMap;
+    pagesByIdentifier?: Record<string, string>;
+    entriesByIdentifier?: Record<string, Record<string, string>>;
+    occurrenceContext?: OccurrenceContextData | null;
+    entrySubrouteContext?: EntrySubrouteContextData | null;
+    contentEntry?: Record<string, unknown> | null;
+    pageSurface?: Record<string, unknown> | null;
+    subject?: import('../../core/src/index').EventPageSurfaceSubjectWire | null;
+    editableRouteMetadataFieldIds?: ReadonlyArray<string> | null;
+    supabaseUrl?: string;
+    mediaAssets?: readonly MediaAssetIndexItem[];
+    imageResolveContext?: ResolveImageUrlContextInput;
+    apiBaseUrl?: string;
+    portalToken?: string | null;
+    bookingOfferingPresets?: readonly BookingOfferingPresetSummary[];
+    bookingTimeZone?: string;
+    eventRegistrationOverlayEnabled?: boolean;
+};

package/dist/_dts/blocks/src/portal/types.d.ts

@@ -69,7 +69,7 @@ export interface CustomerMembership {
     canceledAt: string | null;
 }
 export interface EventTicketBreakdownLine {
-    ticketTypeId: string | null;
+    pricingOptionId: string | null;
     label: string;
     quantity: number;
 }

package/dist/_dts/blocks/src/server.d.ts

@@ -1,4 +1,5 @@
 export { default as PageRenderer, EditorPageRenderer, MissingBlockOverrideError, } from './PageRenderer';
+export type { RenderAudience as PageRenderAudience } from './pageRenderAudience';
 export type { BlockOverrideComponent, BlockOverrideProps, BlockOverrides, EntrySubrouteContextData, EditorPageRendererProps, OccurrenceContextData, PageBlockRenderAdmissionError, PageBlockPosition, PageRuntimeBoundary, RenderablePageBlock, RenderablePageOutline, SdkConfigForRenderer, } from './PageRenderer';
 export * from './subroutes';
 export { ThemeScope } from '../../theme-core/src/ThemeScope';

package/dist/_dts/blocks/src/system/blocks/event-registration.d.ts

@@ -1,3 +1,4 @@
+import type { PublicEventPricingOption } from '../../../../core/src/index';
 import type { SystemBlockDefinition } from '../registry';
 import type { SectionStylesContent } from '../fields/boxStyles';
 import { type PublicEvent } from './events/shared';
@@ -77,7 +78,7 @@ export declare const eventRegistrationManifest: import("..").DefinedBlockManifes
     }, {
         readonly id: "showCapacity";
         readonly type: "boolean";
-        readonly label: "Show available spots";
+        readonly label: "Show available places";
         readonly description: "Display remaining capacity";
         readonly required: false;
         readonly defaultValue: true;
@@ -161,10 +162,9 @@ export type EventRegistrationOptionsResponse = Readonly<{
         kind: 'waitlisted';
     }>;
     pricing: Readonly<{
-        mode: 'single' | 'ticket_types' | 'sliding_scale';
+        strategy: import('../../../../core/src/index').EventPricingStrategy;
         currency: string;
         subtotalCents: number;
-        requiresPayment: boolean;
         paymentTerms: BlockBookingPaymentTerms;
         lines: readonly EventRegistrationOptionLine[];
         options: readonly EventRegistrationPricingOption[];
@@ -215,24 +215,16 @@ export type EventRegistrationOptionLine = Readonly<{
     unitPriceCents: number;
     subtotalCents: number;
 }>;
-export type EventRegistrationPricingOption = Readonly<{
+/**
+ * A pricing option as the registration-options response reports it.
+ *
+ * It answers to `pricingOptionId` because that is the name the rest of the
+ * registration contract uses for this identity — ticket lines, submissions and
+ * order items all refer to a pricing option that way — while `id` stays for the
+ * row itself.
+ */
+export type EventRegistrationPricingOption = Omit<PublicEventPricingOption, 'id'> & Readonly<{
     pricingOptionId: string;
-    label: string;
-    description: string | null;
-    unitPriceCents: number;
-    sortOrder: number;
-    capacityLimit: number | null;
-    saleStartsAt: string | null;
-    saleEndsAt: string | null;
-    attendanceScope: 'in_person' | 'online' | 'both';
-    availability: Readonly<{
-        kind: 'available';
-        remainingPlaces: number | null;
-    }> | Readonly<{
-        kind: 'unavailable';
-        reason: 'inactive' | 'notOnSaleYet' | 'saleEnded' | 'soldOut' | 'attendanceModeUnavailable' | 'overallCapacityUnavailable';
-        remainingPlaces: number | null;
-    }>;
 }>;
 export type EventRegistrationOwnedMembership = Readonly<{
     customerMembershipId: string;

package/dist/_dts/blocks/src/system/blocks/events/event-calendar.d.ts

@@ -27,7 +27,7 @@ export declare const eventCalendarManifest: import("../..").DefinedBlockManifest
         readonly required: false;
         readonly multiple: false;
         readonly options: {
-            value: "stack" | "grid" | "compact";
+            value: "stack" | "compact" | "grid";
         }[];
     }, {
         readonly id: "defaultCalendarView";

package/dist/_dts/blocks/src/system/blocks/events/eventCalendarDataLoaders.d.ts

@@ -0,0 +1,3 @@
+import type { BlockDataLoader } from '../../registry';
+/** Combined renders two jobs; calendar-only variants never pay for the list seed. */
+export declare const eventCalendarDataLoaders: Record<string, BlockDataLoader>;

package/dist/_dts/blocks/src/system/blocks/events/shared/calendarWindow.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+import { type CalendarDate } from '../../../../../../calendar/src/index';
+import { type BookingTimeZone } from '../../../../../../core/src/index';
+import type { PublicEvent } from './types';
+export type CalendarReadProfile = 'listing-card' | 'timetable';
+export declare function resolveCalendarReadProfile(content: {
+    variant?: unknown;
+    displayMode?: unknown;
+}): CalendarReadProfile;
+/** Runtime picker sentinels and bound loader IDs must describe the same query. */
+export declare function normalizeCalendarFilterId(value: string | undefined): string | undefined;
+export declare const CALENDAR_SSR_PAGE_SIZE = 100;
+export declare const CALENDAR_CLIENT_PAGE_SIZE = 200;
+export declare const calendarMonthSchema: z.ZodString;
+export declare function calendarMonthDate(month: string): CalendarDate;
+export declare function calendarMonthKey(date: CalendarDate): string;
+export declare const calendarMonthWindowSchema: z.ZodObject<{
+    startMonth: z.ZodString;
+    endMonthExclusive: z.ZodString;
+}, z.core.$strip>;
+export type CalendarMonthWindow = z.infer<typeof calendarMonthWindowSchema>;
+export declare const calendarWindowQuerySchema: z.ZodObject<{
+    startMonth: z.ZodOptional<z.ZodString>;
+    endMonthExclusive: z.ZodOptional<z.ZodString>;
+    afterStartsAt: z.ZodOptional<z.ZodString>;
+    afterId: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    stage: z.ZodDefault<z.ZodEnum<{
+        published: "published";
+        preview: "preview";
+    }>>;
+    readProfile: z.ZodOptional<z.ZodEnum<{
+        "listing-card": "listing-card";
+        timetable: "timetable";
+    }>>;
+    eventSurface: z.ZodOptional<z.ZodEnum<{
+        custom: "custom";
+        all: "all";
+        regularClassSchedule: "regularClassSchedule";
+        specialDatedEvents: "specialDatedEvents";
+    }>>;
+    eventPresets: z.ZodOptional<z.ZodString>;
+    scheduleScope: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        recurring: "recurring";
+        oneOff: "oneOff";
+    }>>;
+    categoryIds: z.ZodOptional<z.ZodString>;
+    venueId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
+    staffMemberId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string | undefined, string>>>;
+}, z.core.$strip>;
+export type CalendarWindowQuery = z.infer<typeof calendarWindowQuerySchema>;
+export type CalendarWindowRequest = Omit<CalendarWindowQuery, 'limit' | 'stage'> & Partial<Pick<CalendarWindowQuery, 'limit' | 'stage'>>;
+export type CalendarFilterInput = Pick<CalendarWindowQuery, 'eventSurface' | 'eventPresets' | 'scheduleScope' | 'categoryIds' | 'venueId' | 'staffMemberId' | 'readProfile'>;
+/** Pagination and window bounds deliberately do not change the query's identity. */
+export declare function calendarQueryKey(siteId: string, stage: string | undefined, filters: CalendarFilterInput): string;
+export declare function calendarWindowMonths(window: CalendarMonthWindow): string[];
+export declare function calendarWindowBounds(window: CalendarMonthWindow, timeZone: BookingTimeZone): Readonly<{
+    startInclusive: string;
+    endExclusive: string;
+}>;
+export declare function resolveCalendarWindow(query: CalendarWindowQuery, now: Date, timeZone: BookingTimeZone): CalendarMonthWindow;
+export declare const calendarSourceCursorSchema: z.ZodObject<{
+    startsAt: z.ZodString;
+    occurrenceId: z.ZodString;
+}, z.core.$strip>;
+export type CalendarSourceCursor = z.infer<typeof calendarSourceCursorSchema>;
+export declare const calendarPageProgressSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"complete">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"partial">;
+    nextCursor: z.ZodObject<{
+        startsAt: z.ZodString;
+        occurrenceId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>], "kind">;
+export type CalendarPageProgress = z.infer<typeof calendarPageProgressSchema>;
+export type CalendarWindowPage = Readonly<{
+    scope: Readonly<{
+        key: string;
+        timeZone: BookingTimeZone;
+    }>;
+    window: CalendarMonthWindow;
+    initialToday: CalendarDate;
+    events: PublicEvent[];
+}> & CalendarPageProgress;
+export declare function calendarPageResponseError(page: CalendarWindowPage, expected: Readonly<{
+    key: string;
+    timeZone: BookingTimeZone;
+    window: CalendarMonthWindow;
+    cursor?: CalendarSourceCursor;
+}>): 'scopeMismatch' | 'nonAdvancingCursor' | null;
+export declare const calendarWindowPageSchema: z.ZodType<CalendarWindowPage>;
+/** Split missing months without bridging covered months or exceeding the wire cap. */
+export declare function planCalendarMonthRanges(months: readonly string[]): CalendarMonthWindow[];

package/dist/_dts/blocks/src/system/blocks/events/shared/index.d.ts

@@ -3,6 +3,7 @@
  */
 export * from './types';
 export * from './schemas';
+export * from './runGrouping';
 export * from './fields';
 export * from './filtering';
 export * from './layout';

package/dist/_dts/blocks/src/system/blocks/events/shared/runGrouping.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Run grouping for the canonical public Event contract.
+ *
+ * `listPublicEvents` answers either of two questions. A page of dates returns a
+ * whole-series run once per occurrence that landed on the page; a run-oriented
+ * read (`readIntent: 'runs'`) returns one representative row per run. Both
+ * carry the same complete `run` facts, so a surface that shows one item per run
+ * groups whichever it was given here rather than deriving its own idea of what
+ * a run is.
+ *
+ * A surface may hold both kinds of result at once — a registration page loads
+ * its dates and its runs separately — so rows are collapsed by series and, for
+ * safety, deduplicated by occurrence.
+ */
+import type { PublicEvent, PublicWholeSeriesRun } from './types';
+/** A `PublicEvent` narrowed to the whole-series arm of the union. */
+export type WholeSeriesPublicEvent = Extract<PublicEvent, {
+    bookingScope: 'whole_series';
+}>;
+/** A single whole-series run with the occurrences that carried it. */
+export type PublicEventRunGroup = Readonly<{
+    eventSeriesId: string;
+    run: PublicWholeSeriesRun;
+    /** Occurrence rows for the run, in the order they arrived. */
+    occurrences: readonly WholeSeriesPublicEvent[];
+    /** The first occurrence row, which carries the run's shared booking facts. */
+    representative: WholeSeriesPublicEvent;
+}>;
+export declare function isWholeSeriesPublicEvent(event: PublicEvent): event is WholeSeriesPublicEvent;
+/**
+ * Group events into one entry per whole-series run.
+ *
+ * Single-occurrence events are ignored. Run order follows first appearance, so
+ * a caller's sort survives the grouping, and an occurrence that arrives twice
+ * is kept once.
+ */
+export declare function groupPublicEventsByRun(events: readonly PublicEvent[]): readonly PublicEventRunGroup[];