@nice2dev/events 1.0.29 → 1.1.5

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  */
 
 import { default as default_2 } from 'react';
+import { NiceHtmlEditorCommand } from '@nice2dev/ui';
 
 /** Attraction category. */
 export declare type AttractionCategory = 'game' | 'music' | 'dance' | 'quiz' | 'karaoke' | 'photo' | 'custom';
@@ -17,7 +18,16 @@ export declare interface BillingItem {
     paidById?: string;
     paidByName?: string;
     splitAmong?: string[];
+    /**
+     * Paid to the vendor — **not** settled between participants.
+     *
+     * Deliberately has no effect on balances: letting it zero one would erase
+     * everyone's debt the moment somebody pays the caterer. Settling up between
+     * people is recorded separately, as {@link NiceSettlementTransfer}[].
+     */
     isPaid?: boolean;
+    /** When the expense was incurred (ISO). Orders the expense list. */
+    incurredAt?: string;
 }
 
 export declare interface CateringZone {
@@ -57,6 +67,12 @@ export declare interface ChatMessage {
 /** Chat message type. */
 export declare type ChatMessageType = 'text' | 'image' | 'system' | 'reaction' | 'announcement';
 
+/** Rendered size of the chart container, in CSS pixels. */
+declare interface ContainerSize {
+    width: number;
+    height: number;
+}
+
 export declare interface EvacuationPlan {
     venueId: string;
     routes: EvacuationRoute[];
@@ -108,6 +124,17 @@ export declare interface EventAttraction {
     order?: number;
 }
 
+/** Attached document (Documents tab). */
+export declare interface EventDocument {
+    id: string;
+    name: string;
+    fileType?: string;
+    url?: string;
+    sizeKb?: number;
+    uploadedByName?: string;
+    uploadedAt?: string;
+}
+
 /** Event location. */
 export declare interface EventLocation {
     name: string;
@@ -130,6 +157,12 @@ export declare interface EventMediaItem {
     caption?: string;
     likes?: number;
     tags?: string[];
+    /**
+     * Display position. Items sort by `order`, falling back to their index in
+     * the `items` array. Order is controlled by the caller: components emit
+     * `onReorder` and never hold their own copy of the sequence.
+     */
+    order?: number;
 }
 
 /** Core event model. */
@@ -170,7 +203,7 @@ export declare interface EventParticipant {
 declare type EventPlanningDisplayMode = 'micro' | 'compact' | 'normal' | 'full';
 
 /** Available planner tabs. */
-declare type EventPlanningTab = 'details' | 'location' | 'participants' | 'surveys' | 'budget' | 'settings';
+declare type EventPlanningTab = 'details' | 'location' | 'schedule' | 'participants' | 'tasks' | 'surveys' | 'vendors' | 'budget' | 'documents' | 'settings';
 
 /** Event round. */
 export declare interface EventRound {
@@ -251,6 +284,32 @@ export declare interface EventSurvey {
     isActive?: boolean;
 }
 
+/** Planning task / checklist item (Tasks tab). */
+export declare interface EventTask {
+    id: string;
+    title: string;
+    done?: boolean;
+    assigneeName?: string;
+    dueDate?: string;
+}
+
+/** Vendor / supplier (Vendors tab). */
+export declare interface EventVendor {
+    id: string;
+    name: string;
+    category?: string;
+    contact?: string;
+    status?: 'contacted' | 'quoted' | 'booked' | 'confirmed' | 'cancelled';
+    cost?: number;
+    currency?: string;
+}
+
+/** How the expense list is ordered. */
+export declare type ExpenseSortBy = 'date' | 'amount' | 'none';
+
+/** Which of the three views is showing. */
+export declare type ExpenseSplitView = 'expenses' | 'balances' | 'settlement';
+
 export declare interface FloorPlanUpsellConfig {
     /** Show "Add Floor Plan" button */
     showButton: boolean;
@@ -264,6 +323,17 @@ export declare interface FloorPlanUpsellConfig {
     autoLinkAddress: boolean;
 }
 
+/** What a guest is pledging. */
+export declare interface GiftContributionPayload {
+    amount?: number;
+    quantity?: number;
+    message?: string;
+    /** Always present — anonymous guests type it in. */
+    userName: string;
+    /** Only when the contributor was signed in. */
+    userId?: string;
+}
+
 /** Karaoke song with lyrics. */
 export declare interface KaraokeSong extends SongEntry {
     hasLyrics: boolean;
@@ -329,6 +399,16 @@ export declare interface NiceAttractionVotingProps {
     style?: default_2.CSSProperties;
 }
 
+/** One tile in a collage or slideshow. */
+export declare interface NiceCollageItem {
+    id: string;
+    mediaUrl: string;
+    type?: 'photo' | 'video';
+    caption?: string;
+    /** Slideshow dwell time for this tile; falls back to the collage default. */
+    durationMs?: number;
+}
+
 /**
  * {@link NiceEventMedia} — responsive media gallery (photos / videos) built from
  * Nice* controls: NiceUpload for adding media and NiceCardGroup for the layout.
@@ -355,6 +435,16 @@ export declare interface NiceEventMediaProps {
     uploadEnabled?: boolean;
     /** Filter by type. */
     typeFilter?: 'photo' | 'video' | 'all';
+    /**
+     * Enables drag-to-reorder and is called with the full id sequence after a
+     * move. Order is controlled: items render sorted by `EventMediaItem.order`
+     * (falling back to array position) and this component never keeps its own
+     * copy of the sequence, so the view cannot drift from what was saved.
+     *
+     * Reordering applies to the whole list, so it is ignored while `typeFilter`
+     * hides part of it.
+     */
+    onReorder?: (orderedIds: string[]) => void;
     className?: string;
     style?: default_2.CSSProperties;
 }
@@ -377,6 +467,14 @@ export declare interface NiceEventPlanningProps {
     surveys?: EventSurvey[];
     /** Billing items (Budget tab). */
     billing?: BillingItem[];
+    /** Agenda entries (Schedule tab). */
+    scheduleItems?: ScheduleItem[];
+    /** Planning tasks / checklist (Tasks tab). */
+    tasks?: EventTask[];
+    /** Vendors / suppliers (Vendors tab). */
+    vendors?: EventVendor[];
+    /** Attached documents (Documents tab). */
+    documents?: EventDocument[];
     /**
      * Display density / scope. `micro` renders only a summary card (no tabs);
      * `compact` shows the core tabs; `normal` (default) and `full` show everything.
@@ -388,6 +486,35 @@ export declare interface NiceEventPlanningProps {
     activeTab?: EventPlanningTab;
     /** Active-tab change handler. */
     onTabChange?: (tab: EventPlanningTab) => void;
+    /** Show only the tab icons (labels in the tooltip). Default `true`. */
+    tabsIconOnly?: boolean;
+    /** Center the tab strip. `'auto'` (default) centers only when icon-only. */
+    tabsCentered?: boolean | 'auto';
+    /**
+     * Where per-tab counts sit relative to the icon: `'bottom'` (default) — a
+     * heavily-rounded pill under the icon; `'right'` — inline after the icon.
+     */
+    countLocation?: 'bottom' | 'right';
+    /** Show the Details tab (default `true`). */
+    showDetails?: boolean;
+    /** Show the Location tab (default `true`). */
+    showLocation?: boolean;
+    /** Show the Schedule tab (default `true`). */
+    showSchedule?: boolean;
+    /** Show the Participants tab (default `true`). */
+    showParticipants?: boolean;
+    /** Show the Tasks tab (default `true`). */
+    showTasks?: boolean;
+    /** Show the Surveys tab (default `true`). */
+    showSurveys?: boolean;
+    /** Show the Vendors tab (default `true`). */
+    showVendors?: boolean;
+    /** Show the Budget tab (default `true`). */
+    showBudget?: boolean;
+    /** Show the Documents tab (default `true`). */
+    showDocuments?: boolean;
+    /** Show the Settings tab (default `true`). */
+    showSettings?: boolean;
     /** Whether editing is allowed. */
     editable?: boolean;
     /** Toolbar — Save handler (button shown when provided). */
@@ -412,6 +539,246 @@ export declare interface NiceEventPlanningProps {
     style?: default_2.CSSProperties;
 }
 
+/** A `BillingItem` that could not be included in the balance maths. */
+export declare interface NiceExpenseIssue {
+    itemId: string;
+    reason: 'no-payer' | 'unknown-payer' | 'no-participants';
+}
+
+/**
+ * {@link NiceExpenseSplit} — who paid, who owes, and the shortest way to square up.
+ *
+ * Three views over the same data: the expense list, each person's net balance,
+ * and a settlement plan that reduces the debt graph to few transfers (at most
+ * one less than the number of people who owe or are owed). The plan is not
+ * provably minimal — exact minimisation is NP-hard — but it is what every
+ * comparable product ships and it is optimal in ordinary cases.
+ *
+ * Arithmetic runs on integer minor units, so balances sum to exactly zero and
+ * no rounding drifts. Expenses in different currencies are grouped and settled
+ * separately rather than converted: applying an exchange rate silently at
+ * render time would be a correctness bug, and this package has no business
+ * owning FX rates.
+ *
+ * `BillingItem.isPaid` does not affect balances — it records that the vendor
+ * was paid, not that the group settled up.
+ */
+export declare const NiceExpenseSplit: default_2.ForwardRefExoticComponent<NiceExpenseSplitProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link NiceExpenseSplit}. */
+export declare interface NiceExpenseSplitProps {
+    /** Expenses, using the existing `BillingItem` shape. */
+    items: BillingItem[];
+    /** Everyone who can pay or owe. */
+    participants: Array<{
+        id: string;
+        name: string;
+        avatarUrl?: string;
+    }>;
+    /** Payments already made, subtracted before the plan is computed. */
+    settlements?: NiceSettlementTransfer[];
+    /** Which view to show. Leave unset to let the control manage it. */
+    view?: ExpenseSplitView;
+    defaultView?: ExpenseSplitView;
+    onViewChange?: (view: ExpenseSplitView) => void;
+    /** Called when a suggested transfer is marked as paid. */
+    onSettle?: (transfer: NiceSettlementTransfer) => void;
+    onItemDelete?: (itemId: string) => void;
+    onItemClick?: (item: BillingItem) => void;
+    /** Reports expenses that could not be included in the maths. */
+    onValidationChange?: (issues: NiceExpenseIssue[]) => void;
+    /**
+     * Order of the expense list. `'date'` sorts oldest first by
+     * `BillingItem.incurredAt`, leaving undated expenses at the end in the order
+     * they were given; `'none'` keeps the caller's order.
+     *
+     * Presentation only — balances and the settlement plan do not depend on it.
+     */
+    sortBy?: ExpenseSortBy;
+    /** Locale for money formatting. Defaults to the runtime locale. */
+    locale?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** A single contribution towards a gift registry item. */
+export declare interface NiceGiftContribution {
+    id: string;
+    /** Display name. Always present — a guest with no account types it in. */
+    contributorName: string;
+    /** Set only when the contributor was a signed-in user. */
+    contributorUserId?: string;
+    /** Money contributed (group gifting). */
+    amount?: number;
+    /** Units contributed, when the item is counted rather than funded. */
+    quantity?: number;
+    message?: string;
+    /** ISO timestamp. */
+    contributedAt: string;
+}
+
+/**
+ * {@link NiceGiftRegistry} — a gift list guests can actually use: what is still
+ * needed, what is already covered, and a way to chip in.
+ *
+ * Two shapes behind one component, chosen with `kind`. A **registry** counts
+ * units and money towards each gift, so several people can share the cost of
+ * something expensive. A **wishlist** drops the money and tracks priority and
+ * whether the thing has been bought.
+ *
+ * Both work with no signed-in user, because the guest view is normally reached
+ * through a public share link: an anonymous guest types their name and that
+ * comes back as `userName` with no `userId`.
+ *
+ * `hideContributors` hides the names but keeps the progress bar — you can see
+ * a gift is covered without seeing who covered it.
+ */
+export declare const NiceGiftRegistry: default_2.ForwardRefExoticComponent<NiceGiftRegistryProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** An item on a gift registry or wishlist. */
+export declare interface NiceGiftRegistryItem {
+    id: string;
+    title: string;
+    description?: string;
+    /** Link to a shop. */
+    url?: string;
+    imageUrl?: string;
+    price?: {
+        amount: number;
+        currency: string;
+    };
+    /** Units needed. Registry only; defaults to 1. */
+    quantityNeeded?: number;
+    /** Units already covered. Registry only. */
+    quantityContributed?: number;
+    contributions?: NiceGiftContribution[];
+    /** Wishlist only — higher sorts first. */
+    priority?: number;
+    /** Wishlist only. */
+    isPurchased?: boolean;
+    /** Wishlist only — who bought it, when known. */
+    purchasedByUserId?: string;
+}
+
+/** Props for {@link NiceGiftRegistry}. */
+export declare interface NiceGiftRegistryProps {
+    /** Items on the list. */
+    items: NiceGiftRegistryItem[];
+    /**
+     * `registry` tracks quantities and money towards each gift; `wishlist` is
+     * the same list without the money — priority and a bought/not-bought flag.
+     *
+     * Named `kind` rather than `variant` because `variant` already means the
+     * colour intent across the library.
+     */
+    kind?: 'registry' | 'wishlist';
+    /** `owner` manages the list; `guest` is the public, read-mostly view. */
+    mode?: 'owner' | 'guest';
+    /** Fallback currency for items with no price of their own. */
+    currency?: string;
+    locale?: string;
+    /**
+     * Hide who contributed what. The progress bar stays — the classic wedding
+     * registry behaviour, where you can see a gift is covered without seeing
+     * who covered it.
+     */
+    hideContributors?: boolean;
+    /**
+     * Signed-in user. Leave unset for a public share-token page; guests are
+     * then asked for a name before they can pledge.
+     */
+    currentUserId?: string;
+    currentUserName?: string;
+    onContribute?: (itemId: string, payload: GiftContributionPayload) => void;
+    /** "I'll take this one" — reserving the whole item. */
+    onClaim?: (itemId: string, payload: GiftContributionPayload) => void;
+    onUnclaim?: (itemId: string) => void;
+    onItemAdd?: (item: Omit<NiceGiftRegistryItem, 'id' | 'quantityContributed'>) => void;
+    onItemDelete?: (itemId: string) => void;
+    onItemClick?: (item: NiceGiftRegistryItem) => void;
+    layout?: 'grid' | 'list';
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/**
+ * {@link NiceInvitationDesigner} — write the invitation, see it as a guest will,
+ * and send it to a list.
+ *
+ * Split into an editor and a live preview. `{{token}}` placeholders are
+ * inserted from a row of buttons and resolved against `previewData` on the
+ * right, so you can check a real name lands where you meant it to. Substituted
+ * values are HTML-escaped — guest names are user input going into an HTML
+ * string.
+ *
+ * The recipient box is a textarea because the real workflow is pasting a
+ * column out of a spreadsheet: it splits on commas, semicolons, tabs and
+ * newlines, unwraps `Name <addr@example.com>`, and drops duplicates.
+ *
+ * `onSend` dispatches real mail, so pass `sending` while a send is in flight —
+ * the button stays disabled until you clear it.
+ */
+export declare const NiceInvitationDesigner: default_2.ForwardRefExoticComponent<NiceInvitationDesignerProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link NiceInvitationDesigner}. */
+export declare interface NiceInvitationDesignerProps {
+    /** The template being edited. */
+    template: NiceInvitationTemplate;
+    onTemplateChange?: (template: NiceInvitationTemplate) => void;
+    /** Placeholders offered as insert buttons. */
+    tokens?: NiceInvitationToken[];
+    /** Values substituted into the live preview. */
+    previewData?: Record<string, string>;
+    recipients?: NiceInvitationRecipient[];
+    onRecipientsChange?: (emails: string[]) => void;
+    /** Called to actually send. Guard it with {@link sending}. */
+    onSend?: (payload: {
+        templateId?: string;
+        emails: string[];
+    }) => void;
+    /**
+     * A send is in flight. Blocks the button — this dispatches real mail, and a
+     * double click is a double send.
+     */
+    sending?: boolean;
+    /** Editor toolbar. Defaults to a subset suited to writing an invitation. */
+    toolbar?: NiceHtmlEditorCommand[];
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** One address on the send list. */
+export declare interface NiceInvitationRecipient {
+    email: string;
+    name?: string;
+    status?: 'pending' | 'sent' | 'failed';
+}
+
+/** The invitation being written. */
+export declare interface NiceInvitationTemplate {
+    id?: string;
+    name: string;
+    /** HTML body, with `{{token}}` placeholders. */
+    body: string;
+    coverImageUrl?: string;
+}
+
+/** A placeholder the host can insert with one click. */
+export declare interface NiceInvitationToken {
+    key: string;
+    label: string;
+    sample?: string;
+}
+
 /**
  * {@link NiceKaraokePicker} — Karaoke song picker with queue management.
  */
@@ -437,6 +804,120 @@ export declare interface NiceKaraokePickerProps {
     style?: default_2.CSSProperties;
 }
 
+/**
+ * {@link NiceMediaCollage} — arrange photos and video into an ordered collage
+ * and play it back as a slideshow.
+ *
+ * The companion to `NiceEventMedia`: that one is for browsing what people
+ * uploaded, this one is for deciding what the montage looks like. Tiles are
+ * reordered by dragging or from the keyboard (focus a tile, Space to pick it
+ * up, arrows to move, Space to drop, Escape to cancel) — pointer events
+ * throughout, so it works on a phone.
+ *
+ * Order is controlled by the caller: the component sorts the `items` it is
+ * given and reports moves through `onReorder`.
+ */
+export declare const NiceMediaCollage: default_2.ForwardRefExoticComponent<NiceMediaCollageProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Arrangement used by `NiceMediaCollage`. */
+export declare type NiceMediaCollageLayout = 'sequence' | 'grid' | 'mosaic';
+
+/** Props for {@link NiceMediaCollage}. */
+export declare interface NiceMediaCollageProps {
+    /** Tiles, in the order they should appear. */
+    items: NiceCollageItem[];
+    /** Arrangement. `sequence` is a single ordered strip; the others are grids. */
+    layout?: NiceMediaCollageLayout;
+    /**
+     * Called with the full id sequence after a move. Order is controlled: the
+     * component never keeps its own copy, so the view cannot drift from what
+     * was persisted.
+     */
+    onReorder?: (orderedIds: string[]) => void;
+    onItemAdd?: (files: File[]) => void;
+    onItemRemove?: (id: string) => void;
+    onCaptionChange?: (id: string, caption: string) => void;
+    onItemClick?: (item: NiceCollageItem) => void;
+    /** Play the tiles as a slideshow instead of showing the editor. */
+    previewMode?: boolean;
+    transition?: 'none' | 'fade' | 'slide';
+    /** Dwell time per tile, unless the tile sets its own. Default `3000`. */
+    defaultDurationMs?: number;
+    /** Advance the slideshow automatically. Default `true` in preview. */
+    autoPlay?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** Net position of one participant in one currency. */
+export declare interface NiceParticipantBalance {
+    participantId: string;
+    participantName: string;
+    /** Positive: owed to them. Negative: they owe. Zero: settled up. */
+    amount: number;
+    currency: string;
+}
+
+/**
+ * {@link NiceParticipantList} — the guest roster: who is coming, who replied,
+ * who has arrived.
+ *
+ * Two modes. `organizer` is the management view: counts, grouping, search,
+ * per-row RSVP and check-in, and an invite box that parses a pasted list of
+ * addresses. `guest` is the self-service view — only the viewer's own row,
+ * with {@link NiceRsvpControl} for answering.
+ *
+ * Check-in by QR is wired through `onScan` plus a `checkInSlot` you fill with
+ * your own scanner, so the package takes no camera dependency and your app
+ * keeps control of the permission prompt.
+ */
+export declare const NiceParticipantList: default_2.ForwardRefExoticComponent<NiceParticipantListProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link NiceParticipantList}. */
+export declare interface NiceParticipantListProps {
+    /** The roster. */
+    participants: EventParticipant[];
+    /**
+     * `organizer` manages everyone; `guest` shows only the viewer's own entry
+     * with RSVP actions.
+     */
+    mode?: 'organizer' | 'guest';
+    /** Identifies the viewer's own row in `guest` mode. */
+    currentUserId?: string;
+    currentUserName?: string;
+    /** Called when a participant's RSVP changes. */
+    onRsvpChange?: (participantId: string, status: ParticipantStatus, selection?: NiceRsvpSelection) => void;
+    /** Called when a participant is checked in. */
+    onCheckIn?: (participantId: string) => void;
+    /**
+     * Called with a scanned code. Pair with {@link checkInSlot} to host your own
+     * scanner — this package does not take a camera dependency.
+     */
+    onScan?: (code: string) => void;
+    /** Your scanner UI, rendered in the toolbar when provided. */
+    checkInSlot?: default_2.ReactNode;
+    /** Called with parsed, de-duplicated addresses from the invite box. */
+    onInvite?: (emails: string[]) => void;
+    /** Extra columns. */
+    extraFields?: ParticipantExtraField[];
+    /** Group rows under headings. */
+    groupBy?: 'status' | 'role' | 'none';
+    /** Show the counts strip. */
+    showSummary?: boolean;
+    /** Show the filter/search row. */
+    showSearch?: boolean;
+    /** Offer plus-ones in guest mode. */
+    allowPlusOnes?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
 /**
  * {@link NiceRoundCard} — Individual round card with actions, timer, and scoreboard.
  */
@@ -491,6 +972,160 @@ export declare interface NiceRoundListProps {
     style?: default_2.CSSProperties;
 }
 
+/** The three answers a guest can give to an invitation. */
+export declare type NiceRsvpAnswer = 'yes' | 'maybe' | 'no';
+
+/**
+ * {@link NiceRsvpControl} — yes / maybe / no, with optional plus-ones and a note.
+ *
+ * Small on purpose: it is meant to be dropped onto a public invitation page
+ * reached through a share link, so it never assumes a signed-in user. When
+ * `currentUserId` is absent the guest types their name, and `onRespond`
+ * reports it as `userName` with no `userId`.
+ *
+ * `NiceParticipantList` embeds this same control in its guest mode, so there
+ * is exactly one RSVP implementation in the package.
+ */
+export declare const NiceRsvpControl: default_2.ForwardRefExoticComponent<NiceRsvpControlProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link NiceRsvpControl}. */
+export declare interface NiceRsvpControlProps {
+    /** Current answer, when the guest has already replied. */
+    value?: NiceRsvpAnswer;
+    /** Called when the guest commits a reply. */
+    onRespond?: (selection: NiceRsvpSelection) => void;
+    /** Offer a "+N guests" field. */
+    allowPlusOnes?: boolean;
+    /** Cap on additional guests. Default `5`. */
+    maxPlusOnes?: number;
+    /** Current number of additional guests. */
+    plusOnes?: number;
+    /** Offer a free-text note (dietary needs, arrival time…). */
+    allowNote?: boolean;
+    /**
+     * Signed-in user. Leave unset for a public invitation page — the guest is
+     * then asked for a name before they can reply.
+     */
+    currentUserId?: string;
+    currentUserName?: string;
+    /** Show only the answer buttons, without name, plus-ones or note. */
+    compact?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/** A guest's reply, including who replied and how many they bring. */
+export declare interface NiceRsvpSelection {
+    answer: NiceRsvpAnswer;
+    /** Additional guests beyond the responder. */
+    plusOnes?: number;
+    /** Display name — a guest arriving from a share link has no account. */
+    userName?: string;
+    userId?: string;
+    note?: string;
+}
+
+/**
+ * {@link NiceSeatingChart} — pick seats from a venue plan, at any venue size.
+ *
+ * Renders SVG with three levels of detail chosen from how many seats are
+ * actually in view: whole sections when zoomed out, row strips in between,
+ * individual seats up close. Because the tier is decided *after* culling, a
+ * 20 000-seat stadium and a 200-seat theatre both draw a bounded number of
+ * nodes — the cap is `maxRenderedSeats`, not the size of the chart.
+ *
+ * Two ways in, both always present. The map supports pan, pinch-zoom and a
+ * roving keyboard cursor (arrows to move, Home/End for the row ends,
+ * PageUp/PageDown between sections, Enter to toggle). Moving the cursor forces
+ * seat-level detail and pans to follow, because a focused element that gets
+ * culled away takes the focus with it. Alongside it, `showList` opens a plain
+ * section → row → seat picker with a "best available" button — the only
+ * workable path with a screen reader, and the one most sighted buyers want too.
+ *
+ * Accessible seats are distinguished by shape, pattern and text as well as
+ * colour, and survive being sold: use `Seat.accessType`, since `SeatStatus`
+ * alone cannot represent a sold wheelchair space.
+ */
+export declare const NiceSeatingChart: default_2.ForwardRefExoticComponent<NiceSeatingChartProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/** Props for {@link NiceSeatingChart}. */
+export declare interface NiceSeatingChartProps {
+    /** The venue layout, using the existing `SeatingChart` type. */
+    chart: SeatingChart;
+    /** `select` lets a buyer pick seats; `view` is read-only; `design` is reserved. */
+    mode?: 'design' | 'select' | 'view';
+    /** Selection rules: how many, which categories, whether gaps are allowed. */
+    selection?: SeatSelectionConfig;
+    /** Controlled selection. */
+    selectedSeatIds?: string[];
+    defaultSelectedSeatIds?: string[];
+    onSelectionChange?: (seatIds: string[]) => void;
+    /** Fires when a click is refused, with the reason. */
+    onSelectionRejected?: (rejection: {
+        reason: SelectionRejection;
+        seatId: string;
+    }) => void;
+    /** Live availability from the backend, overriding the statuses in `chart`. */
+    seatStatusOverrides?: Record<string, Seat['status']>;
+    onSeatClick?: (seat: Seat) => void;
+    /**
+     * Called when the buyer asks for the best available block. Leave unset to
+     * use the built-in pick (highest average view score in a legal run).
+     */
+    onBestAvailable?: (count: number, options: {
+        sectionId?: string;
+    }) => void;
+    /** Detail level. `auto` picks from how many seats are actually in view. */
+    lod?: 'auto' | SeatLodTier;
+    onLodChange?: (tier: SeatLodTier) => void;
+    /** Cap on seat nodes drawn at once. Default `2500`. */
+    maxRenderedSeats?: number;
+    /** Override the measured size — needed in tests and for SSR. */
+    containerSize?: ContainerSize;
+    showLegend?: boolean;
+    /** Show the non-visual section/row/seat picker. Default `false` here. */
+    showList?: boolean;
+    zoomable?: boolean;
+    locale?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    className?: string;
+    style?: default_2.CSSProperties;
+}
+
+/**
+ * {@link NiceSeatPicker} — the buy-a-ticket view: pick seats, see the total.
+ *
+ * A preset over {@link NiceSeatingChart} with `mode="select"` and the
+ * non-visual section → row → seat list open by default, since that is the
+ * flow most buyers use on a phone. Not a second implementation — every rule,
+ * from adjacency to accessible-seat rendering, is the same code.
+ *
+ * Reach for {@link NiceSeatingChart} directly when you need `view` mode or
+ * control over the level of detail.
+ */
+export declare const NiceSeatPicker: default_2.ForwardRefExoticComponent<NiceSeatPickerProps & default_2.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Props for {@link NiceSeatPicker} — {@link NiceSeatingChartProps} without the
+ * options that only make sense in the full editor.
+ */
+export declare type NiceSeatPickerProps = Omit<NiceSeatingChartProps, 'mode' | 'lod' | 'onLodChange'>;
+
+/** One payment in a settlement plan: `fromId` pays `toId`. */
+export declare interface NiceSettlementTransfer {
+    fromId: string;
+    fromName: string;
+    toId: string;
+    toName: string;
+    /** Major units (e.g. 12.50), matching {@link BillingItem.amount}. */
+    amount: number;
+    currency: string;
+}
+
 /**
  * {@link NiceSongPicker} — Song selection for music events.
  */
@@ -531,6 +1166,13 @@ export declare interface OccupancyMapConfig {
     alertThreshold: number;
 }
 
+/** An extra column, so hosts can show dietary needs or plus-ones without a model change. */
+export declare interface ParticipantExtraField {
+    key: string;
+    label: string;
+    render?: (participant: EventParticipant) => default_2.ReactNode;
+}
+
 /** Participant role. */
 export declare type ParticipantRole = 'host' | 'co-host' | 'moderator' | 'participant' | 'spectator' | 'vip';
 
@@ -548,6 +1190,16 @@ export declare interface RoundScore {
 /** Round status. */
 export declare type RoundStatus = 'upcoming' | 'active' | 'voting' | 'scored' | 'completed' | 'skipped';
 
+/** Agenda / schedule item (Schedule tab). */
+export declare interface ScheduleItem {
+    id: string;
+    title: string;
+    startTime?: string;
+    endTime?: string;
+    location?: string;
+    description?: string;
+}
+
 export declare interface Seat {
     id: string;
     row: string;
@@ -561,6 +1213,18 @@ export declare interface Seat {
     priceCategoryId: string;
     /** Status */
     status: SeatStatus;
+    /**
+     * Accessibility classification, independent of {@link status}.
+     *
+     * `SeatStatus` folds `'wheelchair'`/`'companion'` into the same union as
+     * `'sold'`/`'reserved'`, so a wheelchair seat loses its accessibility metadata
+     * the moment it is booked. Use this field instead: an accessible seat that is
+     * sold is `{ status: 'sold', accessType: 'wheelchair' }`.
+     *
+     * `status: 'wheelchair' | 'companion'` remains supported as a legacy alias for
+     * `{ status: 'available', accessType: … }`.
+     */
+    accessType?: 'wheelchair' | 'companion';
     /** View quality score (0-100) */
     viewScore?: number;
 }
@@ -599,23 +1263,45 @@ export declare interface SeatingSection {
     currency: string;
 }
 
+/** How much detail the chart draws. */
+declare type SeatLodTier = 'section' | 'row' | 'seat';
+
 export declare interface SeatSelectionConfig {
-    /** Max seats per order */
-    maxSeats: number;
-    /** Show prices */
-    showPrices: boolean;
-    /** Show view preview */
-    showViewPreview: boolean;
-    /** Interactive zoom/pan */
-    interactive: boolean;
-    /** Highlight available sections */
-    highlightAvailable: boolean;
-    /** Allow section-level selection */
-    sectionSelect: boolean;
+    /** Max seats per order. Default `8`. */
+    maxSeats?: number;
+    /** Show prices. Default `true`. */
+    showPrices?: boolean;
+    /** Show view preview. Default `false`. */
+    showViewPreview?: boolean;
+    /** Interactive zoom/pan. Default `true`. */
+    interactive?: boolean;
+    /** Highlight available sections. Default `true`. */
+    highlightAvailable?: boolean;
+    /** Allow section-level selection. Default `false`. */
+    sectionSelect?: boolean;
+    /**
+     * Forbid selections that strand a single empty seat inside a run of
+     * available seats. Applied per row, never across rows.
+     *
+     * Given the run of consecutive selectable seats containing the selection,
+     * a selection is rejected when it leaves exactly one seat free on either
+     * side. Leaving 0 or 2+ seats is allowed, and a run that was already a
+     * single seat may always be taken — you consume an orphan, you don't
+     * create one.
+     */
+    adjacentOnly?: boolean;
+    /**
+     * Restrict selection to these `Seat.priceCategoryId` values. Unset means
+     * every category is selectable.
+     */
+    allowedCategories?: string[];
 }
 
 export declare type SeatStatus = 'available' | 'reserved' | 'sold' | 'blocked' | 'wheelchair' | 'companion';
 
+/** Why a candidate selection was refused. */
+declare type SelectionRejection = 'unavailable' | 'category-not-allowed' | 'max-seats' | 'not-adjacent' | 'orphan-seat';
+
 /** Song entry. */
 export declare interface SongEntry {
     id: string;