your-ai-workflow-firebase-os 2.0.10 → 2.0.13

package/dist/lib/schedule.d.ts

@@ -1,1025 +0,0 @@
-/**
- * Bookable time — the pure half of the Schedule feature.
- *
- * The owner's team says WHEN they can be booked, each in their own time zone:
- * which days, from when to when, how long a booking lasts, how far ahead and
- * with how much notice. A visitor then sees the free times in THEIR OWN time
- * zone and takes one. Everything that turns the first into the second lives
- * here, with no dependency and no clock of its own: every function that
- * needs "now" is handed it, so the same input always gives the same slots.
- *
- * Where things live (see firestore.rules):
- *   sys_schedules/{id}      one document per SCHEDULE — a kind of meeting one
- *                           team member offers ("A 1-hour session", "A 2-hour
- *                           workshop"), with its own hours, length, description
- *                           and, when the owner wants, a payment. A member may
- *                           have several; they share ONE availability, because
- *                           a person cannot be in two meetings at once. A sys_
- *                           collection reads openly (a guest on a booking page
- *                           has to see the free times) and writes admin-only.
- *                           A document from before schedules had names is keyed
- *                           by the member's uid and reads as one schedule of
- *                           theirs.
- *   pub_bookings/{slotId}   one document per TAKEN time, holding no names —
- *                           member, start, end. Its id IS the member and the
- *                           start, so two people cannot take the same time:
- *                           the second create fails. Anyone may create one.
- *                           A taken time blocks every schedule of that member
- *                           that overlaps it, whatever its length.
- *   mem_bookings/{slotId}   who booked and what they answered — the team's
- *                           copy, which the person who booked (when signed in)
- *                           may also read. Anyone may create one.
- *
- * A booking itself is a FORM ENTRY: the form gets one question of type
- * 'schedule', the built-in form renders the picker, and on send it claims the
- * slot, saves the entry the way every form entry is saved, and writes the
- * team's copy. The assistant never builds a calendar of its own. Every
- * schedule also has a booking page of its own, /book/{id}, shipped with the
- * app — the link the owner sends out.
- */
-export type DayKey = 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat' | 'sun';
-/** Monday first — the order a week is shown in. */
-export declare const DAY_KEYS: DayKey[];
-export declare const DAY_LABELS: Record<DayKey, string>;
-export declare const DAY_SHORT: Record<DayKey, string>;
-/** One stretch of bookable time on one day, 'HH:MM' to 'HH:MM' in the member's zone. */
-export interface TimeWindow {
-    from: string;
-    to: string;
-}
-/**
- * A day the person is NOT free, whatever their week says — a holiday, a
- * flight, an afternoon at the dentist.
- *
- * The week is the rule and this is the exception, which is why it is a date
- * and not another switch: an owner going away for a fortnight should not have
- * to empty their Tuesdays and remember to fill them in again. With no windows
- * the whole day is blocked; with windows, only those stretches of it are, so
- * "I am out on the 14th until two" is one row rather than a rewritten week.
- */
-export interface BlockedDate {
-    /** 'YYYY-MM-DD', read in the schedule's own zone — the same clock its hours are in. */
-    date: string;
-    /** The stretches that are spoken for. Empty means the whole day. */
-    windows: TimeWindow[];
-}
-/**
- * One thing a booking page asks for beyond the name and the email — a phone
- * number, what someone needs, which room they want. The owner writes these on
- * the Schedule screen the way a form's questions are written, and the booking
- * page draws them under the two it always asks.
- */
-export type BookingQuestionType = 'text' | 'textarea' | 'tel' | 'email' | 'number' | 'date' | 'select' | 'checkbox' | 'file';
-export interface BookingQuestion {
-    /** The key the answer is filed under in the entry and the team's copy — generated from the label, never shown. */
-    name: string;
-    /** What the visitor reads above the box. */
-    label: string;
-    type: BookingQuestionType;
-    /** On means the booking cannot be confirmed until it is answered. */
-    required: boolean;
-    /** The faint example inside the box. */
-    placeholder: string;
-    /** The choices behind a 'Choose one'; empty for every other kind. */
-    options: string[];
-}
-/** The kinds of answer a booking question can ask for, in the owner's words. */
-export declare const BOOKING_QUESTION_TYPES: {
-    value: string;
-    label: string;
-}[];
-/**
- * The example each kind of answer starts with — the faint words inside the
- * empty box on the booking page. Picking a kind fills this in, so a question
- * is never shipped with an empty box the owner meant to write an example for
- * and forgot; typing over it stops that for good (see bookingQuestionExample).
- * A date and a yes-no have no box to put words in, so they have none.
- */
-export declare const BOOKING_QUESTION_EXAMPLES: Record<BookingQuestionType, string>;
-/** The kinds with a box an example can be shown in: a date picker and a tick have none. */
-export declare const bookingQuestionHasExample: (type: string) => boolean;
-/**
- * The example a question wears after its kind changes. It follows the kind
- * while the words are still ours — an owner who typed their own example keeps
- * it, exactly the way a schedule's name stops following its length once it has
- * been written by hand.
- */
-export declare const bookingQuestionExample: (question: BookingQuestion, type: BookingQuestionType) => string;
-/**
- * The two every booking asks for, in the owner's own words.
- *
- * A name and an email are how the owner answers the person, so they are always
- * asked and always required — but the WORDS are the owner's, the same as every
- * other question: "Your name" can become "Who is coming?" and the example
- * inside the box can become anything. They are the first two questions of every
- * schedule, kept in front by the sanitizer, and the booking page draws them
- * itself rather than in the list, because what they are answered with does not
- * go in with the answers: it goes on the booking as the person's name and the
- * address a confirmation is sent to.
- */
-export declare const ALWAYS_ASKED: {
-    name: 'name' | 'email';
-    type: BookingQuestionType;
-    label: string;
-    placeholder: string;
-}[];
-/** Is this the name question or the email one — the two the page draws itself? */
-export declare const isAlwaysAsked: (name: string) => boolean;
-/**
- * The name question or the email one as this schedule asks it — the owner's
- * words when they wrote their own, ours when they did not. Never missing: a
- * schedule saved before these were editable simply reads as the two defaults.
- */
-export declare const alwaysAskedQuestion: (questions: BookingQuestion[], name: "name" | "email") => BookingQuestion;
-/**
- * What a schedule asks for when nothing has been written here: the two every
- * booking takes — a name and an email — and the note the booking page has
- * always asked for. A schedule that has never been touched reads as these
- * three, so nothing an older install asks for changes — and the owner can
- * rename any of them, add to them, or take the note away.
- */
-export declare const defaultBookingQuestions: () => BookingQuestion[];
-/** A fresh, empty question for the owner to fill in — with its kind's example already in it. */
-export declare const blankBookingQuestion: () => BookingQuestion;
-/** A label as a storage key: 'What is your phone number?' → 'what_is_your_phone_number'. */
-export declare const bookingQuestionSlug: (label: string) => string;
-/**
- * The key a question's answers are filed under. It follows the label only
- * while it still matches it — a key that was written by hand is left alone,
- * because changing it would orphan every answer already taken.
- */
-export declare function bookingQuestionName(question: BookingQuestion, label: string, siblings: BookingQuestion[]): string;
-/**
- * A stored list of questions back into a safe one. A document with no list at
- * all — every schedule made before this existed — reads as the note question;
- * a document with an empty list asks nothing beyond the name and the email,
- * because that is an answer the owner gave.
- */
-export declare function sanitizeBookingQuestions(raw: any): BookingQuestion[];
-/**
- * The questions listed under the two the page draws itself — one without words
- * to read is not asked at all, and the name and the email are never in here:
- * their answers become the booking's own name and email, not an answer beside
- * them.
- */
-export declare const askedQuestions: (questions: BookingQuestion[]) => BookingQuestion[];
-/** What a checkbox answer is remembered as. */
-export declare const TICKED = "Yes";
-/**
- * What is missing before a booking can be taken, by question name. Required
- * is the whole of it: the kind of box already keeps a date a date and a
- * number a number.
- */
-export declare function bookingAnswerProblems(questions: BookingQuestion[], answers: Record<string, string>): Record<string, string>;
-/** The answers as they are filed — the empty ones left out, so a booking keeps no blank keys. */
-export declare function bookingAnswerFields(questions: BookingQuestion[], answers: Record<string, string>): Record<string, string>;
-/** The same answers under the words the owner asked them in — what an email about a booking reads. */
-export declare function bookingAnswerLines(questions: BookingQuestion[], answers: Record<string, string>): Record<string, string>;
-export interface MemberSchedule {
-    /** The document id in sys_schedules — generated, or the member's uid for a document from before. */
-    id: string;
-    /** Whose time this is — the team member's uid. Every schedule of one member shares one availability. */
-    memberId: string;
-    /** The person's name as a visitor reads it beside a time. */
-    memberName: string;
-    /** What this kind of meeting is called — "A 1-hour session"; '' means after its length (scheduleName). */
-    name: string;
-    /** A line or two a visitor reads on the booking page about it. */
-    description: string;
-    /** What the booking page asks for beyond the name and the email. */
-    questions: BookingQuestion[];
-    /** A one-off payment on the Payments screen taken before the time is confirmed, or '' for none. */
-    paymentId: string;
-    /** Email the owner when a time is taken — a heads-up for a free booking, the sale alert for a paid one. */
-    notifyOwner: boolean;
-    /** Email the person who booked — a receipt when they pay, a note that the time is theirs when they book signed in. */
-    confirmBooker: boolean;
-    /** Whether it is being offered. A schedule the owner adds arrives on (freshSchedule); a stored one is off unless its document says otherwise. */
-    enabled: boolean;
-    /** An IANA zone, 'Europe/Rome' — every window below is read in it. */
-    timeZone: string;
-    /** How long one booking lasts. */
-    slotMinutes: number;
-    days: Record<DayKey, TimeWindow[]>;
-    /** The days the week's hours do not apply to — a holiday, or the hours of one date that are taken. */
-    blocked: BlockedDate[];
-    /** How many days ahead a visitor may book. */
-    horizonDays: number;
-    /** The least notice a booking needs, in hours. */
-    noticeHours: number;
-    createdAt?: number;
-    updatedAt?: number;
-    /**
-     * Held together at runtime out of a booking link and the hours it names,
-     * never read from one document and never written back as one. See
-     * bookingLinks.ts; `saveMemberSchedule` refuses anything wearing it.
-     */
-    joined?: boolean;
-    /**
-     * WHICH hours a joined meeting is booked in — the schedule document's own
-     * id, kept because the meeting wears the link's id and would otherwise have
-     * no way of saying where its week came from: it is how a holiday put on the
-     * week reaches every link booked in it. Absent on a document from before the
-     * split, which is its own hours and so answers with its own id.
-     */
-    scheduleId?: string;
-}
-/**
- * What a booking made from a /book link is stamped with. It is not a form id
- * any more — a booking writes no form entry — but it stays on the booking, and
- * the Inbox uses it to keep the bookings older installs DID file there out of a
- * list of messages. It lives here rather than on the booking page so the bell
- * and the Inbox can read it without pulling a page in behind it.
- */
-export declare const BOOKING_LINK_FORM_ID = "booking";
-export declare const SCHEDULES_COLLECTION = "sys_schedules";
-export declare const TAKEN_COLLECTION = "pub_bookings";
-export declare const BOOKINGS_COLLECTION = "mem_bookings";
-export declare const SLOT_LENGTHS: {
-    value: string;
-    label: string;
-}[];
-export declare const HORIZONS: {
-    value: string;
-    label: string;
-}[];
-export declare const NOTICES: {
-    value: string;
-    label: string;
-}[];
-/** Every half hour of a day, 'HH:MM' — where a window may START. */
-export declare const HALF_HOURS: {
-    value: string;
-    label: string;
-}[];
-/**
- * Where a window may END: every half hour after the first, then midnight as
- * '24:00' — so a late shift can run to the very end of the day and a window
- * that starts at 00:00 the next day meets it with no half hour lost between.
- */
-export declare const END_TIMES: {
-    value: string;
-    label: string;
-}[];
-/** The bare shape: weekdays nine to five, half-hour bookings, off — what a stored document is filled in from, and what the Schedule screen switches on before it hands the owner a new one. */
-export declare const blankMemberSchedule: (id: string, memberId?: string, memberName?: string, timeZone?: string) => MemberSchedule;
-export declare const isDateKey: (raw: unknown) => boolean;
-/**
- * Stored blocked days back into a safe list: real dates only, one row per
- * date with the windows of same-date rows folded together, in date order.
- * A row with no usable window blocks the whole day, which is what an owner
- * ticking a date means.
- */
-export declare function sanitizeBlockedDates(raw: any): BlockedDate[];
-/** The stretches of one date that are blocked, as wall-clock windows — [] when the date is free. */
-export declare function blockedWindows(schedule: MemberSchedule, dateKey: string): TimeWindow[];
-/** Whether nothing at all can be booked on that date. */
-export declare const dayBlocked: (schedule: MemberSchedule, dateKey: string) => boolean;
-/**
- * A Firestore document (or anything hand-edited) back into a safe schedule.
- * A document from before schedules had names of their own is keyed by the
- * member's uid and carries only the person's name: it reads as one schedule
- * of that member, called by their name, so nothing an older install offers
- * stops being bookable.
- */
-export declare const sanitizeMemberSchedule: (id: string, raw: any) => MemberSchedule;
-/** The zone this browser is in — what a visitor sees times in, and the default a member starts with. */
-export declare function detectTimeZone(): string;
-export declare function isTimeZone(tz: unknown): boolean;
-/** Every zone this runtime knows, for a searched picker. */
-export declare function allTimeZones(): string[];
-/** Zones whose name contains the typed words, the detected one first. */
-export declare function searchTimeZones(query: string, limit?: number): string[];
-export interface ZonedParts {
-    year: number;
-    month: number;
-    day: number;
-    hour: number;
-    minute: number;
-    second: number;
-    weekday: DayKey;
-    /** 'YYYY-MM-DD' in the zone. */
-    dateKey: string;
-    /** 'HH:MM' in the zone. */
-    time: string;
-}
-/** The wall-clock reading of an instant in a zone. */
-export declare function zonedParts(instant: Date, tz: string): ZonedParts;
-/** Minutes the zone is ahead of UTC at that instant — positive east of Greenwich. */
-export declare function zoneOffsetMinutes(tz: string, instant: Date): number;
-/**
- * The instant a wall-clock time in a zone names: 'YYYY-MM-DD' + 'HH:MM' in
- * tz → a Date. '24:00' is allowed and means the midnight that ends the day.
- * Two passes catch a daylight-saving change between the guess and the
- * answer. A time that does not exist (the spring-forward gap) is moved
- * FORWARD by the size of the gap — 02:30 on the night Rome skips 02:00–03:00
- * becomes 03:30 — the same way in every zone, rather than throwing or
- * landing before the gap in one zone and after it in another.
- */
-export declare function zonedToUtc(dateKey: string, time: string, tz: string): Date;
-/** 'YYYY-MM-DD' plus n days, done in UTC so no zone can shift it. */
-export declare function addDays(dateKey: string, n: number): string;
-/** Which weekday a 'YYYY-MM-DD' is — a calendar fact, the same in every zone. */
-export declare function weekdayOf(dateKey: string): DayKey;
-/** A 'YYYY-MM' month's name and year as the viewer's locale writes them — read in UTC so no zone can shift it. */
-export declare function monthLabel(month: string, locale?: string): string;
-/** The 'YYYY-MM' `by` months after (or before) another. */
-export declare function shiftMonth(month: string, by: number): string;
-/** One bookable time: two instants, whose time it is, and which schedule offered it. */
-export interface Slot {
-    /** ISO 8601, UTC. */
-    start: string;
-    end: string;
-    memberId: string;
-    /** The schedule the time was offered under — '' on a slot from before schedules had ids of their own. */
-    scheduleId: string;
-}
-/**
- * A time already taken — the shape pub_bookings holds, and what the picker
- * leaves out.
- *
- * `createdAt` is when the time was claimed. It matters to one question only:
- * whether a hold with no booking behind it is a booking still being made or
- * an hour left blocked by one that failed (see `orphanHolds`). Optional,
- * because a hold written before it was recorded has none — and because
- * nothing that works out FREE times has ever needed to know.
- */
-export interface TakenTime {
-    memberId: string;
-    start: string;
-    end: string;
-    createdAt?: number;
-    /**
-     * A paid hold that no longer keeps its time — let go, or run out unpaid
-     * (bookingHold.ts). Only ever on a list asked for with `keepOpen`: every
-     * other reader is never handed such a hold at all.
-     */
-    open?: boolean;
-}
-/** Whether two stretches of time share a minute — touching ends (10:00–11:00 and 11:00–12:00) do not. */
-export declare const overlaps: (a: {
-    start: string;
-    end: string;
-}, b: {
-    start: string;
-    end: string;
-}) => boolean;
-/**
- * The document id a taken time gets — the member and the start, nothing a
- * visitor could vary. Because the id is the slot, the database itself refuses
- * a second booking of the same time.
- */
-export declare const slotId: (memberId: string, startIso: string) => string;
-/**
- * The colours a booking or an event of the owner's own can be given.
- *
- * The default is the site's own accent, so a calendar nobody has touched is
- * all one colour — the theme's. The rest are fixed hues rather than more
- * theme variables: they are the owner's way of telling one kind of day apart
- * from another, and they must stay the same colour whatever accent the site
- * is wearing this week. Each is used as a TINT behind foreground text and as
- * a bar down the side of a card, never as text on a panel, so every one of
- * them reads in the light theme and the dark one.
- */
-export interface EventColor {
-    value: string;
-    label: string;
-    hex: string;
-}
-export declare const EVENT_COLORS: EventColor[];
-/** The colour a stored value names — the accent for '' and for anything unknown. */
-export declare const eventHex: (color: string) => string;
-/**
- * That colour at a fraction of itself, for a surface: `color-mix` against
- * transparent, the same way the theme makes its own washes, so one hex
- * serves as a wash behind text, a border and a bar.
- */
-export declare const eventTint: (color: string, percent: number) => string;
-/** Every quarter hour of a day, 'HH:MM' — where an event may start. */
-export declare const QUARTER_HOURS: {
-    value: string;
-    label: string;
-}[];
-/**
- * How long an event of the owner's own can run. The bookable lengths, plus
- * the two longer ones a morning or an afternoon takes — four hours is the
- * longest anything on this calendar may be, because that is how far the
- * claim looks back when it checks whether a time is free.
- */
-export declare const EVENT_LENGTHS: {
-    value: string;
-    label: string;
-}[];
-/** What an entry on the calendar is called: the owner's title, or who booked. */
-export declare const eventName: (e: {
-    own?: boolean;
-    title?: string;
-    name?: string;
-}) => string;
-/** The next quarter hour on or after the wall clock in a zone — an event's first offer of a time. */
-export declare function nextQuarterHour(instant: Date, tz: string): string;
-export interface SlotOptions {
-    /** The moment the list is made for — passed in, never read off a clock here. */
-    now: Date;
-    /**
-     * Times already taken, left out of the answer. A taken time removes every
-     * slot of the same MEMBER that overlaps it — a two-hour meeting at ten
-     * takes the one-hour slots at ten and eleven with it — because a person's
-     * schedules share one availability.
-     */
-    taken?: TakenTime[];
-    /** Fewer days than the member's horizon, when a screen only needs some. */
-    days?: number;
-}
-/**
- * Every free time a schedule offers from `now` to its horizon, oldest first.
- * Days are walked in the MEMBER's zone — a window of 09:00–17:00 means their
- * nine to five, whatever the visitor's clock says — and each start is turned
- * into an instant, so the visitor's side only ever formats instants.
- */
-export declare function availableSlots(schedule: MemberSchedule, options: SlotOptions): Slot[];
-/** Slots from several schedules, merged by start time. */
-export declare function availableSlotsFor(schedules: MemberSchedule[], options: SlotOptions): Slot[];
-/**
- * One schedule per PERSON, the first of each, in the order they came — what a
- * united booking is really made of. A meeting with the whole team books
- * PEOPLE, not meetings, and a person cannot sit in two of their own at once,
- * so a list that names two schedules of one member reads as that member once.
- */
-export declare function oneEach(schedules: MemberSchedule[]): MemberSchedule[];
-/**
- * Every time the WHOLE PARTY is free at once — the united calendar.
- *
- * A page that books several people has two quite different meanings, and only
- * the owner knows which one they meant. Separately: a visitor picks a person
- * and then one of that person's free times, which is what `availableSlotsFor`
- * gives — every schedule's times side by side. Together: the visitor is
- * booking ONE meeting that all of them attend, so a time is only offered when
- * every single one of them is free for the whole of it. That is this function,
- * and it is why the assistant must never work shared hours out for itself: it
- * cannot see anyone's hours, and a page that lists each person's times beside
- * each other is exactly the mess a united calendar is meant to replace.
- *
- * What the party's shared meeting is:
- *   how long   the LONGEST of their lengths — a 30-minute schedule and an hour
- *              one meet for an hour, because the hour cannot be cut in half.
- *   how far    the SHORTEST horizon — nobody is booked past their own.
- *   notice     the LONGEST — the person who needs a day gets a day.
- * A time is offered only when it fits inside a stretch every one of them
- * offers, and nothing already taken in ANY of their calendars touches it.
- *
- * The answer's slots are anchored on the first of them, so a pick is one slot
- * like any other; `partySlots` turns that one pick back into a time in each
- * person's own calendar when the booking is made.
- */
-export declare function togetherSlots(schedules: MemberSchedule[], options: SlotOptions): Slot[];
-/**
- * The times to offer for a booking, whichever kind it is — the ONE place
- * either question is asked, so a picker never has to know the difference.
- */
-export declare const slotsFor: (schedules: MemberSchedule[], options: SlotOptions, together: boolean) => Slot[];
-/**
- * One picked time as a time in EVERY person's own calendar — the same two
- * instants, once per member of the party. A united booking is claimed, written
- * and announced once for each of them, which is what puts it in each person's
- * own diary and rings each person's own bell.
- */
-export declare const partySlots: (slot: Slot, party: MemberSchedule[]) => Slot[];
-/** Everyone at once only means something with more than one PERSON on the page. */
-export declare const togetherPossible: (schedules: MemberSchedule[]) => boolean;
-/** Every schedule one member offers — the ones that share their availability. */
-export declare const schedulesOf: (schedules: MemberSchedule[], memberId: string) => MemberSchedule[];
-/** The schedule a slot was offered under, when the list still has it. */
-export declare const scheduleOfSlot: (slot: Slot, schedules: MemberSchedule[]) => MemberSchedule | undefined;
-/** The booking page every schedule has — the link the owner sends out. */
-export declare const bookingPath: (scheduleId: string) => string;
-/** The payment page every one-off payment has. */
-export declare const payPath: (productId: string) => string;
-/** A path as a full address on this app, for a link that leaves it — the path alone when there is no browser. */
-export declare function absoluteUrl(path: string): string;
-export interface SlotDay {
-    dateKey: string;
-    label: string;
-    slots: Slot[];
-}
-/** Slots grouped by the day they fall on in the VIEWER's zone, in order. */
-export declare function groupSlotsByDay(slots: Slot[], viewerTz: string, locale?: string): SlotDay[];
-/** 'Tue 12 Sep 2026' in the viewer's zone. */
-export declare function formatDay(instant: Date, tz: string, locale?: string): string;
-/** '10:00' or '10:00 AM' in the viewer's zone, as their locale writes it. */
-export declare function formatTime(instant: Date, tz: string, locale?: string): string;
-/** 'Tue 12 Sep 2026, 10:00–10:30' in the viewer's zone. */
-export declare function slotLabel(slot: Slot, tz: string, locale?: string): string;
-/**
- * A picked time as the two things a visitor checks — the day, and the hour it
- * runs. Two short lines rather than one long one: who it is with is already
- * the title of the page, and the zone is said once, at the foot of it.
- */
-export declare function slotWhen(slot: Slot, tz: string, locale?: string): {
-    day: string;
-    time: string;
-};
-/** 'Europe/Rome' as a visitor reads it: 'Europe / Rome'. */
-export declare const timeZoneLabel: (tz: string) => string;
-/** The one line a booking is remembered by — in the entry, the Inbox, the team's list. */
-export declare function bookingText(slot: Slot, memberName: string, tz: string, locale?: string): string;
-/**
- * What the picker stores in the form's answers while the form is open. A
- * trailing `|t` is the visitor's own choice on a `party: 'choose'` question —
- * this time is with the whole party — so the submit path knows to spread the
- * one pick across every one of their calendars. `decodeSlot` ignores it; the
- * flag is read on its own with `decodeSlotTogether`.
- */
-export declare const encodeSlot: (slot: Slot, together?: boolean) => string;
-export declare function decodeSlot(value: unknown): Slot | null;
-/** Whether an encoded pick carries the visitor's "with all of them" choice. */
-export declare const decodeSlotTogether: (value: unknown) => boolean;
-/**
- * What a booking writes into the saved form entry under the question's name:
- * the readable line, plus the facts beside it so a list can sort and a team
- * page can show who — one key each, strings all, like every other answer.
- */
-export declare function bookingEntryFields(fieldName: string, slot: Slot, memberName: string, viewerTz: string, locale?: string): Record<string, string>;
-/** The facts a booking keeps beside its readable line, read back from a saved entry. */
-export interface BookingFacts {
-    start: string;
-    end: string;
-    with: string;
-    timeZone: string;
-}
-/** The facts under a question's name, or null when that answer is not a booking. */
-export declare function bookingFacts(entry: Record<string, unknown>, key: string): BookingFacts | null;
-/**
- * Whether a saved form entry took a TIME — a form with a Pick-a-time question
- * on it, as against a form that only asked questions.
- *
- * An entry like that produces a booking as well as a message: the answers are
- * mail and belong in the Inbox, but the appointment is announced as a booking,
- * because that is what happened and because the booking feed already says so.
- * Without this the bell said both things about one act — "New booking" from
- * mem_bookings and "New form submission" from the entry beside it.
- */
-export declare const entryTookABooking: (entry: Record<string, unknown>) => boolean;
-/**
- * Whether a key is one of a booking's fact keys — they fold under the readable
- * line wherever an entry is shown, never as a row of their own.
- */
-export declare function isBookingFactKey(entry: Record<string, unknown>, key: string): boolean;
-/**
- * The same booking as the reader's own clock shows it — the line was written
- * in the visitor's zone — or '' when the reader's clock already reads the
- * same: the same zone, or another name for the same time (Rome and Berlin).
- */
-export declare function bookingInZone(facts: BookingFacts, tz: string, locale?: string): string;
-/**
- * The first thing a member's hours still need, in the order the screen asks;
- * '' when they are complete. A blank name is never one of them: the schedule
- * is called after its length until the owner names it (scheduleName), so a
- * fresh schedule turned on is bookable at once.
- */
-export declare function scheduleProblem(s: MemberSchedule): string;
-/**
- * What a set of HOURS still needs before anything can be booked on them — a
- * zone we know, days that make sense, and at least one of them on. '' means
- * the week is sound.
- *
- * It asks nothing about a meeting, because a schedule is not one any more: it
- * is when somebody is free, and a booking link is what puts a meeting on it.
- * `slotMinutes` is passed in only when there IS a meeting to measure the
- * hours against — a link's length, or a document from before the split, which
- * carries its own.
- */
-export declare function hoursProblem(s: MemberSchedule, slotMinutes?: number): string;
-/**
- * Whether hours are worth putting a booking link on — sound, and nothing
- * missing. Nothing about being switched on: hours have no switch. They are
- * the background a week is kept in, always live; what is offered or not
- * offered is the booking link sitting in them.
- */
-export declare const hoursReady: (s: MemberSchedule) => boolean;
-/** Whether a visitor can be offered this schedule's times: turned on and complete. */
-export declare const bookable: (s: MemberSchedule) => boolean;
-/** Every schedule a visitor could book right now. */
-export declare const bookableMembers: (schedules: MemberSchedule[]) => MemberSchedule[];
-export declare const autoScheduleName: (s: Pick<MemberSchedule, "slotMinutes">) => string;
-/** The schedule's name as a person reads it — the owner's, or the automatic one. Never ''. */
-export declare const scheduleName: (s: MemberSchedule) => string;
-/** 'A 1-hour session with Anna' — how a schedule is named wherever a person reads it. */
-export declare const scheduleTitle: (s: MemberSchedule) => string;
-/**
- * Whether this id is a MEETING somebody named — a booking link, or a document
- * from before links existed — rather than a plain week of hours. Those two
- * are exactly what `knownSchedules()` holds.
- */
-export declare const isNamedMeeting: (id: string, meetings?: MemberSchedule[]) => boolean;
-/**
- * What a MEETING is called, or '' when there is no meeting to name.
- *
- * A week of hours has a name too — "Working hours", "Studio days" — and it is
- * the team's own word for a block of time on the Schedule screen, which says
- * out loud that only they read it. It is not the name of anything anybody
- * books. A page built straight on somebody's hours takes a time with no
- * booking link in the way, and writing the week's name onto that booking put
- * "Working hours with Brian Foster" in front of the person who booked — a
- * phrase from inside the app, about a meeting they had just arranged in the
- * app's own words somewhere else.
- *
- * So the name is only ever taken from a real meeting. Anything else falls back
- * to whatever the page that took the booking calls itself, and to nothing at
- * all after that — a booking with no meeting name reads "A meeting with Brian
- * Foster", which is true, where the week's name was not.
- */
-export declare function meetingNameFor(s: MemberSchedule | undefined | null, fallback?: string, meetings?: MemberSchedule[]): string;
-/**
- * What a booking is called to the person who MADE it — the other side of
- * `eventName`, which names a booking after whoever booked it.
- *
- * Their own name is the one thing they do not need to be told, so their side
- * of the meeting is named after what it is and who it is with. A booking that
- * never got a meeting name (see meetingNameFor) is still "A meeting with
- * Brian Foster" rather than a blank.
- */
-export declare const bookingHeading: (b: {
-    scheduleName?: string;
-    memberName?: string;
-}) => string;
-/** The length of one booking as words — '1 hour', '45 minutes'. */
-export declare const slotLengthLabel: (minutes: number) => string;
-/**
- * The line a fresh schedule starts with, written into the box as a VALUE the
- * owner can rewrite — the same way the name is. It says the two things a
- * visitor needs before anything is typed: how long it is, and who with. While
- * the box still holds exactly this line it follows the length and the name;
- * one keystroke of the owner's own and it is theirs, untouched from then on.
- */
-export declare const autoScheduleDescription: (s: Pick<MemberSchedule, "slotMinutes" | "memberName">) => string;
-/**
- * The owner's OWN line about a meeting — empty while the box still holds the
- * line we wrote for them.
- *
- * The automatic line says the length and who it is with ("30 minutes with
- * Brian Foster. Pick a time that suits you."). On a card that already names
- * the meeting, says who it is with in that name and carries the length as a
- * pill, printing it again is the same three facts three times. So a card asks
- * for this instead of the raw description: it gets words when the owner wrote
- * some, and nothing when they have not.
- */
-export declare const scheduleBlurb: (s: MemberSchedule) => string;
-/**
- * A length split for a badge — { value: '30', unit: 'min' }, { value: '1',
- * unit: 'hour' }. The label is one string ('45 minutes'), and a badge wants
- * the number big and the unit small underneath it.
- */
-export declare const slotLengthParts: (minutes: number) => {
-    value: string;
-    unit: string;
-};
-/**
- * The week as one phrase — 'Mon–Fri 09:00–17:00', 'Mon, Wed, Fri 09:00–17:00',
- * 'Mon–Fri, hours vary' — or '' when no day is on at all.
- */
-export declare function daysLine(s: MemberSchedule): string;
-/** 'A 1-hour session with Anna — Mon–Fri 09:00–17:00 · 1 hour · Europe / Rome' — the one line a closed row shows. */
-export declare function scheduleSummary(s: MemberSchedule): string;
-/** Today where the reader is, so a date already gone can be told from one still to come. */
-export declare const todayKey: (now?: Date) => string;
-/**
- * What a set of hours is called until the owner names it. Not after a length
- * any more — a schedule is somebody's week, and 'A short meeting' is what a
- * booking link on it is called.
- */
-export declare const hoursName: (s: Pick<MemberSchedule, "name">) => string;
-/** 'Anna · Working hours' — how a set of hours is named where a link picks one. */
-export declare const hoursLabel: (s: MemberSchedule) => string;
-/**
- * 'Working hours — Mon–Fri 09:00–17:00 · Europe / Rome' — the one line a
- * closed schedule row shows. No length and no meeting: those belong to the
- * booking links on it, which say them on their own rows.
- */
-export declare function hoursSummary(s: MemberSchedule, today?: string): string;
-export declare const setKnownSchedules: (schedules: MemberSchedule[]) => void;
-export declare const knownSchedules: () => MemberSchedule[];
-export declare const setKnownTeamHours: (hours: MemberSchedule[]) => void;
-export declare const knownTeamHours: () => MemberSchedule[];
-/**
- * Everything a 'schedule' form question can resolve: the named meetings a
- * booking link carries, AND the plain weeks a page is built on — the picker
- * books those hours straight, at the app's own length, so a page never needs
- * a booking link to take a time. A week is offered only when it is sound
- * (`bookable`); the two lists are merged with the meetings winning an id
- * clash, which only a legacy document can cause.
- */
-export declare const knownBookableEntities: () => MemberSchedule[];
-/**
- * How the picker looks on the page: the whole calendar, or a compact list of
- * days and times. A form question carries it; a PAGE does not — the page's
- * row asks only how booking should work, and the assistant picks the look
- * from those words (BOOKING_LOOK_LINE). The Forms screen still offers the
- * pair on a Pick-a-time question, where there are no words to pick from.
- */
-export type BookingLook = 'calendar' | 'compact';
-export declare const BOOKING_LOOKS: {
-    value: BookingLook;
-    label: string;
-}[];
-/**
- * Who a booking on this page is with, when more than one person's hours are
- * on it — the owner's answer to a question a single person never raises.
- *
- *   'each'   individual: the visitor picks one of them, then one of that
- *            person's own free times. The default, and the only meaning a
- *            single person can have.
- *   'all'    the united team: ONE meeting the whole party attends, offered
- *            only at the times every one of them is free at once.
- *   'choose' both: one time question that lets the VISITOR pick — meet one of
- *            us, or meet all of us — so a page can carry the 1:1 and the
- *            group booking without two pickers.
- */
-export type BookingParty = 'each' | 'all' | 'choose';
-export declare const BOOKING_PARTIES: {
-    value: BookingParty;
-    label: string;
-}[];
-/**
- * Who a stored booking is with. `party` is read as it is when it is one of
- * the three; a document from before the choice was more than a switch carries
- * `together: true` for the united team and nothing for an individual one.
- */
-export declare const storedParty: (raw: any) => BookingParty;
-/**
- * What a page row stores under `booking` once the owner picks a schedule for
- * it. The key is still called `booking` — every stored page says it — but
- * what it holds is somebody's HOURS and what the page makes of them, which is
- * a booking only when the words ask for one.
- */
-export interface PageBooking {
-    /** The hours the page is built on — one set per team member. */
-    schedules: string[];
-    /** Who a booking here is with when more than one person is on the page. */
-    party: BookingParty;
-    /**
-     * What the page asks the visitor before they pick a time, in the owner's
-     * words — and, by being answered at all, that this page takes bookings.
-     * Empty means nothing is booked here unless the words below say so.
-     */
-    ask: string;
-    /** What this page does with those hours, in the owner's words. The first thing asked. */
-    how: string;
-}
-/**
- * The ids a stored booking names — `schedules`, or `members` from before a
- * schedule had an id of its own (then the member's uid IS the id of their
- * one schedule, so the old list still resolves).
- */
-export declare const storedScheduleIds: (raw: any) => string[];
-/** The ONE parser of a page's stored booking, each field made safe; null when nothing is attached. */
-export declare function pageBooking(config: any): PageBooking | null;
-/**
- * The WEEK one stored pick means, or undefined when it means nothing any more.
- *
- * A page picks hours. It did not always: until the Pages screen offered weeks
- * it offered the meetings booked in them, so a page saved before that holds a
- * booking link's id where a week's is expected. That page meant "Anna's
- * hours" then and means it now, so a link's id resolves to the week it is
- * booked in rather than reading as a schedule that no longer exists.
- */
-export declare const hoursOf: (id: string, hours: MemberSchedule[], meetings?: MemberSchedule[]) => MemberSchedule | undefined;
-/** The same, for a whole stored list — the ids as the row should now hold them. */
-export declare const hoursIds: (ids: string[], hours: MemberSchedule[], meetings?: MemberSchedule[]) => string[];
-/** The hours a page's picks point at, in pick order — ids that mean nothing any more are dropped. */
-export declare const bookingMembers: (booking: PageBooking, schedules: MemberSchedule[], meetings?: MemberSchedule[]) => MemberSchedule[];
-/**
- * Pick a schedule into a list, one per person: choosing a second schedule of
- * the same member replaces their first, because one person has one
- * availability and a page offers one kind of meeting with them. Picking one
- * already in the list takes it out.
- */
-export declare function pickSchedule(picked: string[], id: string, schedules: MemberSchedule[]): string[];
-/** The members' names as one phrase — "Anna", "Anna and Bob", "Anna, Bob and Cy". */
-export declare const memberNames: (list: MemberSchedule[]) => string;
-/** The schedules as one phrase — "A 1-hour session with Anna, and A 2-hour workshop with Bob". */
-export declare const scheduleTitles: (list: MemberSchedule[]) => string;
-/**
- * NOTE: there was a `meetingsOn` here that turned the hours a page picked
- * into the booking LINKS sitting in them, and every booking sentence went
- * through it. It is gone, deliberately. A schedule and a booking link are two
- * separate things the owner attaches in two separate sections: hours are the
- * building block the assistant builds on, a link is an address that already
- * works. Tying the first to the second meant a page could pick somebody's
- * week, say exactly what it wanted, and get no sentence at all until a link
- * was made on another screen. Nothing here may reach for a link again.
- */
-/**
- * What is still missing before the hours a page was given can ride its
- * sentence — the first thing, in the order the row asks; '' when it is ready.
- * A member whose hours are unfinished on the Schedule screen holds the page
- * back and is named, so the owner knows which screen to return to. The middle
- * question is asked in the hours' own words, not booking's: what the page
- * makes of them is what the box asks and what the sentence carries.
- *
- * Nothing here asks for a booking link. A schedule is the building block and
- * booking links are a separate section: the owner picks somebody's WEEK, says
- * what the page does with it, and the assistant builds it — a rota, a shift
- * board, or a booking straight on those hours. So the only things that hold
- * the sentence back are a pick that has gone, a week that is not sound, and
- * the one box that is always answered: what the page makes of the hours.
- */
-export declare function bookingBlocker(config: any, hours: MemberSchedule[], meetings?: MemberSchedule[]): string;
-export declare const mentionsBooking: (words: string) => boolean;
-/**
- * The owner's own words about a page, gathered from every box that holds
- * any: what is on it, what should change about it, and what the page does
- * with the hours it was given.
- */
-export declare const pageWords: (config: any) => string;
-/**
- * Whether the hours a page was given are for BOOKING.
- *
- * A schedule is not a booking and never implies one — it is the building
- * block, and what is made of it is the owner's words' business: a booking, a
- * rota, a shift board, who is in on Thursday. So an empty box asks for
- * NOTHING, booking included; only words that name a booking or a meeting turn
- * the picker on. (The row holds every sentence back until "how will it be
- * used" is answered anyway, so hours that say nothing at all never reach a
- * page in the first place.)
- */
-export declare const wantsBooking: (words: string) => boolean;
-/**
- * Whether a page with hours on it is taking BOOKINGS — the one test the
- * blocker and the sentence share, so the row never holds a page back for a
- * booking the sentence then decides not to build.
- *
- * Three ways the owner says yes. What the page asks BEFORE a time is picked is
- * a question only a booking has, so anything in that box is the owner saying
- * this is one, whatever the other boxes call it. Who the booking is WITH is the
- * same kind of answer: nobody picks "one meeting with all of us" for a rota, so
- * moving that away from its default says booking as plainly as the words do.
- * Failing both, the owner's own words decide — and left saying nothing at all,
- * nothing is booked here.
- */
-export declare const asksForBooking: (config: any, booking?: PageBooking | null) => boolean;
-/**
- * Whether a page's visitors book straight on the HOURS it was given — the
- * booking sentence's own test, so the row and the sentence agree on it.
- *
- * A time booked on hours is always free: a week carries no price, only a
- * booking link does, so the form has nothing to charge and ContactPopup takes
- * no money. A page that books on hours AND is ticked for a payment was told
- * both "never a PayButton or a price for a booking" and "<BuyButton
- * amount={18}>", and the owner who wrote "paid when they book" got a page
- * that took bookings for nothing (the Lotus Yoga rehearsal, 2026-09-26).
- */
-export declare const booksOnHours: (config: any, hours: MemberSchedule[], meetings?: MemberSchedule[]) => boolean;
-export declare const PAID_BOOKING_WORDS: RegExp;
-/**
- * Whether the owner's words make the payment the price of the booking (see
- * PAID_BOOKING_WORDS). Read one part of a sentence at a time — split at a
- * stop (never the point in "£12.50"), a line, a colon, a bracket, a dash or
- * a comma — so "the first class is free, the rest are paid when they book"
- * ties, "no booking fee" never does, and "book a free class and pay by card
- * for your mat" no longer held the page and took its mats away.
- */
-export declare const tiesPaymentToBooking: (words: string) => boolean;
-/** The one rule every booking sentence carries, word for word, wherever it is built. */
-export declare const BOOKING_RULE = "Booking goes through the app's own form system: the page's form gets ONE question of type 'schedule', and the built-in form draws the picker \u2014 never build a calendar, a time picker, a list of times or a bookings collection of your own. The app shows every visitor the free times in their own time zone, stops two people taking the same time, and lists every booking on my Schedule screen. It also tells the people it was booked with \u2014 the booking is in their bell and on their own calendar the moment it is made \u2014 so never send a notification of your own about a booking. When the time booked takes a payment, the same form sends the visitor to pay before it is theirs \u2014 so never add a PayButton, a checkout or a price of your own for a booking.";
-/**
- * The exact question the assistant adds to the form's fields — copied
- * verbatim, ids and all. It carries no `look`: that is the assistant's call,
- * made from the owner's words, and BOOKING_LOOK_LINE says how. `schedules`
- * are the ids the page picked — somebody's WEEK — and the built-in picker
- * reads those hours live, so the page follows a change to them on its own.
- *
- * `party` is 'all' for one meeting the whole party attends (`together: true`),
- * 'choose' for a picker that lets the visitor pick either, and 'each' — the
- * default — for one of them at a time.
- */
-export declare const scheduleQuestion: (schedules: string[], name?: string, party?: BookingParty) => string;
-/**
- * A meeting with the whole party — the rule that stops the assistant building
- * the mess it built the first time it was asked for one.
- *
- * Asked for "a united calendar where only the times that suit both of us
- * show", an assistant that is handed two schedule ids and nothing else does
- * the only thing it can: it puts both people's times on the page, side by
- * side, and the owner gets two calendars instead of the one they asked for.
- * It cannot do better on its own — it cannot see anyone's hours, and the
- * hours live in a collection it is forbidden to read. So the ANSWER is not a
- * better prompt about how to work out shared times: it is one more word on
- * the question the app already draws. `together: true` and the built-in
- * picker does the intersecting, the claiming and the telling.
- */
-export declare const TOGETHER_RULE = "With together: true the app offers only the times every single one of them is free at the same moment \u2014 in the visitor's own time zone \u2014 and one booking takes that time in every one of their calendars and tells every one of them. Never work the shared times out yourself, never draw a calendar or a list of anyone's hours, never ask the visitor to pick a person first, and never make more than one booking or more than one time question.";
-/**
- * Both kinds at once — the rule for `party: 'choose'`. One time question, and
- * the built-in picker draws the switch: the assistant builds nothing of it.
- */
-export declare const CHOOSE_RULE = "With party: 'choose' the built-in picker shows the visitor a switch above the times \u2014 meet one of us, or meet all of us. On 'one of us' it offers each person's own free times with their name under each; on 'all of us' only the times every one of them is free at once, and the booking is then made and announced the right way for whichever they chose. Never build that switch, a calendar or a list of anyone's hours yourself, never ask the visitor to pick a person before the switch, and never make more than one time question.";
-/**
- * The same word, offered as a DECISION — for the page whose owner said what
- * they wanted in the box rather than by the switch beside it.
- *
- * "A united calendar to book a meeting with the whole team, only intervals
- * that work for both of us" is a perfectly clear sentence, and an assistant
- * that is handed two schedule ids and no way to say "together" can only
- * disobey it. So wherever more than one person is on offer and the switch is
- * off, the words get their chance: this line says which word to add, and what
- * it does, so the sentence in the box can still be obeyed exactly.
- */
-export declare const togetherChoiceLine: () => string;
-/**
- * What the page asks when somebody books, in the owner's words. The owner
- * writes what they need to know, not fields — the assistant chooses the kind
- * of box each answer takes, the way it does everywhere else.
- *
- * It never says WHEN they are asked. It used to say "before the time is
- * picked", two lines under BOOKING_LOOK_LINE's calendar, which puts the other
- * questions AFTER the time — the Lotus Yoga rehearsal (2026-09-26) read the
- * order both ways in one sentence. Where they sit is the look's: the built-in
- * form leads with a calendar and follows it with the rest.
- */
-export declare const askLine: (ask: string) => string;
-/**
- * The picker's look, left to the assistant. The row used to ask "How should
- * the booking look?" beside the words on how booking works — the same
- * question twice, and one the owner's words already answer. Now the sentence
- * names the two looks, what each does to the page, and the tie-break.
- */
-export declare const BOOKING_LOOK_LINE = "Decide how the picker looks from my words and add a look to that question. look: 'calendar' when the page is about booking \u2014 the question draws a whole calendar with the free times under it, so show the form inline with <ContactPopup formId='\u2026' isInline /> and give it the full width of the page, the other questions following once a time is picked. look: 'compact' when booking is one question among others \u2014 the question draws a compact picker of days and times and sits among the other questions like any of them, and the form shows the way any other form on the page does. If my words do not say, a page that is about nothing but booking gets the calendar and every other page gets the compact picker.";
-/** The hook line a team page reads bookings with — the ONE way, named the same everywhere. */
-export declare const USE_BOOKINGS_RULE = "Read them with useBookings() from 'your-ai-workflow-firebase-os' \u2014 { loading, bookings, error }, each booking with id, start and end (ISO, UTC), memberId, memberName, name, email, answers and formId \u2014 the upcoming ones, soonest first; show error when it is set, format times in the reader's own zone, and cancel one with cancelBooking(id, { reason, side: 'host' }) from the same package \u2014 always with a reason, because it is what the other side reads. Never read mem_bookings or pub_bookings by hand, and never write to them. An entry with own:true is an event the owner put on their own calendar rather than a booking: it has no name or email, so title every entry with eventName(booking) from the same package. An entry with cancelled:true was called off \u2014 its time is free again, so keep it in the list greyed out and struck through rather than dropping it, and show its cancelReason when it has one. An entry with pending:true is booked but NOT yet agreed to by the person whose hour it is: mark it Pending and never draw it as a settled meeting. They accept their own with acceptBooking(id) \u2014 offer that only when booking.memberId is the signed-in person's own uid, because a meeting in somebody else's diary is not theirs to agree to. Turning a booking down is cancelBooking with a reason, never a state of its own.";
-/**
- * Words that make a team page about bookings that have ENDED — today's, who
- * came, what happened. useBookings() drops a booking the moment it ends, so a
- * page for "today's classes at a glance … a tick beside each student to mark
- * who came" lost each class as it finished (the Lotus Yoga rehearsal,
- * 2026-09-26). The option that keeps them was named nowhere a page is built
- * from.
- */
-export declare const PAST_BOOKINGS_WORDS: RegExp;
-/** Said beside USE_BOOKINGS_RULE when the words are about bookings that end while the page is open. */
-export declare const PAST_BOOKINGS_LINE = "useBookings() drops a booking the moment it ends, and this page is about ones that have: read them with useBookings({ includePast: true }) instead \u2014 the upcoming ones soonest first, then the past ones, most recent first \u2014 and pick the day or the stretch it shows by each booking's start, in the reader's own zone. A class that has finished is still on today's list.";
-/**
- * Words that put something ON a booking from a team page — a tick for who
- * came, a note, a mark. The Lotus Yoga rehearsal (2026-09-26) built its
- * Teachers page with the ticks and the notes in useState, so a reload lost
- * every one: nothing said where they are saved, and the booking itself is
- * not the page's to write.
- */
-export declare const BOOKING_MARK_WORDS: RegExp;
-/** Where a team page keeps what it marks on a booking: its own records, one per booking. */
-export declare const BOOKING_MARKS_LINE = "What this page puts ON a booking \u2014 who came, a note, a tick \u2014 is never written onto the booking, which is not the page's to write: it is ONE record of this page's own per booking, carrying bookingId: booking.id, added with await actions.saveRecord({ bookingId: booking.id, \u2026 }) the first time something is marked and changed with actions.updateRecord(id, change) after, and found again in actions.records by that bookingId. So a reload keeps every tick and every note, and everybody on this page sees the same ones. Never keep them only in state.";
-/**
- * The OTHER window on the bookings, and the one that had none.
- *
- * useBookings() reads mem_bookings, which the pasted rules give the team and
- * nobody else — so a page for Members that reaches for it is answered with a
- * permission error, not an empty list. And a person's own meetings are not in
- * a user_ collection either: they are in the team's, readable by whoever the
- * booking names. That left "a page where my clients see their appointments",
- * which owners keep asking for, with nothing at all to reach for: the build
- * warns about mem_bookings, the rules refuse it, and the only thing a weak
- * model could do next was build a calendar of its own out of nothing.
- *
- * useMyBookings() is that window. It asks by uid AND by address, so a meeting
- * taken as a guest before the account existed is still theirs afterwards —
- * which is also why a page never has to ask somebody which bookings are
- * theirs.
- */
-export declare const MY_BOOKINGS_RULE = "A person's OWN meetings are read with useMyBookings() from 'your-ai-workflow-firebase-os' \u2014 { loading, bookings, error }, the same shape useBookings() gives, and it needs no arguments: it answers about whoever is signed in, and finds what they booked as a guest before they had an account as well. NEVER useBookings() on a page like this and never mem_bookings by hand \u2014 both are my team's and everybody else is refused, which shows as an error and never as an empty list. Title each one with eventName(booking) from the same package, show the times in the reader's own zone, keep a cancelled one in the list greyed out with its cancelReason rather than dropping it, and mark one that is pending:true as still waiting. They call one off with cancelBooking(id, { ids: booking.copyIds, reason, side: 'booker' }) from the same package \u2014 always with a reason \u2014 and never accept or decline anything, because the meeting is not in their diary to agree to.";
-/**
- * The hours handed over as DATA, for the page that is not a booking.
- *
- * The owner's own example: "if a user decides to create a tab where users
- * input their team's tasks — bookings are irrelevant". A schedule is the base
- * now, so a page built on one may be a rota, a shift board, a page of who is
- * in on Thursday, and the worst thing that can happen to it is the booking
- * block: a form question, a picker and a rule about lengths, for a page that
- * books nothing.
- *
- * So this is what it gets instead — one line. Where the hours come from, whose
- * they are, and the two things that go wrong without being told: hours typed
- * into the page (stale the moment somebody changes their week) and a page
- * reaching into sys_schedules itself. Everything else — which helper joins two
- * people's hours, which pieces draw a row of times — is in the app's own
- * instructions, where a list of parts cannot be mistaken for a list of things
- * to put on the page.
- */
-export declare const hoursDataLine: (picked: MemberSchedule[]) => string;
-/**
- * The hours, said to the assistant for the page they are built on — as a
- * booking when the words ask for one, and as data when they ask for anything
- * else. Either way the hours are the ENTITY the page is built on: the picker
- * reads them live off my Schedule screen, so a change to my week changes the
- * page. A booking link is a separate thing in a separate section and is never
- * mentioned here.
- *
- * A page for visitors gets the form question and the choice of look to make;
- * a page for the team gets the hook that lists the bookings. The owner's own
- * words close it either way.
- */
-export declare function bookingLines(config: any, hours: MemberSchedule[], teamPage: boolean, meetings?: MemberSchedule[]): string[];
-/**
- * What a page LINKED to a booking page is told — the other half of the
- * counter. Times are taken over there; here the team reads them.
- */
-export declare function linkedBookingLine(partnerPath: string, config: any, hours: MemberSchedule[], teamPage: boolean, meetings?: MemberSchedule[], ownWords?: string): string;