@ripple-ui/svelte 0.0.0-stage → 0.8.2

package/dist/widgets/composite/bill-split.d.ts

@@ -0,0 +1,56 @@
+export declare const MIN_PEOPLE = 2;
+export declare const MAX_PEOPLE = 12;
+export declare const MAX_TIP = 100;
+export declare const DEFAULT_TIP = 18;
+export declare const DEFAULT_TIP_OPTIONS: number[];
+export interface Person {
+    id: string;
+    name: string;
+    /** What this person had on top of the shared part, e.g. drinks. */
+    extras: number;
+}
+/** The bound value: everything the visitor can edit. */
+export interface BillValue {
+    subtotal: number;
+    tip_percent: number;
+    people: Person[];
+}
+export interface Share extends Person {
+    /** What this person pays, tip and tax included, in minor units. */
+    cents: number;
+    /** The tip and tax inside `cents`: the share minus their even part and extras. */
+    added: number;
+}
+export interface Split {
+    shares: Share[];
+    /** Minor units. The bill the split used: subtotal (raised to the extras if they exceed it). */
+    subtotal: number;
+    tax: number;
+    tip: number;
+    /** subtotal + tax + tip, and exactly the sum of the shares. */
+    total: number;
+    /** Extras added up to more than the subtotal. */
+    over: boolean;
+}
+/** A number, or a string like "12.50", "$8" or "$1,240.50"; anything else is undefined. */
+export declare function toAmount(v: unknown): number | undefined;
+/** A tip percent from 18 or "20%", clamped to 0..100; junk is undefined. */
+export declare const clampTip: (v: unknown) => number | undefined;
+/** Decimal places of the currency's minor unit (USD 2, JPY 0, BHD 3); a bad code counts as USD. */
+export declare function minorDigits(currency: unknown): number;
+/** How many real people the model sent, before the 12 cap. */
+export declare const countPeople: (raw: unknown) => number;
+/** Model or bound people: at most 12, unique ids, a name, extras >= 0. */
+export declare function toPeople(raw: unknown): Person[];
+/** A fresh `pN` id, starting from `from`, that no one has yet. */
+export declare function nextId(ids: readonly string[], from?: number): string;
+/** Tip chips: 0..100 only (the rest dropped, not clamped), deduped, ascending, at most 6. */
+export declare function toTipOptions(raw: unknown): number[];
+/** A clean BillValue from model props or a bound value; undefined until there is a bill and a person. */
+export declare function toValue(raw: {
+    subtotal?: unknown;
+    tip_percent?: unknown;
+    people?: unknown;
+}): BillValue | undefined;
+/** Split a bill. Every amount out is in minor units (`digits` places); the shares add up to `total`. */
+export declare function split(v: BillValue, tax?: unknown, digits?: number): Split;

package/dist/widgets/composite/bill-split.js

@@ -0,0 +1,117 @@
+// widgets/composite/bill-split.ts: the pure half of the `bill-split` data
+// widget. Prop hygiene (model output in, clean BillValue out) and the split.
+//
+// Model output is messy, so every parser here never throws: money arrives as
+// 12.5, "12.50" or "$1,240.50", a tip as "20%", a person as a bare string.
+// Junk drops out (a null person is not a person, a 150% tip option is not a
+// chip) instead of being clamped into something that looks real.
+//
+// The split works in integer minor units of the currency (cents for USD, yen
+// for JPY, fils for BHD; `minorDigits`). Each person's weight is their even
+// part of the shared amount plus what they had on top (extras), so tax and
+// tip follow what each person ordered. Every share is floored and the
+// leftover units go to the first people, so the shares always add up to the
+// total exactly. Tax sits ON TOP of `subtotal` (the pre-tax bill); the tip is
+// a percent of the pre-tax subtotal. Extras that add up to more than the bill
+// raise the bill to their sum, and `over` says so.
+import { finite, plain } from '../data-kit/format.js';
+export const MIN_PEOPLE = 2;
+export const MAX_PEOPLE = 12;
+export const MAX_TIP = 100;
+export const DEFAULT_TIP = 18;
+export const DEFAULT_TIP_OPTIONS = [15, 18, 20, 22];
+/** A number, or a string like "12.50", "$8" or "$1,240.50"; anything else is undefined. */
+export function toAmount(v) {
+    if (typeof v !== 'string')
+        return finite(v);
+    const m = /^[^\d.-]{0,4}(-?(?:\d+\.?\d*|\.\d+))$/.exec(v.replace(/[\s,]/g, ''));
+    return m ? finite(m[1]) : undefined;
+}
+const amount = (v) => Math.max(0, toAmount(v) ?? 0);
+/** A tip percent from 18 or "20%", clamped to 0..100; junk is undefined. */
+export const clampTip = (v) => {
+    const n = typeof v === 'string' ? finite(v.trim().replace(/\s*%$/, '')) : finite(v);
+    return n === undefined ? undefined : Math.min(Math.max(n, 0), MAX_TIP);
+};
+/** Decimal places of the currency's minor unit (USD 2, JPY 0, BHD 3); a bad code counts as USD. */
+export function minorDigits(currency) {
+    const code = typeof currency === 'string' && currency.trim() ? currency.trim().toUpperCase() : 'USD';
+    try {
+        return new Intl.NumberFormat('en', { style: 'currency', currency: code }).resolvedOptions().maximumFractionDigits ?? 2;
+    }
+    catch {
+        return 2;
+    }
+}
+/** People entries worth keeping: objects (not arrays) and strings, which become a name. */
+const valid = (raw) => Array.isArray(raw)
+    ? raw.flatMap((p) => (typeof p === 'string' ? [{ name: p }] : p !== null && typeof p === 'object' && !Array.isArray(p) ? [p] : []))
+    : [];
+/** How many real people the model sent, before the 12 cap. */
+export const countPeople = (raw) => valid(raw).length;
+/** Model or bound people: at most 12, unique ids, a name, extras >= 0. */
+export function toPeople(raw) {
+    const seen = new Set();
+    const out = [];
+    for (const [i, o] of valid(raw).slice(0, MAX_PEOPLE).entries()) {
+        let id = typeof o.id === 'string' || typeof o.id === 'number' ? String(o.id).trim() : '';
+        if (!id || seen.has(id))
+            id = nextId([...seen], i + 1);
+        seen.add(id);
+        out.push({ id, name: plain(o.name) || `Person ${i + 1}`, extras: amount(o.extras) });
+    }
+    return out;
+}
+/** A fresh `pN` id, starting from `from`, that no one has yet. */
+export function nextId(ids, from = ids.length + 1) {
+    let k = from;
+    while (ids.includes(`p${k}`))
+        k++;
+    return `p${k}`;
+}
+/** Tip chips: 0..100 only (the rest dropped, not clamped), deduped, ascending, at most 6. */
+export function toTipOptions(raw) {
+    const list = Array.isArray(raw) ? raw.map(finite).filter((n) => n !== undefined && n >= 0 && n <= MAX_TIP) : [];
+    const clean = [...new Set(list)].toSorted((a, b) => a - b).slice(0, 6);
+    return clean.length ? clean : DEFAULT_TIP_OPTIONS;
+}
+/** A clean BillValue from model props or a bound value; undefined until there is a bill and a person. */
+export function toValue(raw) {
+    const sub = toAmount(raw.subtotal);
+    const people = toPeople(raw.people);
+    if (sub === undefined || !people.length)
+        return undefined;
+    return { subtotal: Math.max(0, sub), tip_percent: clampTip(raw.tip_percent) ?? DEFAULT_TIP, people };
+}
+/** Split a bill. Every amount out is in minor units (`digits` places); the shares add up to `total`. */
+export function split(v, tax = 0, digits = 2) {
+    const unit = 10 ** digits;
+    const minor = (x) => Math.round(amount(x) * unit);
+    const n = v.people.length;
+    const ex = v.people.map((p) => minor(p.extras));
+    const extras = ex.reduce((a, b) => a + b, 0);
+    const given = minor(v.subtotal);
+    const subtotal = Math.max(given, extras);
+    const taxM = minor(tax);
+    const tip = Math.round((subtotal * (clampTip(v.tip_percent) ?? 0)) / 100);
+    const total = subtotal + taxM + tip;
+    const shared = subtotal - extras;
+    // n * (shared / n + extras_i): integer weights that sum to n * subtotal.
+    const w = ex.map((e) => shared + n * e);
+    const W = w.reduce((a, b) => a + b, 0);
+    const pay = w.map((x) => (W ? Math.floor((total * x) / W) : 0));
+    if (!W && n)
+        pay[0] = total;
+    const left = total - pay.reduce((a, b) => a + b, 0);
+    if (n)
+        for (let i = 0; i < left; i++)
+            pay[i % n]++;
+    return {
+        shares: v.people.map((p, i) => ({ ...p, cents: pay[i], added: Math.max(0, Math.round(pay[i] - w[i] / n)) })),
+        subtotal,
+        tax: taxM,
+        tip,
+        total,
+        over: extras > given
+    };
+}

package/dist/widgets/composite/board-game.d.ts

@@ -0,0 +1,45 @@
+export type Game = 'tic-tac-toe' | 'connect-four';
+export type Difficulty = 'easy' | 'medium' | 'hard';
+export type Board = string[];
+export interface Dims {
+    rows: number;
+    cols: number;
+    need: number;
+}
+export declare const DIMS: Readonly<Record<Game, Dims>>;
+export declare const MARKS: Readonly<Record<Game, readonly [string, string]>>;
+/** Search depth of hard connect-four (plies). */
+export declare const C4_DEPTH = 5;
+export declare const emptyBoard: (game: Game) => Board;
+/** Every winning line (window) of the game, as cell indices. */
+export declare const LINES: Readonly<Record<Game, number[][]>>;
+/** The winning mark and its line, or null. */
+export declare function winner(game: Game, board: Board): {
+    mark: string;
+    line: number[];
+} | null;
+/** The line the mark at `cell` completes, if any. */
+export declare function winAt(game: Game, board: Board, cell: number): number[] | null;
+export declare const isFull: (board: Board) => boolean;
+/** The cell a token dropped in `col` lands on, or -1 when the column is full. */
+export declare function dropCell(board: Board, col: number): number;
+/** Legal moves: empty cells (tic-tac-toe) or columns with room (connect-four). */
+export declare function legalMoves(game: Game, board: Board): number[];
+/** The cell a move fills, or -1 when it is not legal. */
+export declare function moveCell(game: Game, board: Board, move: number): number;
+/** A new board with `move` played by `mark`, and the cell it filled; null when illegal. */
+export declare function play(game: Game, board: Board, move: number, mark: string): {
+    board: Board;
+    cell: number;
+} | null;
+/** A move that wins on the spot for `mark`, or -1. */
+export declare function winningMove(game: Game, board: Board, mark: string): number;
+/** The standard heuristic: open windows weighted by how full they are, plus the centre column. */
+export declare function c4Heuristic(board: Board, me: string, them: string): number;
+/**
+ * The computer's move for `me` against `them`: a cell (tic-tac-toe) or a
+ * column (connect-four); -1 when there is no legal move.
+ * easy: random legal. medium: win, else block, else random (connect-four
+ * leans to the centre). hard: tic-tac-toe full search, connect-four negamax.
+ */
+export declare function aiMove(game: Game, board: Board, me: string, them: string, difficulty: Difficulty, rand?: () => number, depth?: number): number;

package/dist/widgets/composite/board-game.js

@@ -0,0 +1,277 @@
+// widgets/composite/board-game.ts: the rules and the computer opponents of the
+// `board-game` widget (plan 2026-10-10, A3): tic-tac-toe (3x3, three in a row)
+// and connect-four (7 columns by 6 rows, four in a row). Pure TypeScript, no
+// DOM, no Svelte; BoardGame.svelte renders it and board-game.test.ts proves it.
+//
+// Invariants:
+// - A board is a flat, row-major string[] (row 0 on top); '' is empty and a
+//   filled cell holds the mark that took it ('X'/'O', 'red'/'yellow').
+// - A move is a cell index for tic-tac-toe and a column index for
+//   connect-four; `play` drops a connect-four token to the lowest free row.
+// - Every AI takes `rand` (default Math.random) so tests can pin it, and never
+//   mutates the board it is given.
+// - Hard tic-tac-toe is a full search (unbeatable). Hard connect-four is a
+//   depth-limited negamax with alpha-beta and the usual window heuristic;
+//   C4_DEPTH is sized so a move stays well under 50ms (see the timing test).
+export const DIMS = {
+    'tic-tac-toe': { rows: 3, cols: 3, need: 3 },
+    'connect-four': { rows: 6, cols: 7, need: 4 }
+};
+export const MARKS = {
+    'tic-tac-toe': ['X', 'O'],
+    'connect-four': ['red', 'yellow']
+};
+/** Search depth of hard connect-four (plies). */
+export const C4_DEPTH = 5;
+export const emptyBoard = (game) => Array(DIMS[game].rows * DIMS[game].cols).fill('');
+function buildLines({ rows, cols, need }) {
+    const out = [];
+    const dirs = [
+        [0, 1],
+        [1, 0],
+        [1, 1],
+        [1, -1]
+    ];
+    for (let r = 0; r < rows; r++)
+        for (let c = 0; c < cols; c++)
+            for (const [dr, dc] of dirs) {
+                const er = r + dr * (need - 1);
+                const ec = c + dc * (need - 1);
+                if (er < 0 || er >= rows || ec < 0 || ec >= cols)
+                    continue;
+                out.push(Array.from({ length: need }, (_, k) => (r + dr * k) * cols + (c + dc * k)));
+            }
+    return out;
+}
+/** Every winning line (window) of the game, as cell indices. */
+export const LINES = {
+    'tic-tac-toe': buildLines(DIMS['tic-tac-toe']),
+    'connect-four': buildLines(DIMS['connect-four'])
+};
+/** The lines through each cell, for checking only what the last move touched. */
+const THROUGH = {
+    'tic-tac-toe': through('tic-tac-toe'),
+    'connect-four': through('connect-four')
+};
+function through(game) {
+    const out = emptyBoard(game).map(() => []);
+    for (const line of LINES[game])
+        for (const i of line)
+            out[i].push(line);
+    return out;
+}
+/** The winning mark and its line, or null. */
+export function winner(game, board) {
+    for (const line of LINES[game]) {
+        const m = board[line[0]];
+        if (m && line.every((i) => board[i] === m))
+            return { mark: m, line };
+    }
+    return null;
+}
+/** The line the mark at `cell` completes, if any. */
+export function winAt(game, board, cell) {
+    const m = board[cell];
+    if (!m)
+        return null;
+    for (const line of THROUGH[game][cell])
+        if (line.every((i) => board[i] === m))
+            return line;
+    return null;
+}
+export const isFull = (board) => board.every((c) => c !== '');
+/** The cell a token dropped in `col` lands on, or -1 when the column is full. */
+export function dropCell(board, col) {
+    const { rows, cols } = DIMS['connect-four'];
+    if (col < 0 || col >= cols)
+        return -1;
+    for (let r = rows - 1; r >= 0; r--)
+        if (board[r * cols + col] === '')
+            return r * cols + col;
+    return -1;
+}
+/** Legal moves: empty cells (tic-tac-toe) or columns with room (connect-four). */
+export function legalMoves(game, board) {
+    if (game === 'tic-tac-toe')
+        return board.flatMap((c, i) => (c === '' ? [i] : []));
+    return Array.from({ length: DIMS[game].cols }, (_, c) => c).filter((c) => board[c] === '');
+}
+/** The cell a move fills, or -1 when it is not legal. */
+export function moveCell(game, board, move) {
+    if (game === 'connect-four')
+        return dropCell(board, move);
+    return Number.isInteger(move) && move >= 0 && move < board.length && board[move] === '' ? move : -1;
+}
+/** A new board with `move` played by `mark`, and the cell it filled; null when illegal. */
+export function play(game, board, move, mark) {
+    const cell = moveCell(game, board, move);
+    if (cell < 0)
+        return null;
+    const next = [...board];
+    next[cell] = mark;
+    return { board: next, cell };
+}
+const pick = (xs, rand) => xs[Math.min(xs.length - 1, Math.floor(rand() * xs.length))];
+/** A move that wins on the spot for `mark`, or -1. */
+export function winningMove(game, board, mark) {
+    for (const m of legalMoves(game, board)) {
+        const cell = moveCell(game, board, m);
+        board[cell] = mark;
+        const won = winAt(game, board, cell) !== null;
+        board[cell] = '';
+        if (won)
+            return m;
+    }
+    return -1;
+}
+// ---- tic-tac-toe, hard: full negamax, memoised by board -------------------
+const tttMemo = new Map();
+/**
+ * Best score for `me` to move, relative to this position: 10 for a win now,
+ * one less per move it takes; a loss the reverse; 0 for a draw. Relative
+ * scores are what make the memo valid at any depth.
+ */
+function tttScore(board, me, them) {
+    const key = board.join(',') + '|' + me;
+    const hit = tttMemo.get(key);
+    if (hit !== undefined)
+        return hit;
+    let best = -Infinity;
+    for (let i = 0; i < 9; i++) {
+        if (board[i] !== '')
+            continue;
+        board[i] = me;
+        const s = winAt('tic-tac-toe', board, i) ? 10 : -tttScore(board, them, me);
+        board[i] = '';
+        if (s > best)
+            best = s;
+    }
+    const score = best === -Infinity ? 0 : best > 0 ? best - 1 : best < 0 ? best + 1 : 0;
+    tttMemo.set(key, score);
+    return score;
+}
+function tttHard(board, me, them, rand) {
+    const b = [...board];
+    let best = -Infinity;
+    let bestMoves = [];
+    for (const m of legalMoves('tic-tac-toe', b)) {
+        b[m] = me;
+        const s = winAt('tic-tac-toe', b, m) ? 10 : -tttScore(b, them, me);
+        b[m] = '';
+        if (s > best)
+            [best, bestMoves] = [s, [m]];
+        else if (s === best)
+            bestMoves.push(m);
+    }
+    return pick(bestMoves, rand);
+}
+// ---- connect-four, hard: negamax with alpha-beta and a window heuristic ----
+const C4 = DIMS['connect-four'];
+const C4_ORDER = [3, 2, 4, 1, 5, 0, 6];
+const WIN = 1_000_000;
+function windowScore(board, line, me, them) {
+    let mine = 0;
+    let theirs = 0;
+    for (const i of line) {
+        if (board[i] === me)
+            mine++;
+        else if (board[i] === them)
+            theirs++;
+    }
+    if (mine && theirs)
+        return 0;
+    if (mine === 3)
+        return 5;
+    if (mine === 2)
+        return 2;
+    if (theirs === 3)
+        return -4;
+    if (theirs === 2)
+        return -1;
+    return 0;
+}
+/** The standard heuristic: open windows weighted by how full they are, plus the centre column. */
+export function c4Heuristic(board, me, them) {
+    let s = 0;
+    for (const line of LINES['connect-four'])
+        s += windowScore(board, line, me, them);
+    for (let r = 0; r < C4.rows; r++) {
+        const c = board[r * C4.cols + 3];
+        if (c === me)
+            s += 3;
+        else if (c === them)
+            s -= 3;
+    }
+    return s;
+}
+function negamax(board, depth, alpha, beta, me, them) {
+    if (depth === 0)
+        return c4Heuristic(board, me, them);
+    let best = -Infinity;
+    let any = false;
+    for (const col of C4_ORDER) {
+        const cell = dropCell(board, col);
+        if (cell < 0)
+            continue;
+        any = true;
+        board[cell] = me;
+        // A quicker win scores higher (more depth left).
+        const s = winAt('connect-four', board, cell) ? WIN + depth : -negamax(board, depth - 1, -beta, -alpha, them, me);
+        board[cell] = '';
+        if (s > best)
+            best = s;
+        if (best > alpha)
+            alpha = best;
+        if (alpha >= beta)
+            break;
+    }
+    return any ? best : 0;
+}
+function c4Hard(board, me, them, depth) {
+    const b = [...board];
+    let best = -Infinity;
+    let move = -1;
+    for (const col of C4_ORDER) {
+        const cell = dropCell(b, col);
+        if (cell < 0)
+            continue;
+        b[cell] = me;
+        const s = winAt('connect-four', b, cell) ? WIN + depth : -negamax(b, depth - 1, -Infinity, -best, them, me);
+        b[cell] = '';
+        if (s > best || move < 0)
+            [best, move] = [s, col];
+    }
+    return move;
+}
+/** A column chosen with weight 4 at the centre down to 1 at the edges. */
+function centreWeighted(moves, rand) {
+    const w = moves.map((c) => 4 - Math.abs(c - 3));
+    let r = rand() * w.reduce((a, b) => a + b, 0);
+    for (let k = 0; k < moves.length; k++)
+        if ((r -= w[k]) < 0)
+            return moves[k];
+    return moves[moves.length - 1];
+}
+/**
+ * The computer's move for `me` against `them`: a cell (tic-tac-toe) or a
+ * column (connect-four); -1 when there is no legal move.
+ * easy: random legal. medium: win, else block, else random (connect-four
+ * leans to the centre). hard: tic-tac-toe full search, connect-four negamax.
+ */
+export function aiMove(game, board, me, them, difficulty, rand = Math.random, depth = C4_DEPTH) {
+    const moves = legalMoves(game, board);
+    if (!moves.length)
+        return -1;
+    if (difficulty === 'easy')
+        return pick(moves, rand);
+    if (difficulty === 'hard')
+        return game === 'tic-tac-toe' ? tttHard(board, me, them, rand) : c4Hard(board, me, them, depth);
+    const b = [...board];
+    const win = winningMove(game, b, me);
+    if (win >= 0)
+        return win;
+    const block = winningMove(game, b, them);
+    if (block >= 0)
+        return block;
+    return game === 'connect-four' ? centreWeighted(moves, rand) : pick(moves, rand);
+}

package/dist/widgets/composite/booking.d.ts

@@ -0,0 +1,107 @@
+export type Service = {
+    id: string;
+    name: string;
+    kind?: string;
+    duration_min?: number;
+    price?: number;
+    image?: string;
+    party?: Bounds;
+    /** The service's own open days, when the data puts them there; they win over the top-level `days`. */
+    days?: Day[];
+};
+export type Bounds = {
+    min: number;
+    max: number;
+};
+export type Slot = {
+    start: string;
+    label: string;
+    available: boolean;
+};
+export type Day = {
+    date: string;
+    date_label: string;
+    slots: Slot[];
+};
+export type Preferred = {
+    date?: string;
+    after?: string;
+};
+export type Customer = {
+    name: string;
+    email?: string;
+    phone?: string;
+};
+export type BookingRequest = {
+    service_id: string;
+    start: string;
+    party?: number;
+    /** Left out when the widget asks for no contact details (`contact: false`). */
+    customer?: Customer;
+    notes?: string;
+};
+/** The request in progress, as the bound `selection` holds it. */
+export type Selection = {
+    service_id?: string;
+    start?: string;
+    party?: number;
+    customer?: {
+        name?: string;
+        email?: string;
+        phone?: string;
+    };
+    notes?: string;
+};
+export type Notice = {
+    kind: 'error' | 'info';
+    text: string;
+    code?: string;
+    start?: string;
+};
+export type Confirmed = {
+    booking_id: string;
+    label?: string;
+    date_label?: string;
+    service_name?: string;
+    party?: number;
+};
+export declare const LIMITS: {
+    readonly name: 80;
+    readonly notes: 500;
+    readonly email: 254;
+};
+export declare function readBounds(v: unknown): Bounds | undefined;
+export declare function readServices(v: unknown): Service[];
+export declare function readDays(v: unknown): Day[];
+export declare function readNotice(v: unknown): Notice | undefined;
+export declare function readConfirmed(v: unknown): Confirmed | undefined;
+export declare function readSelection(v: unknown): Selection;
+/** A host notice that says the slot just went: `code: 'slot_taken'`, or text that says "taken". */
+export declare function isSlotTaken(n: Notice | undefined): boolean;
+/** Minutes after midnight from "HH:MM" (or the time part of an ISO string), store-local. */
+export declare function clock(v: unknown): number | undefined;
+export declare const isOpen: (s: Slot, taken: ReadonlySet<string>) => boolean;
+/**
+ * The open slot nearest the visitor's ask: the first day on or after
+ * `preferred.date` with an open slot, then the slot closest to
+ * `preferred.after` there (a tie goes to the later slot, since the ask says
+ * "after"). Undefined without an ask, or when nothing is open from that day on.
+ */
+export declare function nearest(days: readonly Day[], pref: Preferred | undefined, taken: ReadonlySet<string>): {
+    date: string;
+    start: string;
+} | undefined;
+/** Slots grouped by part of the day, store-local; keeps each slot's index for keys. */
+export declare function partsOfDay(slots: readonly Slot[]): {
+    name: string;
+    slots: Array<{
+        slot: Slot;
+        i: number;
+    }>;
+}[];
+export type Errors = Partial<Record<'name' | 'contact' | 'email' | 'phone' | 'notes', string>>;
+/** The visitor's details, checked the way the host re-checks them. */
+/** `contact` false: only the notes are checked (a booking that asks for no contact details). */
+export declare function checkDetails(sel: Selection, contact?: boolean): Errors;
+/** The request to emit, or undefined while anything is missing or invalid. */
+export declare function toRequest(sel: Selection, service: Service | undefined, contact?: boolean): BookingRequest | undefined;