kaafil-react-uikit 0.1.0-beta.1

package/dist/manager/index.d.ts

@@ -0,0 +1,1054 @@
+export { B as BootErrorScreen, a as BootErrorScreenProps, b as BootFailureMode, O as OfflineFallbackScreen, c as OfflineFallbackScreenProps } from '../OfflineFallbackScreen-B5dfaJBN.js';
+export { L as LockedTripScreen, a as LockedTripScreenProps, N as NotFoundScreen, b as NotFoundScreenProps, S as SessionExpiredScreen, c as SessionExpiredScreenProps } from '../SessionExpiredScreen-D8GHyZc3.js';
+import { ComponentType, ReactNode } from 'react';
+import { C as ChecklistSectionRow, a as ChecklistsReady, T as TripFormRow, L as FormDefinitionDetail, M as FormResponseDetail, N as TravellerFormResponseRow, I as ItineraryDayRow, d as ItineraryItemRow, r as ItineraryReady, O as ExpenseLiveRow, s as RoomingReady, e as TripVendorRow } from '../useVendors-DXOuZWhZ.js';
+export { Q as ChecklistAvailableTemplateRow, F as FileListItem, S as FilePurpose, b as FloatLedgerMovementRow, f as FloatLedgerSummaryRow, U as ManagerFileView } from '../useVendors-DXOuZWhZ.js';
+import { K as KaafilTokenOverrides } from '../tokenStyle-CToG5oOS.js';
+import { p as CloseoutBlockerRow, d as ManagerTodayReady, q as PickupManifestResult, M as ManagerMeReady, h as SeatingReady } from '../useNotifications-D262i5BQ.js';
+export { r as CloseoutAggregate, C as ConflictRecord, c as ManagerNotification, s as PartiesTripRosterRow } from '../useNotifications-D262i5BQ.js';
+import { PickupStopDeltaRow, ManagerOwnTrip } from 'kaafil-js/client';
+export { ManagerOwnTrip, OutboxOp, PickupStopDeltaRow } from 'kaafil-js/client';
+
+interface ItemRowProps {
+    readonly item: ChecklistItemLiveRow;
+    /** Resolved via `useManagers(tripRef)`, joined on `managerId` — real name,
+     * never a raw id, never fabricated when the join can't resolve. */
+    readonly completedByName: string | undefined;
+    readonly pending: boolean;
+    readonly onToggle: () => void;
+    readonly onEdit: () => void;
+    readonly onDelete: () => void;
+}
+
+interface ProgressCardProps {
+    readonly title: string | undefined;
+    readonly subtitle: string | undefined;
+    readonly progress: {
+        readonly total: number;
+        readonly complete: number;
+    } | undefined;
+}
+
+interface SectionCardProps {
+    readonly section: ChecklistSectionRow;
+    readonly items: readonly ChecklistItemLiveRow[];
+    readonly completedByNameFor: (managerId: string) => string | undefined;
+    readonly pendingItemIds: ReadonlySet<string>;
+    readonly onToggleItem: (item: ChecklistItemLiveRow) => void;
+    readonly onEditItem: (item: ChecklistItemLiveRow) => void;
+    readonly onDeleteItem: (item: ChecklistItemLiveRow) => void;
+    readonly ItemRowComponent: ComponentType<ItemRowProps>;
+}
+
+/** One row of `useChecklists()`'s `items[]` — a live item or a tombstone,
+ * `useChecklists.ts`'s own documented split. */
+type ChecklistItemDeltaRow = ChecklistsReady['items'][number];
+/** `ChecklistItemDeltaRow`, narrowed to the live shape — a
+ * deleted-since-last-cursor row carries no `title`/`status`/etc. at all. */
+type ChecklistItemLiveRow = Exclude<ChecklistItemDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type ChecklistItemPhase = ChecklistSectionRow['phase'];
+type ChecklistItemGate = ChecklistItemLiveRow['gate'];
+interface ManagerChecklistSectionProps {
+    /** The trip this section reads `useChecklists(tripRef)` for. */
+    readonly tripRef: string;
+    /** Tier-4 named-component overrides — the three genuinely reskinnable
+     * regions. Each receives EXACTLY the same props this composite's own
+     * default renders it with. */
+    readonly components?: {
+        readonly ProgressCard?: ComponentType<ProgressCardProps>;
+        readonly SectionCard?: ComponentType<SectionCardProps>;
+        readonly ItemRow?: ComponentType<ItemRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerChecklistSection({ tripRef, components, style, }: ManagerChecklistSectionProps): ReactNode;
+
+interface BlockerRowProps {
+    readonly blocker: CloseoutBlockerRow;
+    readonly onAction?: (blocker: CloseoutBlockerRow) => void;
+}
+
+interface ManagerCloseoutSectionProps {
+    readonly tripRef: string;
+    /** Real dispatch, never a fabricated route: `ManagerTripSection` wires
+     * this to its own `actionKey → ManagerTripTabKey` map and switches its
+     * own tab state — see this composite's own header. Omit to render every
+     * blocker action button disabled/absent-of-navigation (still shows the
+     * blocker itself, just no dispatch). */
+    readonly onBlockerAction?: (blocker: CloseoutBlockerRow) => void;
+    /** `UnlockForm`'s own real contract (`04-closing-day.md`, verbatim): "this
+     * screen makes no `kaafil-js` call of its own" for unlock — `unlockCloseout`
+     * is `apiKeyAuth`-only. Submitting the reason form calls this instead, the
+     * host's own out-of-band route to ops. Omitted → a static "contact ops to
+     * reopen" message renders in place of the form. */
+    readonly onSubmitUnlockRequest?: (payload: {
+        readonly tripRef: string;
+        readonly reason: string;
+    }) => Promise<void>;
+    readonly components?: {
+        readonly BlockerRow?: ComponentType<BlockerRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerCloseoutSection({ tripRef, onBlockerAction, onSubmitUnlockRequest, components, style, }: ManagerCloseoutSectionProps): ReactNode;
+
+interface ManagerDocumentsSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerDocumentsSection({ tripRef, style, }: ManagerDocumentsSectionProps): ReactNode;
+
+interface ManagerFloatLedgerSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerFloatLedgerSection({ tripRef, style, }: ManagerFloatLedgerSectionProps): ReactNode;
+
+/** One answer this composite is about to write back — mirrors
+ * `SubmitFormResponseInput['answers'][number]` so nothing here hand-shapes
+ * the array passed to `submitResponse`. */
+interface FieldAnswer {
+    readonly fieldKey: string;
+    readonly value: unknown;
+}
+
+interface FormFillRendererProps {
+    readonly form: TripFormRow;
+    readonly definition: FormDefinitionDetail;
+    /** The subject's (self, or the on-behalf traveller's) existing response,
+     * when one is known — `undefined` starts a fresh fill. */
+    readonly existingResponse: FormResponseDetail | undefined;
+    /** `existingResponse?.status === 'SUBMITTED'`, OR the parent's own
+     * optimistic "we just submitted this" flag — kept as an explicit prop
+     * rather than derived only from `existingResponse` so a just-submitted
+     * fill locks immediately using the answers already held in THIS
+     * component's own local state, without the parent fabricating a
+     * `FormResponseDetail` it doesn't really have back from the write. */
+    readonly locked: boolean;
+    /** Set only for on-behalf capture — gates the `SELF_ONLY` sensitivity
+     * filter (05-forms.md's own privacy rule). */
+    readonly travellerRef: string | undefined;
+    readonly pending: boolean;
+    readonly hasConflict: boolean;
+    readonly onSave: (answers: readonly FieldAnswer[]) => void;
+    readonly onSubmit: (answers: readonly FieldAnswer[]) => void;
+    readonly onRefreshAfterConflict: () => void;
+    readonly onBack: () => void;
+}
+
+interface TripFormsPanelProps {
+    readonly rows: readonly FormsListRow[];
+    readonly now: string | undefined;
+    readonly travellerScoped: boolean;
+    readonly onSelectForm: (row: FormsListRow) => void;
+}
+
+/** One row of `TripFormsPanel`'s list. `response` is the SUBJECT's own
+ * response for this form when known — always `undefined` in self-fill mode
+ * (`useForms.ts` exposes no "list my own manager responses" read; this
+ * composite's own header documents the gap), populated in traveller-scoped
+ * mode (`travellerRef` set) from `travellerResponses(travellerRef)`. */
+interface FormsListRow {
+    readonly form: TripFormRow;
+    readonly response: TravellerFormResponseRow | undefined;
+}
+interface ManagerFormsSectionProps {
+    /** The trip this section reads `useForms(tripRef)` for. */
+    readonly tripRef: string;
+    /** Deep-link straight into one form's fill UI, skipping the list. */
+    readonly initialFormRef?: string;
+    /**
+     * Scopes this composite to a SINGLE traveller instead of the manager's
+     * own self-fill list — the only honest way to serve "view what a
+     * traveller submitted," using the two real reads this SDK exposes
+     * (`travellerResponses`/`getResponse`). A caller who already knows which
+     * traveller (e.g. a row-tap in `ManagerManifestSection`/
+     * `ManagerTravellerProfileSection`) mounts this composite with
+     * `travellerRef` set; the list switches to that traveller's response rows
+     * joined against `forms[]`, and an unanswered row's tap becomes on-behalf
+     * capture (`submitResponse({ travellerRef, ... })`).
+     */
+    readonly travellerRef?: string;
+    readonly onSubmitted?: (formRef: string, responseId: string) => void;
+    /** Tier-4 named-component overrides — the two genuinely reskinnable
+     * regions, matching `05-forms.md`'s own `FormFillFlow.components` slot. */
+    readonly components?: {
+        readonly TripFormsPanel?: ComponentType<TripFormsPanelProps>;
+        readonly FormFillRenderer?: ComponentType<FormFillRendererProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerFormsSection({ tripRef, initialFormRef, travellerRef, onSubmitted, components, style, }: ManagerFormsSectionProps): ReactNode;
+
+interface DayStripProps {
+    readonly days: readonly ItineraryDayRow[];
+    readonly selectedDayIndex: number;
+    readonly onSelect: (dayIndex: number) => void;
+}
+
+interface ItemCardProps {
+    readonly item: ItineraryItemRow;
+    readonly canMoveUp: boolean;
+    readonly canMoveDown: boolean;
+    readonly onMoveUp: (item: ItineraryItemRow) => void;
+    readonly onMoveDown: (item: ItineraryItemRow) => void;
+    readonly onEdit: (item: ItineraryItemRow) => void;
+}
+
+type ItineraryChangeLogRow = ItineraryReady['changeLog'][number];
+interface ManagerItinerarySectionProps {
+    /** The trip this section reads `useItinerary()`'s own reads for. */
+    readonly tripRef: string;
+    /** Overrides the "no days yet" empty state — same render-prop shape
+     * `ManagerRoomingSection.emptyView`/`ManagerVehiclesSection.emptyView`
+     * already establish. Omit for the built-in message. Days materialize
+     * lazily server-side on first read, so this should never actually fire
+     * in practice, but the composite still handles it honestly rather than
+     * crashing on an empty `days[]`. */
+    readonly emptyView?: ReactNode | (() => ReactNode);
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`'s own
+     * "the only way to replace a named component"). Each receives EXACTLY
+     * the same props this composite's own default renders it with. */
+    readonly components?: {
+        readonly DayStrip?: ComponentType<DayStripProps>;
+        readonly ItemCard?: ComponentType<ItemCardProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerItinerarySection({ tripRef, emptyView, components, style, }: ManagerItinerarySectionProps): ReactNode;
+
+interface TripBookingGroupCardProps {
+    readonly group: ManifestBookingGroup;
+    readonly onCollect: (groupId: string) => void;
+    /** Fired when a member chip is tapped — the same real destination
+     * `TripTravellerRow.onOpen` already opens, so a traveller reachable from
+     * either the group card or the all-travellers list below lands on the
+     * identical `ManagerTravellerProfileSection`. */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+}
+
+interface ManifestStats {
+    readonly confirmedCount: number;
+    readonly vegCount: number;
+    readonly totalCount: number;
+    readonly balanceDueMinor: number;
+    readonly currency: string;
+}
+
+interface TripManifestStatsProps {
+    readonly stats: ManifestStats;
+}
+
+interface TripTravellerRowProps {
+    readonly traveller: ManifestTraveller;
+    /** `fullName` is passed alongside the id — already in scope here, so a
+     * host wiring `onOpenTraveller` to a header/nav can show a real name
+     * immediately, before `ManagerTravellerProfileSection` finishes its own
+     * fetch, without a second lookup. */
+    readonly onOpen: (travellerId: string, fullName: string) => void;
+}
+
+interface ManagerManifestSectionProps {
+    /** The trip this section reads `useParties()`'s two real reads for. */
+    readonly tripRef: string;
+    /** Fired when a booking group's "Collect" CTA is tapped — nav-only
+     * (hard rule #9): no group-level collect endpoint exists (`collections`'s
+     * DTOs key strictly on `travellerId`), so the host resolves this into
+     * whatever real per-traveller flow it wants. */
+    readonly onCollectFromGroup: (groupId: string) => void;
+    /** Fired when a traveller row is tapped — the destination is
+     * `ManagerTravellerProfileSection` (a standalone composite, also
+     * exported), still fired via a callback rather than a router (hard rule
+     * #9). `fullName` is passed alongside the id so a host can show a real
+     * header title immediately, before the profile composite's own fetch
+     * resolves. */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+    /** Overrides the "no travellers match your search or filters" empty
+     * state — same render-prop shape `ManagerNowSection.idleView` already
+     * establishes for a state override. Omit for the built-in message. */
+    readonly emptyView?: ReactNode | (() => ReactNode);
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`'s own
+     * "the only way to replace a named component") — the three leaf pieces a
+     * partner CRM is most likely to reskin: its own traveller-row layout,
+     * its own booking-group card, its own stat cells. Each receives EXACTLY
+     * the same props this composite's own default renders it with; a host
+     * overriding `TravellerRow` still gets real `onOpen`/real traveller data,
+     * never a stripped-down shape. */
+    readonly components?: {
+        readonly TravellerRow?: ComponentType<TripTravellerRowProps>;
+        readonly BookingGroupCard?: ComponentType<TripBookingGroupCardProps>;
+        readonly Stats?: ComponentType<TripManifestStatsProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+type ManifestDiet = 'V' | 'NV' | 'J';
+/** `BookingStatus` (`kaafil-engine`'s real Prisma enum) — never a free
+ * string; the DTO widens it to `z.string()` on the wire, but this composite
+ * only ever recognizes these three real values. */
+type ManifestBookingStatus = 'CONFIRMED' | 'TENTATIVE' | 'CANCELLED';
+interface ManifestTraveller {
+    readonly travellerId: string;
+    readonly fullName: string;
+    readonly bookingStatus: ManifestBookingStatus;
+    readonly diet: ManifestDiet | null;
+    readonly groupId: string | null;
+    readonly dueMinor: number;
+    readonly currency: string;
+}
+interface ManifestBookingGroup {
+    readonly groupId: string;
+    /** `Party.kind` (real) — used only for the i18n fallback name when
+     * `label` is null, never rendered as its own badge (the reference
+     * screenshot shows no kind badge on the group card itself). */
+    readonly kind: 'FAMILY' | 'COUPLE' | 'FRIENDS' | 'CORPORATE' | 'OTHER';
+    readonly label: string | null;
+    readonly members: readonly {
+        readonly travellerId: string;
+        readonly fullName: string;
+    }[];
+    readonly dueMinor: number;
+    readonly currency: string;
+}
+
+declare function ManagerManifestSection({ tripRef, onCollectFromGroup, onOpenTraveller, emptyView, components, style, }: ManagerManifestSectionProps): ReactNode;
+
+interface ManagerMeSectionProps {
+    /** Fired when a recent-trip row is tapped — the host's own real
+     * navigation into `ManagerTripSection` for that trip (hard rule #9, ships
+     * no router). Omit to render rows as plain, non-interactive text. */
+    readonly onOpenTrip?: (tripRef: string) => void;
+    /** Renders a "Sign out" button only when supplied — `useSession()` itself
+     * exposes no sign-out method (credential storage is host-owned), same
+     * "prop presence gates the affordance" convention `ManagerCloseoutSection`
+     * `UnlockRequestForm` already establishes. */
+    readonly onSignOut?: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerMeSection({ onOpenTrip, onSignOut, style, }: ManagerMeSectionProps): ReactNode;
+
+interface BalanceDueDisplayRow {
+    readonly travellerId: string;
+    readonly fullName: string;
+    readonly initials: string;
+    readonly outstandingMinor: number;
+    readonly currency: string;
+}
+
+interface BalancesDueSectionProps {
+    readonly rows: readonly BalanceDueDisplayRow[];
+    readonly showingAll: boolean;
+    readonly onSelect: (row: BalanceDueDisplayRow) => void;
+    readonly onSeeAll: () => void;
+}
+
+interface MoneyStatsProps {
+    readonly float?: {
+        readonly balanceMinor: number;
+        readonly issuedMinor: number;
+        readonly currency: string;
+    };
+    readonly spend?: {
+        readonly amountMinor: number;
+        readonly currency: string;
+    };
+    readonly collect?: {
+        readonly amountMinor: number;
+        readonly travellerCount: number;
+        readonly currency: string;
+    };
+    readonly reimbursable?: {
+        readonly amountMinor: number;
+        readonly count: number;
+        readonly currency: string;
+    };
+}
+
+interface RecentExpensesSectionProps {
+    readonly expenses: readonly ExpenseLiveRow[];
+    readonly onSelect: (expense: ExpenseLiveRow) => void;
+}
+
+interface ManagerMoneySectionProps {
+    /** The trip this section reads every real hook's own data for. */
+    readonly tripRef: string;
+    /** Fired when a balances-due row's traveller name is tapped — the same
+     * real destination `ManagerManifestSection`/`ManagerRoomingSection`'s
+     * `onOpenTraveller` already open. Still fired via a callback rather than
+     * a router (hard rule #9). */
+    readonly onOpenTraveller?: (travellerId: string, fullName: string) => void;
+    /** Fired when the float balance card's "View full ledger" affordance is
+     * tapped — the host pushes `ManagerFloatLedgerSection` (a full-screen
+     * deep-dive, never a tab, matching the `openTraveller`/`openTraveller`-
+     * style push convention). Omit to hide the affordance entirely — "prop
+     * presence gates the affordance," the same convention
+     * `ManagerCloseoutSection`'s own `UnlockRequestForm` establishes. */
+    readonly onViewFloatLedger?: () => void;
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`'s own
+     * "the only way to replace a named component") — the three genuinely
+     * reskinnable regions. Each receives EXACTLY the same props this
+     * composite's own default renders it with. */
+    readonly components?: {
+        readonly Stats?: ComponentType<MoneyStatsProps>;
+        readonly RecentExpenses?: ComponentType<RecentExpensesSectionProps>;
+        readonly BalancesDue?: ComponentType<BalancesDueSectionProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerMoneySection({ tripRef, onViewFloatLedger, components, style, }: ManagerMoneySectionProps): ReactNode;
+
+interface ManagerNotificationsSectionProps {
+    /** Fired after a row marks itself read — the host decides what a non-null
+     * `tripId` means (navigate there); a `null` tripId row has nowhere to go,
+     * so a host may simply no-op. Required, matching the spec's own
+     * `NotificationsFeed` contract (never optional — a row with no navigation
+     * destination at all would be a dead tap target). */
+    readonly onSelectNotification: (notification: {
+        readonly notificationId: string;
+        readonly tripId: string | null;
+    }) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerNotificationsSection({ onSelectNotification, style, }: ManagerNotificationsSectionProps): ReactNode;
+
+type WireOnly<T> = T extends unknown ? Omit<T, 'status' | 'syncedAt'> : never;
+type ManagerTodayEngaged = Extract<WireOnly<ManagerTodayReady>, {
+    kind: 'trip';
+}>;
+type ManagerTodayIdle = Extract<WireOnly<ManagerTodayReady>, {
+    kind: 'idle';
+}>;
+interface ManagerNowSectionProps {
+    /** The trip this section reads `useManagerToday(tripRef)` for — resolved
+     * by the caller, typically off `useManagerMe()`'s own `defaultTripId`. */
+    readonly tripRef: string;
+    /** Fired when a hero quick-link chip (Manifest/Rooming/Checklist/Docs) OR
+     * the post-trip closeout card's "N item(s) still need closing" row is
+     * tapped — pure navigation, no router (hard rule #9). The host decides
+     * where each key routes to; a module whose composite doesn't exist yet
+     * (`'closing-day'` included — `ClosingDayFlow` is a later wave) still
+     * fires this callback, so the host can no-op it until it does. */
+    readonly onNavigateModule: (moduleKey: 'manifest' | 'rooming' | 'checklist' | 'docs' | 'closing-day') => void;
+    /** Fired once a Quick Actions "Log an expense" submit REALLY succeeds
+     * (the FAB opens a real `LogExpenseSheet` internally, backed by
+     * `useExpenses(tripRef).log()` — the same sheet `ManagerMoneySection`'s
+     * own "+" menu uses) — a completion hook for host-side toasts/analytics,
+     * not the trigger that opens anything. */
+    readonly onLogExpense: () => void;
+    /** Fired once a Quick Actions "Collect payment" submit REALLY succeeds
+     * (backed by `useCollections(tripRef).record()`), same shape as
+     * `onLogExpense` above. */
+    readonly onCollectPayment: () => void;
+    readonly components?: {
+        readonly ManagerNowSectionUI?: ComponentType<ManagerNowSectionUIProps>;
+    };
+    /** Overrides the default `kind: 'idle'` empty/upcoming-trip card. */
+    readonly idleView?: ReactNode | ((reading: ManagerTodayIdle) => ReactNode);
+    readonly style?: KaafilTokenOverrides;
+}
+interface ManagerNowSectionUIProps {
+    readonly data: ManagerTodayEngaged;
+    readonly syncedAt: string;
+    readonly onNavigateModule: ManagerNowSectionProps['onNavigateModule'];
+    readonly onLogExpense: () => void;
+    readonly onCollectPayment: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerNowSection(props: ManagerNowSectionProps): ReactNode;
+
+interface ManagerOverviewSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerOverviewSection({ tripRef, style }: ManagerOverviewSectionProps): ReactNode;
+
+interface CloseStopResolution {
+    readonly travellerId: string;
+    readonly status: 'BOARDED' | 'NO_SHOW';
+}
+
+interface BoardingViewProps {
+    readonly manifest: PickupManifestResult;
+    readonly activeStopId: string;
+    readonly eventType: 'TRIP' | 'TREK';
+    readonly pendingWriteIds: ReadonlySet<string>;
+    readonly closePending: boolean;
+    readonly onSelectStop: (stopId: string) => void;
+    readonly onBoard: (travellerId: string, status: 'BOARDED' | 'NO_SHOW') => void;
+    readonly onCorrect: (travellerId: string, status: 'BOARDED' | 'NO_SHOW') => void;
+    readonly onCloseStop: (input: {
+        readonly resolutions?: readonly CloseStopResolution[];
+        readonly confirm?: boolean;
+        readonly confirmedHeadCount?: number;
+    }) => void;
+    readonly onBack: () => void;
+}
+
+interface StopListProps {
+    readonly stops: readonly PickupStopLiveRow[];
+    readonly kind: PickupStopKind;
+    readonly hasDropStops: boolean;
+    readonly onKindChange: (kind: PickupStopKind) => void;
+    readonly onSelectStop: (stop: PickupStopLiveRow) => void;
+}
+
+/** `PickupStopDeltaRow`, narrowed to the live shape — a deleted-since-last-
+ * cursor row carries no `name`/`rollup`/etc at all. */
+type PickupStopLiveRow = Exclude<PickupStopDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type PickupStopKind = PickupStopLiveRow['kind'];
+interface ManagerPickupsSectionProps {
+    /** The trip this section reads `usePickups(tripRef)` for. */
+    readonly tripRef: string;
+    /** Real, resolved upstream (`useManagerMe()`'s own trip row) — the close-
+     * stop flow's two real policies (TRIP hard-resolve vs TREK short-close
+     * confirm) are selected by this, never re-derived inside this composite. */
+    readonly eventType: 'TRIP' | 'TREK';
+    /** Tier-4 named-component overrides — the two genuinely reskinnable
+     * regions. */
+    readonly components?: {
+        readonly StopList?: ComponentType<StopListProps>;
+        readonly BoardingView?: ComponentType<BoardingViewProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerPickupsSection({ tripRef, eventType, components, style, }: ManagerPickupsSectionProps): ReactNode;
+
+interface RoomCardProps {
+    readonly room: RoomingRoom;
+    readonly onSelectBed: (room: RoomingRoom, bed: RoomingBed) => void;
+    readonly onEditRoom: (room: RoomingRoom) => void;
+}
+
+interface RoomingBedStats {
+    readonly occupied: number;
+    readonly total: number;
+}
+
+interface RoomingStatsProps {
+    readonly roomCount: number;
+    readonly beds: RoomingBedStats;
+    readonly unassignedCount: number;
+}
+
+interface UnassignedPoolSectionProps$1 {
+    readonly travellers: readonly RoomingOccupantRow[];
+    readonly loaded: boolean;
+    readonly onSelectTraveller: (traveller: RoomingOccupantRow) => void;
+}
+
+type RoomingRoomDeltaRow = RoomingReady['rooms'][number];
+type RoomingRoom = Exclude<RoomingRoomDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type RoomingStayWindowDeltaRow = RoomingReady['stayWindows'][number];
+type RoomingStayWindow = Exclude<RoomingStayWindowDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type RoomingOccupantRow = RoomingReady['unassignedPool']['travellers'][number];
+type RoomingBed = RoomingRoom['beds'][number];
+type RoomingAutoAssignResult = Awaited<ReturnType<RoomingReady['autoAssign']>>;
+interface ManagerRoomingSectionProps {
+    /** The trip this section reads `useRooming()`'s own reads for. */
+    readonly tripRef: string;
+    /** Fired when an occupied bed's "View profile" row is tapped — the same
+     * real destination `ManagerManifestSection.onOpenTraveller` already opens,
+     * so a traveller reachable from the rooming board lands on the identical
+     * `ManagerTravellerProfileSection`. Still fired via a callback rather than
+     * a router (hard rule #9). */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+    /** Overrides the "no rooms in this stay window yet" empty state — same
+     * render-prop shape `ManagerManifestSection.emptyView`/
+     * `ManagerNowSection.idleView` already establish. Omit for the built-in
+     * message. */
+    readonly emptyView?: ReactNode | (() => ReactNode);
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`'s own
+     * "the only way to replace a named component") — the three leaf pieces a
+     * partner CRM is most likely to reskin. Each receives EXACTLY the same
+     * props this composite's own default renders it with. */
+    readonly components?: {
+        readonly Stats?: ComponentType<RoomingStatsProps>;
+        readonly RoomCard?: ComponentType<RoomCardProps>;
+        readonly UnassignedPool?: ComponentType<UnassignedPoolSectionProps$1>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerRoomingSection({ tripRef, onOpenTraveller, emptyView, components, style, }: ManagerRoomingSectionProps): ReactNode;
+
+interface ManagerRosterSectionProps {
+    readonly tripRef: string;
+    /** Same prop shape `ManagerManifestSection` already exposes and
+     * `ManagerTripSection` already threads through — reused verbatim, not a
+     * new contract. */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerRosterSection({ tripRef, onOpenTraveller, style, }: ManagerRosterSectionProps): ReactNode;
+
+interface ManagerSyncCenterSectionProps {
+    /** Scopes the itemized outbox view to one trip's own lane — the real
+     * `OutboxOp.tripRef` field. Per spec, `SyncCenterScreen`'s own `tripRef`
+     * is optional (aggregating across every open lane when omitted); this
+     * composite requires it because every other manager composite in this
+     * package is already single-trip-scoped (no cross-trip aggregation
+     * exists anywhere else to be consistent with). */
+    readonly tripRef: string;
+    /** The host supplies this since only it knows every module's own label
+     * conventions for a `listName` — omit to fall back to the real
+     * `entity.listName` (or the op's own `path` when no `entity` is set)
+     * verbatim, never a fabricated generic label. `entityId` is the real
+     * `OutboxEntityRef.id`, renamed at this boundary only to keep the bare
+     * word "id" out of every exported prop table (U-019/dx-17). */
+    readonly getEntityLabel?: (entity: {
+        readonly listName: string;
+        readonly entityId?: string;
+    }) => string;
+    /** Fired after a conflict resolves, for host-side telemetry only — per
+     * spec, T2. */
+    readonly onResolved?: (opId: string, choice: 'keep-queued' | 'keep-current') => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerSyncCenterSection({ tripRef, getEntityLabel, onResolved, style, }: ManagerSyncCenterSectionProps): ReactNode;
+
+type TravellerDiet = 'V' | 'NV' | 'J';
+interface DietaryRow {
+    readonly key: string;
+    readonly labelKey: string;
+    readonly value: string;
+    readonly diet: TravellerDiet | null;
+    readonly isAlert: boolean;
+}
+
+interface TravellerDietaryCardProps {
+    readonly rows: readonly DietaryRow[];
+}
+
+interface TravellerEmergencyCardProps {
+    readonly name: string;
+    readonly relation: string | null;
+    readonly phone: string | null;
+}
+
+interface TravellerNote {
+    readonly id: string;
+    readonly body: string;
+    readonly performedByKind: string | null;
+    readonly createdAt: string;
+}
+interface TravellerNotesSectionProps {
+    readonly notes: readonly TravellerNote[];
+    readonly onAddNote: (body: string) => Promise<void>;
+}
+
+interface TravellerPaymentCardProps {
+    readonly currency: string;
+    readonly totalMinor: number;
+    readonly collectedMinor: number;
+    readonly dueMinor: number;
+    readonly canLogPayment: boolean;
+    readonly onLogPayment: () => void;
+}
+
+interface ManagerTravellerProfileSectionProps {
+    /** The trip this section reads `useTravellerProfile`/`useParties`/
+     * `useCollections` for. */
+    readonly tripRef: string;
+    readonly travellerRef: string;
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`) — the
+     * leaf pieces a partner CRM is most likely to reskin. Each receives
+     * exactly the same real props this composite's own default renders it
+     * with. */
+    readonly components?: {
+        readonly DietaryCard?: ComponentType<TravellerDietaryCardProps>;
+        readonly EmergencyCard?: ComponentType<TravellerEmergencyCardProps>;
+        readonly PaymentCard?: ComponentType<TravellerPaymentCardProps>;
+        readonly NotesSection?: ComponentType<TravellerNotesSectionProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerTravellerProfileSection({ tripRef, travellerRef, components, style, }: ManagerTravellerProfileSectionProps): ReactNode;
+
+/** The one real trip-vs-trek field (`Trip.eventType`, no third value) —
+ * derived structurally off `useManagerMe()`'s own trip row so this file
+ * never imports `kaafil-js` directly. */
+type ManagerTripEventType = ManagerMeReady['trips'][number]['eventType'];
+/**
+ * Every real tab key this composite knows about — the merge this build's
+ * own plan locks in: ONE tab set computed from `eventType`, never two
+ * independent screens (the boilerplate's own posture, deliberately not
+ * followed here). `docs`/`info` are excluded entirely: no real endpoint
+ * backs either (this build's own audit), so no tab key is minted for a
+ * screen that would always render nothing.
+ */
+type ManagerTripTabKey = 'manifest' | 'rooming' | 'vehicles' | 'itinerary' | 'money' | 'vendors' | 'checklist' | 'forms' | 'pickups' | 'overview' | 'roster' | 'closing' | 'documents';
+interface ManagerTripSectionProps {
+    /** The trip this section reads `useManagerMe()`'s own trip list for,
+     * resolved by the caller — same convention `ManagerNowSection.tripRef`
+     * already establishes. */
+    readonly tripRef: string;
+    /** Uncontrolled by default (the section owns its own active-tab state,
+     * same as `ManagerShell`'s bottom bar being host-controlled while this
+     * screen's OWN chip row is nested one level below it) — pass both to
+     * control it from outside. */
+    readonly activeTabKey?: ManagerTripTabKey;
+    readonly onTabChange?: (key: ManagerTripTabKey) => void;
+    /** Fired when a booking group's "Collect" CTA is tapped — nav-only
+     * (hard rule #9): no group-level collect endpoint exists (`collections`'s
+     * DTOs key strictly on `travellerId`), so the host resolves this into
+     * whatever real per-traveller flow it wants. Required once the manifest
+     * panel is live; a caller with no groups yet may still pass a no-op. */
+    readonly onCollectFromGroup: (groupId: string) => void;
+    /** Fired when a traveller row is tapped — see
+     * `ManagerManifestSectionProps.onOpenTraveller`'s own doc comment (this
+     * composite just forwards it to its built-in manifest panel). */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+    /** Fired when a vendor row is tapped in the built-in vendors panel — see
+     * `ManagerVendorsSectionProps.onVendorSelect`'s own doc comment (this
+     * composite just forwards it). */
+    readonly onVendorSelect: (tripVendorId: string) => void;
+    /** Forwarded straight through to the built-in `'money'` panel's own
+     * `onViewFloatLedger` — see `ManagerMoneySectionProps`'s own doc comment.
+     * Omit to hide the "View full ledger" affordance entirely. */
+    readonly onViewFloatLedger?: () => void;
+    /** Forwarded straight through to the built-in `'closing'` panel's own
+     * `onSubmitUnlockRequest` — see `ManagerCloseoutSectionProps`'s own doc
+     * comment for why this composite never calls `closeout.unlock()` itself
+     * (`apiKeyAuth`-only). Omit to render the built-in closing panel's static
+     * "contact ops to reopen" message once locked. */
+    readonly onSubmitUnlockRequest?: (payload: {
+        readonly tripRef: string;
+        readonly reason: string;
+    }) => Promise<void>;
+    /** Registry of real panel content, keyed by tab (hard rule #8 — never a
+     * switch/if-else here). Overrides this composite's OWN built-in panel for
+     * a key (`'manifest'`, this wave) when supplied; every other key still
+     * renders the built-in "not built yet" placeholder until a later wave
+     * fills it — no restructuring required when that happens. */
+    readonly panels?: Partial<Record<ManagerTripTabKey, ReactNode>>;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerTripSection(props: ManagerTripSectionProps): ReactNode;
+
+interface UnassignedPoolSectionProps {
+    readonly travellers: readonly SeatingOccupantRow[];
+    readonly loaded: boolean;
+    readonly onSelectTraveller: (traveller: SeatingOccupantRow) => void;
+}
+
+interface VehicleCardProps {
+    readonly vehicle: SeatingVehicle;
+    readonly ownerName: string | undefined;
+    readonly onSelectSeat: (vehicle: SeatingVehicle, seat: SeatingSeatSlot) => void;
+    readonly onSelectOccupant: (vehicle: SeatingVehicle, travellerId: string) => void;
+    readonly onAddOccupant: (vehicle: SeatingVehicle) => void;
+    /** Opens the sheet's `customSeat` flow — a manager types the traveller's
+     * REAL boarding-pass/ticket seat number (business rows, exit rows, gaps
+     * this vehicle's synthesised grid doesn't model), rather than being
+     * limited to the grid's own auto-generated labels. Only offered on a
+     * seat-mapped vehicle. */
+    readonly onEnterCustomSeat: (vehicle: SeatingVehicle) => void;
+    readonly onEditVehicle: (vehicle: SeatingVehicle) => void;
+    readonly onEditOwner: (vehicle: SeatingVehicle) => void;
+    /** Opens `VehicleRosterSheet` — a full scrollable list of every real
+     * occupant on this vehicle, for a capacity too large to scan comfortably
+     * as wrapped chips (e.g. a 12-seat tempo traveller). */
+    readonly onViewRoster: (vehicle: SeatingVehicle) => void;
+}
+
+interface VehicleStatsProps {
+    readonly vehicleCount: number;
+    readonly seated: number;
+    readonly capacity: number;
+    readonly unassignedCount: number;
+}
+
+type SeatingVehicleRowRaw = SeatingReady['vehicles'][number];
+type SeatingVehicle = Exclude<SeatingVehicleRowRaw, {
+    readonly _tombstone: true;
+}>;
+type SeatingOccupantRow = SeatingReady['unassignedPool']['travellers'][number];
+type SeatingSeatSlot = SeatingVehicle['seats'][number];
+interface ManagerVehiclesSectionProps {
+    /** The trip this section reads `useSeating()`'s own reads for. */
+    readonly tripRef: string;
+    /** Fired when an occupied seat/occupant slot's "View profile" row is
+     * tapped — the same real destination `ManagerManifestSection`/
+     * `ManagerRoomingSection.onOpenTraveller` already open, so a traveller
+     * reachable from the vehicles board lands on the identical
+     * `ManagerTravellerProfileSection`. Still fired via a callback rather
+     * than a router (hard rule #9). */
+    readonly onOpenTraveller: (travellerId: string, fullName: string) => void;
+    /** Overrides the "no vehicles yet" empty state — same render-prop shape
+     * `ManagerRoomingSection.emptyView`/`ManagerManifestSection.emptyView`
+     * already establish. Omit for the built-in message. */
+    readonly emptyView?: ReactNode | (() => ReactNode);
+    /** Tier-4 named-component overrides (`04-customization-ladder.md`'s own
+     * "the only way to replace a named component") — the three leaf pieces a
+     * partner CRM is most likely to reskin. Each receives EXACTLY the same
+     * props this composite's own default renders it with. */
+    readonly components?: {
+        readonly Stats?: ComponentType<VehicleStatsProps>;
+        readonly VehicleCard?: ComponentType<VehicleCardProps>;
+        readonly UnassignedPool?: ComponentType<UnassignedPoolSectionProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerVehiclesSection({ tripRef, onOpenTraveller, emptyView, components, style, }: ManagerVehiclesSectionProps): ReactNode;
+
+interface VendorListSectionProps {
+    readonly vendors: readonly TripVendorRow[];
+    readonly onVendorSelect: (tripVendorId: string) => void;
+    readonly emptyView?: ReactNode | (() => ReactNode);
+}
+
+type VendorCategory = TripVendorRow['category'];
+interface ManagerVendorsSectionProps {
+    /** The trip this section reads `useVendors(tripRef, '')` for. */
+    readonly tripRef: string;
+    /** Narrows the already-fetched list to one category, client-side — the
+     * spec's own claim that this is "the SDK's own `?category=` filter,
+     * passed straight through" does not match the real
+     * `client.vendors.list()` signature (verified: no such query param
+     * exists), so this never round-trips to the server. */
+    readonly category?: VendorCategory;
+    /** Fired when a vendor row is tapped — a pure passthrough (`10-vendors.md`
+     * §VendorList's own "Does NOT": "`onVendorSelect` only reports which row
+     * was activated"). No detail sheet exists in this build; the host decides
+     * what happens next, the same convention `onOpenTraveller` already
+     * establishes elsewhere in this UIKit. */
+    readonly onVendorSelect: (tripVendorId: string) => void;
+    /** Overrides the default empty state shown when the real list is
+     * genuinely empty (zero vendors is a legitimate state, never confused
+     * with a dark capability) — same `ReactNode | (() => ReactNode)` shape
+     * `ManagerVehiclesSection.emptyView`/`ManagerManifestSection.emptyView`
+     * already use. */
+    readonly emptyView?: ReactNode | (() => ReactNode);
+    /** Tier-4 named-component override — the one genuinely reskinnable
+     * region, named after the spec's own `VendorList` component. */
+    readonly components?: {
+        readonly VendorListUI?: ComponentType<VendorListSectionProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerVendorsSection({ tripRef, category, onVendorSelect, emptyView, components, style, }: ManagerVendorsSectionProps): ReactNode;
+
+/** The 3 bottom-nav destinations this Surface owns — Trip/Trek merge into
+ * one tab (icon/label switch off the selected trip's real `eventType`),
+ * matching `apps/sample-manager/src/App.tsx`'s own real `BottomTabKey`. */
+type KaafilManagerAppTabKey = 'now' | 'trip' | 'me';
+interface TripListRowProps {
+    readonly trip: ManagerOwnTrip;
+    readonly onSelect: (tripRef: string) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface KaafilManagerAppProps {
+    /** Seeds which trip is selected on first mount — skips the trip-list
+     * picker even with 2+ live trips (the deep-link case). Ignored once
+     * `selectedTripRef` (below) is supplied, since that makes selection fully
+     * host-controlled. */
+    readonly initialTripRef?: string;
+    /** Fully controls which trip is selected — omit to let this component own
+     * its own selection state (seeded by `initialTripRef`, then updated by the
+     * trip-list picker / "Me" tab's own trip list / a trip-linked
+     * notification, exactly as `apps/sample-manager/src/App.tsx` already
+     * does). Supplying this makes the Surface a controlled component for trip
+     * selection — `onSelectTrip` still fires so the host can react. */
+    readonly selectedTripRef?: string;
+    /** Fully controls the bottom-tab selection — omit to let this component
+     * own it (defaulting to `'now'`). */
+    readonly activeTab?: KaafilManagerAppTabKey;
+    /** Seeds `ManagerTripSection`'s own internal chip-tab (Manifest/Rooming/
+     * Money/etc.) on first entry into the Trip tab — a second, real
+     * deep-linking level below `initialTripRef`/`activeTab` (e.g. landing
+     * directly on the Money tab from a push notification). */
+    readonly initialTripTabKey?: ManagerTripTabKey;
+    /** → `ManagerNowSection.onNavigateModule` (required there). */
+    readonly onNavigateModule: (moduleKey: 'manifest' | 'rooming' | 'checklist' | 'docs' | 'closing-day') => void;
+    /** → `ManagerNowSection.onLogExpense` (required there). */
+    readonly onLogExpense: () => void;
+    /** → `ManagerNowSection.onCollectPayment` (required there). */
+    readonly onCollectPayment: () => void;
+    /** → `ManagerTripSection.onCollectFromGroup` (required there). */
+    readonly onCollectFromGroup: (groupId: string) => void;
+    /** → `ManagerTripSection.onVendorSelect` (required there). */
+    readonly onVendorSelect: (tripVendorId: string) => void;
+    /** → `ManagerTripSection.onSubmitUnlockRequest` (optional there — omit to
+     * render its own static "contact ops to reopen" message once locked). */
+    readonly onSubmitUnlockRequest?: (payload: {
+        readonly tripRef: string;
+        readonly reason: string;
+    }) => Promise<void>;
+    /** Renders "Sign out" on the Me tab only when supplied (prop-presence
+     * gates the affordance, same convention `ManagerMeSection` itself already
+     * establishes) — this Surface has no credential/session-teardown method
+     * of its own to call first. */
+    readonly onSignOut?: () => void;
+    /** Fires whenever the selected trip changes (picker row tap, the Me tab's
+     * own trip list, or a trip-linked notification) — per spec, T2. */
+    readonly onSelectTrip?: (tripRef: string) => void;
+    /** Fires whenever the bottom tab changes — per spec, T2. */
+    readonly onTabChange?: (tabKey: KaafilManagerAppTabKey) => void;
+    /** Fires whenever `ManagerTripSection`'s own internal chip-tab changes —
+     * the second deep-linking level `initialTripTabKey` seeds. */
+    readonly onTripTabChange?: (tabKey: ManagerTripTabKey) => void;
+    /** Fired alongside the internal traveller-profile push opening/closing —
+     * an analytics/URL-sync hook, never the only way this navigation happens
+     * (the real trigger is always a row tap inside a mounted composite). */
+    readonly onOpenTraveller?: (travellerId: string, fullName: string) => void;
+    readonly onCloseTraveller?: () => void;
+    /** Fired alongside the internal notifications push opening/closing. */
+    readonly onOpenNotifications?: () => void;
+    readonly onCloseNotifications?: () => void;
+    /** Fired alongside the internal float-ledger push opening/closing. */
+    readonly onOpenFloatLedger?: () => void;
+    readonly onCloseFloatLedger?: () => void;
+    /** Fired alongside the internal sync-center push opening/closing — the
+     * real destination the connectivity badge's own "N need attention" text
+     * opens (`ManagerSyncCenterSection`); a caught bug this wave: that text
+     * rendered with nowhere to go before this push existed. */
+    readonly onOpenSyncCenter?: () => void;
+    readonly onCloseSyncCenter?: () => void;
+    /** → `ManagerSyncCenterSection.getEntityLabel` (optional there; `entityId`
+     * is that composite's own renamed `OutboxEntityRef.id`, kept consistent
+     * at this boundary too so this prop table stays free of the bare word
+     * "id", U-019/dx-17). */
+    readonly getSyncEntityLabel?: (entity: {
+        readonly listName: string;
+        readonly entityId?: string;
+    }) => string;
+    /** → `ManagerSyncCenterSection.onResolved` (optional there). */
+    readonly onConflictResolved?: (opId: string, choice: 'keep-queued' | 'keep-current') => void;
+    readonly components?: {
+        /** The trip-list picker's own row renderer (spec-named). */
+        readonly TripListItem?: ComponentType<TripListRowProps>;
+        /** Maps onto `ManagerShell`'s own existing `components.TabIcon` slot —
+         * the only real tab-bar customization point that exists today.
+         * Deliberately narrower than the spec's "TabBar" name implies:
+         * `ManagerShell` has no slot to replace the whole tab-bar chrome with,
+         * so this Surface does not invent a second, parallel tab-bar renderer
+         * just to satisfy the literal name (one mechanism per slot, U-004). */
+        readonly TabBar?: ComponentType<{
+            readonly icon: string;
+        }>;
+        /** Overrides the honest "no active trip assignment" empty state — real
+         * integrators reskin/rebrand this message, they don't fabricate a fake
+         * trip to avoid it. */
+        readonly EmptyState?: ComponentType<Record<string, never>>;
+        /** Overrides the initial loading skeleton. */
+        readonly LoadingView?: ComponentType<Record<string, never>>;
+        /** Overrides the unconditional connectivity indicator (spec: "not a
+         * prop an integrator can turn off" — replacing its PRESENTATION is
+         * still allowed; only removing it entirely is not, so this slot has no
+         * `false`/hide variant). */
+        readonly SyncStatusBadge?: ComponentType<{
+            readonly isOnline: boolean;
+            readonly pending: number;
+            readonly parked: number;
+            readonly onOpenSyncCenter?: () => void;
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function KaafilManagerApp(props: KaafilManagerAppProps): ReactNode;
+
+interface ManagerFabProps {
+    readonly onClick: () => void;
+    /** Accessible name — there is no visible label on the button itself
+     * (boilerplate's own `MFab`: an icon-only circle), so this is required,
+     * never optional. */
+    readonly label: string;
+    /** Defaults to a plus glyph — the one icon every family composite that
+     * has reached for a FAB so far has needed (`ManagerNowSection`'s own
+     * quick-actions trigger); pass a different icon for a family composite
+     * that needs a different primary action. */
+    readonly icon?: ReactNode;
+    readonly tone?: 'accent' | 'ink';
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerFab({ onClick, label, icon, tone, style, }: ManagerFabProps): ReactNode;
+
+interface ManagerShellTab {
+    readonly key: string;
+    readonly label: string;
+    /** One glyph, `icon="clock"` etc. — a registry key (hard rule #8), never
+     * an inline SVG passed per-tab (`ManagerShell` owns its own icon set,
+     * matching the boilerplate's own fixed 4-icon tab bar; a host wanting a
+     * fifth tab's own glyph uses `components.TabIcon`). */
+    readonly icon: 'now' | 'trek' | 'trip' | 'me';
+}
+interface ManagerShellHeaderPage {
+    readonly variant?: 'page';
+    readonly eyebrow?: string;
+    readonly title: string;
+    /** Real unread count (`useNotifications()`'s own `unreadCount`) — never a
+     * boolean or a guessed number; omit entirely to hide the bell. */
+    readonly unread?: number;
+    readonly onBellPress?: () => void;
+    /** 2-letter avatar initials — omit renders a person glyph, never a "?"
+     * (boilerplate's own `m-header.tsx` documents exactly this reasoning:
+     * a question mark on your own avatar reads as "we don't know who you
+     * are," which is never true once a session is open). */
+    readonly avatarInitials?: string;
+    readonly onAvatarPress?: () => void;
+    /** Replaces the whole right-hand slot (bell + avatar) at once. */
+    readonly right?: ReactNode;
+    readonly style?: KaafilTokenOverrides;
+}
+interface ManagerShellHeaderBack {
+    readonly variant: 'back';
+    readonly eyebrow?: string;
+    readonly title: string;
+    readonly onBack: () => void;
+    readonly right?: ReactNode;
+    readonly style?: KaafilTokenOverrides;
+}
+type ManagerShellHeaderConfig = ManagerShellHeaderPage | ManagerShellHeaderBack;
+interface ManagerShellProps {
+    readonly children?: ReactNode;
+    /** Omit to render no header at all — a screen that wants a "back" header
+     * passes `{ variant: 'back', ... }` here instead of mounting its own. */
+    readonly header?: ManagerShellHeaderConfig;
+    /** Omit to render no tab bar (e.g. a screen pushed on top of the tab
+     * stack) — the tab bar is never assumed present. */
+    readonly tabs?: readonly ManagerShellTab[];
+    readonly activeTabKey?: string;
+    readonly onTabChange?: (key: string) => void;
+    /** The floating action button slot — a fully caller-owned node (usually
+     * an `MFab`-equivalent button this family will ship once the FAB pattern
+     * is needed by more than one composite); `ManagerShell` only positions
+     * it, never renders a default. */
+    readonly fab?: ReactNode;
+    readonly components?: {
+        readonly TabIcon?: ComponentType<{
+            readonly icon: string;
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerShell({ children, header, tabs, activeTabKey, onTabChange, fab, style, }: ManagerShellProps): ReactNode;
+
+export { type ChecklistItemDeltaRow, type ChecklistItemGate, type ChecklistItemLiveRow, type ChecklistItemPhase, ChecklistSectionRow, CloseoutBlockerRow, FormDefinitionDetail, FormResponseDetail, type ItineraryChangeLogRow, ItineraryDayRow, ItineraryItemRow, KaafilManagerApp, type KaafilManagerAppProps, type KaafilManagerAppTabKey, ManagerChecklistSection, type ManagerChecklistSectionProps, ManagerCloseoutSection, type ManagerCloseoutSectionProps, ManagerDocumentsSection, type ManagerDocumentsSectionProps, ManagerFab, type ManagerFabProps, ManagerFloatLedgerSection, type ManagerFloatLedgerSectionProps, ManagerFormsSection, type ManagerFormsSectionProps, ManagerItinerarySection, type ManagerItinerarySectionProps, ManagerManifestSection, type ManagerManifestSectionProps, ManagerMeSection, type ManagerMeSectionProps, ManagerMoneySection, type ManagerMoneySectionProps, ManagerNotificationsSection, type ManagerNotificationsSectionProps, ManagerNowSection, type ManagerNowSectionProps, type ManagerNowSectionUIProps, ManagerOverviewSection, type ManagerOverviewSectionProps, ManagerPickupsSection, type ManagerPickupsSectionProps, ManagerRoomingSection, type ManagerRoomingSectionProps, ManagerRosterSection, type ManagerRosterSectionProps, ManagerShell, type ManagerShellHeaderBack, type ManagerShellHeaderConfig, type ManagerShellHeaderPage, type ManagerShellProps, type ManagerShellTab, ManagerSyncCenterSection, type ManagerSyncCenterSectionProps, type ManagerTodayEngaged, type ManagerTodayIdle, ManagerTravellerProfileSection, type ManagerTravellerProfileSectionProps, type ManagerTripEventType, ManagerTripSection, type ManagerTripSectionProps, type ManagerTripTabKey, ManagerVehiclesSection, type ManagerVehiclesSectionProps, ManagerVendorsSection, type ManagerVendorsSectionProps, type ManifestBookingGroup, type ManifestBookingStatus, type ManifestDiet, type ManifestTraveller, PickupManifestResult, type RoomingAutoAssignResult, type RoomingBed, type RoomingOccupantRow, type RoomingRoom, type RoomingStayWindow, type SeatingOccupantRow, type SeatingSeatSlot, type SeatingVehicle, TravellerFormResponseRow, TripFormRow, type TripListRowProps, TripVendorRow, type VendorCategory };