kaafil-react-uikit 0.1.0-beta.1

package/dist/admin/index.d.cts

@@ -0,0 +1,1157 @@
+export { B as BootErrorScreen, a as BootErrorScreenProps, b as BootFailureMode, O as OfflineFallbackScreen, c as OfflineFallbackScreenProps } from '../OfflineFallbackScreen-Ctm7nBa-.cjs';
+export { L as LockedTripScreen, a as LockedTripScreenProps, N as NotFoundScreen, b as NotFoundScreenProps, S as SessionExpiredScreen, c as SessionExpiredScreenProps } from '../SessionExpiredScreen-CytQNuak.cjs';
+import { ReactNode, ComponentType } from 'react';
+import { K as KaafilTokenOverrides } from '../tokenStyle-CToG5oOS.cjs';
+import { C as ChecklistTemplateRow, a as ChecklistTemplateItemRow, F as FormDetailRow, b as FormFieldRow, c as FormRow, M as ManagerListRowResponse, T as TravellerDirectoryItemResponse, J as JourneyTriggerRow, A as AgencyTripRow, d as TripManifestRow, e as CollectionDeltaRow, f as AgencyTripRead } from '../useAgencyTrip-BUYSIaC2.cjs';
+export { g as AgencySettingsDocument, B as FormBuilderBindingRow, h as FormSectionRow } from '../useAgencyTrip-BUYSIaC2.cjs';
+import { ManagerAgencyProfileResponse, TravellerAgencyProfileResponse, BookingListRow, PickupStopDeltaRow, RoomingRoomDeltaRow, SeatingVehicleDeltaRow } from 'kaafil-js/client';
+export { BookingListRow, ManagerAgencyProfileResponse, SeatingOccupant, TravellerAgencyProfileResponse, AgencyTripSegmentCounts as TripDirectorySegmentCounts, TripManifestFacets } from 'kaafil-js/client';
+import { C as ChecklistSectionRow, a as ChecklistsReady, F as FileListItem, E as ExpenseDeltaRow, b as FloatMovementRow, T as TripFormRow, c as TripFormResponseRow, I as ItineraryDayRow, d as ItineraryItemRow, R as RoomingStayWindowRow, e as TripVendorRow } from '../useVendors-DXOuZWhZ.cjs';
+export { f as FloatSummaryRow } from '../useVendors-DXOuZWhZ.cjs';
+
+type PlanLockedReason = 'agency' | 'partner-ceiling';
+interface PlanLockedScreenProps {
+    /** The capability this route was headed for. Read for its own triple
+     * only — never exhaustively switched on (`§6` point 5's open-set rule). */
+    readonly capabilityKey: string;
+    /** The host's own upsell/support flow — Kaafil has no in-product upgrade
+     * path to hand off to. `undefined` means the wire did not say which
+     * queue this belongs in; see this file's header. */
+    readonly onUpgradeRequest: (reason: PlanLockedReason | undefined) => void;
+    /** Supplied by the caller when it saw a refusal that named one. */
+    readonly reason?: PlanLockedReason;
+    readonly components?: {
+        readonly PlanLockedScreenUI?: () => ReactNode;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+declare function PlanLockedScreen({ capabilityKey, onUpgradeRequest, reason, components, style, }: PlanLockedScreenProps): ReactNode;
+
+/** One field's current draft state. `set: false` means this field is
+ * omitted from the outgoing PATCH entirely (inherits the Kaafil default) —
+ * `value` is meaningless in that case, kept only so re-enabling the field
+ * restores the last value the admin had entered rather than resetting to
+ * blank. `value: null` is itself a real, explicit state (`set: true`) for
+ * the one field where the wire distinguishes "no default" from "explicitly
+ * unlimited" (`files.ttlDays`). */
+interface FieldEntry {
+    readonly set: boolean;
+    readonly value: boolean | number | string | readonly string[] | null;
+}
+type SectionDraft = Record<string, FieldEntry>;
+interface FieldOption {
+    readonly value: string;
+    readonly labelKey: string;
+}
+interface ToggleFieldDef {
+    readonly kind: 'toggle';
+    readonly key: string;
+    readonly labelKey: string;
+    readonly hintKey?: string;
+}
+interface NumberFieldDef {
+    readonly kind: 'number';
+    readonly key: string;
+    readonly labelKey: string;
+    readonly hintKey?: string;
+    readonly min?: number;
+    /** When true, this field's wire type is `number | null` and the UI offers
+     * a distinct explicit-null state (a checkbox), not just blank-vs-number. */
+    readonly nullable?: boolean;
+    readonly nullLabelKey?: string;
+    readonly visibleWhen?: (draft: SectionDraft) => boolean;
+}
+interface SelectFieldDef {
+    readonly kind: 'select';
+    readonly key: string;
+    readonly labelKey: string;
+    readonly options: readonly FieldOption[];
+    readonly visibleWhen?: (draft: SectionDraft) => boolean;
+}
+interface ArrayFieldDef {
+    readonly kind: 'array';
+    readonly key: string;
+    readonly labelKey: string;
+    readonly options: readonly FieldOption[];
+    /** Order carries real meaning on the wire (e.g. `rooming.strategyOrder` —
+     * the solver applies strategies in this order) — show move-up/move-down
+     * controls only when true. */
+    readonly reorderable?: boolean;
+}
+type FieldDef = ToggleFieldDef | NumberFieldDef | SelectFieldDef | ArrayFieldDef;
+interface SectionDef {
+    readonly id: string;
+    /** A presentation-only grouping label (`settings-shell.tsx`'s own
+     * "Workspace" / "Your account" / "Advanced" grouping is the identical
+     * device) — purely a nav-rail organizing aid, never a real category on
+     * the wire; `Agency.settings` itself has no concept of a section group. */
+    readonly groupTitleKey: string;
+    readonly titleKey: string;
+    readonly descriptionKey: string;
+    readonly fields: readonly FieldDef[];
+}
+/** `'conflict'` — another write landed first (`CONFLICT_VERSION`); the only
+ * safe recovery is discarding this card's local draft and re-reading the
+ * server's value, never silently overwriting it. `'failed'` — any other
+ * save failure (network, validation); the local draft is still valid, so
+ * the recovery is just "try again", no reseed. */
+type SectionSaveErrorKind = 'conflict' | 'failed';
+interface SectionCardProps {
+    readonly section: SectionDef;
+    /** The stored section object (`document.settings[section.id]`), or
+     * `undefined` if this agency has never set anything in this section. */
+    readonly stored: Record<string, unknown> | undefined;
+    readonly saving: boolean;
+    readonly errorKind: SectionSaveErrorKind | undefined;
+    readonly onSave: (sectionId: string, patch: Record<string, unknown>) => void;
+    /** Fired when the admin dismisses the error banner — for `'conflict'` the
+     * parent refreshes and this card reseeds its draft from the fresh value;
+     * for `'failed'` the parent just clears the error and the draft is left
+     * untouched so the admin can retry the same edit. */
+    readonly onDismissError: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface AgencySettingsScreenProps {
+    readonly title?: string;
+    readonly subtitle?: string;
+    readonly components?: {
+        readonly SectionCard?: ComponentType<SectionCardProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function AgencySettingsScreen({ title, subtitle, components, style, }: AgencySettingsScreenProps): ReactNode;
+
+/** A locally-edited draft of one item — the same shape `items[]` needs to
+ * become on save (`PatchChecklistTemplateRequest`'s item shape: `key`,
+ * `title`, `subLine`, `isMandatory`, `gate`, `dayOffset` — no `id`/
+ * `sortOrder`, array order IS sort order), plus a local-only `draftId` so
+ * React can key a not-yet-saved row before the server assigns a real `id`. */
+interface ChecklistTemplateItemDraft {
+    readonly draftId: string;
+    readonly key: string;
+    readonly title: string;
+    readonly subLine: string;
+    readonly isMandatory: boolean;
+    readonly gate: ChecklistTemplateItemRow['gate'];
+    readonly dayOffset: string;
+}
+interface TemplateEditorHeaderProps {
+    readonly template: ChecklistTemplateRow;
+    readonly title: string;
+    readonly onTitleChange: (title: string) => void;
+    readonly hasChanges: boolean;
+    readonly saving: boolean;
+    readonly onSave: () => void;
+    readonly canPublish: boolean;
+    readonly publishing: boolean;
+    readonly onPublish: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface TemplateItemRowProps {
+    readonly item: ChecklistTemplateItemDraft;
+    readonly index: number;
+    readonly total: number;
+    readonly onEdit: (draftId: string) => void;
+    readonly onRemove: (draftId: string) => void;
+    readonly onReorder: (draggedDraftId: string, targetDraftId: string) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface ChecklistTemplateEditorProps {
+    readonly templateId: string;
+    readonly onSaved?: (template: ChecklistTemplateRow) => void;
+    readonly onPublished?: (template: ChecklistTemplateRow) => void;
+    readonly components?: {
+        readonly TemplateEditorHeader?: ComponentType<TemplateEditorHeaderProps>;
+        readonly TemplateItemRow?: ComponentType<TemplateItemRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ChecklistTemplateEditor({ templateId, onSaved, onPublished, components, style, }: ChecklistTemplateEditorProps): ReactNode;
+
+interface TemplateRowProps {
+    readonly template: ChecklistTemplateRow;
+    readonly selected?: boolean;
+    readonly onSelect?: (template: ChecklistTemplateRow) => void;
+    readonly onDelete?: (template: ChecklistTemplateRow) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface ChecklistTemplateLibraryProps {
+    /** Optional page-head title — rendered above the toolbar. Omit when this
+     * composite is mounted under a shell that already renders its own page
+     * title (e.g. `TemplateAuthoringFlow`'s own master column), same
+     * convention `ManagerDirectoryFlow` establishes. */
+    readonly title?: string;
+    /** Optional supporting copy under `title` — omitted whenever `title` is. */
+    readonly subtitle?: string;
+    /** The currently-selected template, if any — highlights that row. Purely
+     * presentational; this composite never owns selection state itself. */
+    readonly selectedTemplateId?: string;
+    readonly onSelectTemplate?: (template: ChecklistTemplateRow) => void;
+    /** Fires after a successful delete — `templateId` of the removed row. */
+    readonly onDeleted?: (templateId: string) => void;
+    /** Controlled create-dialog visibility — set when a host shell (e.g.
+     * `KaafilAgencyWorkspace`) renders the "New template" action as its own
+     * page-level primary CTA rather than duplicating a create button inside
+     * this composite's own card header (the mockup's own generic page-header
+     * pattern: every pane's `cta` sits beside its `<h1>`, never inside the
+     * card below it). Omit both to fall back to this composite's own
+     * internal button + state, for standalone/story usage. */
+    readonly creating?: boolean;
+    readonly onCreatingChange?: (next: boolean) => void;
+    readonly components?: {
+        readonly TemplateRow?: ComponentType<TemplateRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ChecklistTemplateLibrary({ title, subtitle, selectedTemplateId, onSelectTemplate, onDeleted, creating: controlledCreating, onCreatingChange, components, style, }: ChecklistTemplateLibraryProps): ReactNode;
+
+type FormFieldKind = 'HEADING' | 'INFO_BLOCK' | 'SHORT_TEXT' | 'LONG_TEXT' | 'EMAIL' | 'PHONE' | 'URL' | 'NUMBER' | 'CURRENCY' | 'RATING' | 'NPS' | 'DATE' | 'DATETIME' | 'TIME' | 'SELECT' | 'MULTISELECT' | 'CHECKBOX' | 'CONSENT' | 'SIGNATURE' | 'FILE_UPLOAD' | 'ADDRESS';
+
+interface BuilderHeaderProps {
+    readonly form: FormDetailRow;
+    readonly title: string;
+    readonly onTitleChange: (title: string) => void;
+    readonly onTitleCommit: () => void;
+    readonly onDelete?: () => void;
+    readonly onArchive: () => void;
+    readonly onUnarchive: () => void;
+    readonly onPublish: () => void;
+    readonly onClose: () => void;
+    readonly onReopen: () => void;
+    readonly pending: boolean;
+    readonly style?: KaafilTokenOverrides;
+}
+interface FieldRowProps {
+    readonly field: FormFieldRow;
+    readonly kind: FormFieldKind;
+    /** `true` while THIS row is the one being dragged — dims it in place. */
+    readonly dragging: boolean;
+    /** `true` while a drag is hovering over this row — shows the drop-target
+     * indicator. */
+    readonly dragOver: boolean;
+    /** Opens `FieldEditDialog` for this field — a read-only summary row,
+     * mockup's own `f.edit` anatomy (`TemplateItemRow.tsx`'s established
+     * split: rows summarize, a dialog edits). */
+    readonly onOpenSettings: () => void;
+    readonly onDragStart: () => void;
+    readonly onDragOverRow: () => void;
+    readonly onDrop: () => void;
+    readonly onDragEnd: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface FormBuilderProps {
+    readonly formId: string;
+    readonly onBack?: () => void;
+    readonly components?: {
+        readonly BuilderHeader?: ComponentType<BuilderHeaderProps>;
+        readonly FieldRow?: ComponentType<FieldRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function FormBuilder({ formId, onBack, components, style }: FormBuilderProps): ReactNode;
+
+interface FormsAuthoringFlowProps {
+    /** Deep-link: skip the library and open this form's builder directly on
+     * mount. Omit to start on the library. */
+    readonly initialFormId?: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function FormsAuthoringFlow({ initialFormId, style }: FormsAuthoringFlowProps): ReactNode;
+
+interface FormRowProps$1 {
+    readonly form: FormRow;
+    readonly selected?: boolean;
+    readonly onSelect?: (form: FormRow) => void;
+    readonly onArchive?: (form: FormRow) => void;
+    readonly onUnarchive?: (form: FormRow) => void;
+    readonly onPublish?: (form: FormRow) => void;
+    readonly onClose?: (form: FormRow) => void;
+    readonly onReopen?: (form: FormRow) => void;
+    readonly onDelete?: (form: FormRow) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface FormsLibraryProps {
+    /** Optional page-head title — rendered above the toolbar. Omit when this
+     * composite is mounted under a shell that already renders its own page
+     * title, same convention `ChecklistTemplateLibrary` establishes. */
+    readonly title?: string;
+    /** Optional supporting copy under `title` — omitted whenever `title` is. */
+    readonly subtitle?: string;
+    /** The currently-selected form, if any — highlights that row. Purely
+     * presentational; this composite never owns selection state itself. */
+    readonly selectedFormId?: string;
+    readonly onSelectForm?: (form: FormRow) => void;
+    /** Controlled create-dialog visibility — set when a host shell (e.g.
+     * `KaafilAgencyWorkspace`) renders the "New form" action as its own
+     * page-level primary CTA rather than duplicating a create button inside
+     * this composite's own card header (the mockup's own generic page-header
+     * pattern: every pane's `cta` sits beside its `<h1>`, never inside the
+     * card below it). Omit both to fall back to this composite's own
+     * internal button + state, for standalone/story usage. */
+    readonly creating?: boolean;
+    readonly onCreatingChange?: (next: boolean) => void;
+    readonly components?: {
+        readonly FormRow?: ComponentType<FormRowProps$1>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function FormsLibrary({ title, subtitle, selectedFormId, onSelectForm, creating: controlledCreating, onCreatingChange, components, style, }: FormsLibraryProps): ReactNode;
+
+interface ManagerResultRowProps {
+    readonly manager: ManagerListRowResponse;
+    /** This row's position in the current page of results — cycles the
+     * shared identity-avatar palette (`AdminAvatar`), offset by one from the
+     * traveller directory's own start so the two lists never coincidentally
+     * colour-match at the same row position. */
+    readonly index: number;
+    readonly onSelect?: (manager: ManagerListRowResponse) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface ManagerDirectoryFlowProps {
+    /** Optional page-head title — rendered above the search bar. Omit when
+     * this flow is mounted under a shell that already renders its own page
+     * title (e.g. `KaafilAgencyWorkspace`'s "Managers" nav destination), same
+     * convention `TravellerDirectoryFlow` establishes. */
+    readonly title?: string;
+    /** Optional supporting copy under `title` — omitted whenever `title` is. */
+    readonly subtitle?: string;
+    readonly onSelectManager?: (manager: ManagerListRowResponse) => void;
+    readonly components?: {
+        readonly ManagerResultRow?: ComponentType<ManagerResultRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerDirectoryFlow({ title, subtitle, onSelectManager, components, style, }: ManagerDirectoryFlowProps): ReactNode;
+
+type ManagerAgencyProfileTripRow = ManagerAgencyProfileResponse['trips'][number];
+interface ManagerProfileSectionProps {
+    readonly managerRef: string;
+    /** Renders a back affordance in the hero when supplied — omitted, the
+     * hero shows no back control (a host embedding this without its own
+     * "back to directory" concept, e.g. a modal). */
+    readonly onBack?: () => void;
+    readonly components?: {
+        readonly Hero?: ComponentType<{
+            readonly profile: ManagerAgencyProfileResponse;
+            readonly onBack?: () => void;
+        }>;
+        readonly AssignmentsCard?: ComponentType<{
+            readonly trips: readonly ManagerAgencyProfileTripRow[];
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function ManagerProfileSection({ managerRef, onBack, components, style, }: ManagerProfileSectionProps): ReactNode;
+
+interface TemplateAuthoringFlowProps {
+    /** Deep-link: skip the library and open this template's editor directly
+     * on mount. Omit to start on the library. */
+    readonly initialTemplateId?: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TemplateAuthoringFlow({ initialTemplateId, style, }: TemplateAuthoringFlowProps): ReactNode;
+
+interface TravellerSearchBoxProps {
+    /** An optional client-side floor — defaults to `0` (no floor; the server
+     * itself no longer requires a `q` at all). Set this when a host serving an
+     * unusually large agency wants to hold off issuing a request until the
+     * caller has typed a few characters. */
+    readonly minQueryLength?: number;
+    readonly debounceMs?: number;
+    readonly onSelectTraveller?: (traveller: TravellerDirectoryItemResponse) => void;
+    /** Rendered in the same row as the search input, right-aligned —
+     * `TravellerDirectoryFlow`'s own "Add traveller" button uses this so the
+     * two sit on one row instead of the search input stacking underneath a
+     * separate toolbar. Omit for a bare search box with nothing beside it. */
+    readonly trailingAction?: ReactNode;
+    readonly components?: {
+        readonly TravellerSearchBoxUI?: ComponentType<Record<string, never>>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+interface TravellerDirectoryFlowProps {
+    /** Optional page-head title — rendered above the search bar, boilerplate's
+     * own "Trips" `<h1>` rhythm (`--kf-type-heading-xl-*`). Omit when this flow
+     * is mounted under a shell that already renders its own page title (e.g.
+     * `AdminShell`'s "Traveller" nav destination) so the two never double up —
+     * pass one only when this flow owns its own page head. */
+    readonly title?: string;
+    /** Optional supporting copy under `title` — omitted whenever `title` is. */
+    readonly subtitle?: string;
+    /** Omits the "Add traveller" affordance — for a host whose own CRM UI is
+     * the sole traveller-intake surface. */
+    readonly hideAddTraveller?: boolean;
+    /** Lifts the "Add traveller" affordance OUT of this card and into the
+     * host's own page header, where the design puts it. Supplying this pair
+     * makes the flow controlled: it renders no button of its own and opens
+     * the modal from `adding` instead. `ChecklistTemplateLibrary`/
+     * `FormsLibrary` expose the identical pair for the same reason. */
+    readonly adding?: boolean;
+    readonly onAddingChange?: (adding: boolean) => void;
+    readonly minQueryLength?: number;
+    readonly debounceMs?: number;
+    readonly onSelectTraveller?: (traveller: TravellerDirectoryItemResponse) => void;
+    /** Fires once a traveller is created via `AddTravellerModal`, with the
+     * real row the server returned. */
+    readonly onTravellerAdded?: (traveller: TravellerDirectoryItemResponse) => void;
+    readonly components?: {
+        readonly TravellerSearchBox?: ComponentType<TravellerSearchBoxProps>;
+        readonly AddTravellerModal?: ComponentType<{
+            readonly onClose: () => void;
+            readonly onCreated: (traveller: TravellerDirectoryItemResponse) => void;
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TravellerSearchBox({ minQueryLength, debounceMs, onSelectTraveller, trailingAction, style, }: TravellerSearchBoxProps): ReactNode;
+declare function TravellerDirectoryFlow({ title, subtitle, hideAddTraveller, adding, onAddingChange, minQueryLength, debounceMs, onSelectTraveller, onTravellerAdded, components, style, }: TravellerDirectoryFlowProps): ReactNode;
+
+type TravellerAgencyProfileTripRow = TravellerAgencyProfileResponse['trips'][number];
+type TravellerAgencyProfileNoteRow = TravellerAgencyProfileResponse['notes'][number];
+type TravellerAgencyProfileLifetime = TravellerAgencyProfileResponse['lifetime'];
+interface TravellerProfileSectionProps {
+    readonly travellerRef: string;
+    /** Renders a back affordance in the hero when supplied — omitted, the
+     * hero shows no back control (a host embedding this without its own
+     * "back to directory" concept, e.g. a modal). */
+    readonly onBack?: () => void;
+    readonly components?: {
+        readonly Hero?: ComponentType<{
+            readonly profile: TravellerAgencyProfileResponse;
+            readonly onBack?: () => void;
+        }>;
+        readonly PersonalCard?: ComponentType<{
+            readonly profile: TravellerAgencyProfileResponse;
+        }>;
+        readonly LifetimeCard?: ComponentType<{
+            readonly lifetime: TravellerAgencyProfileLifetime;
+        }>;
+        readonly TripHistoryTable?: ComponentType<{
+            readonly trips: readonly TravellerAgencyProfileTripRow[];
+        }>;
+        readonly NotesList?: ComponentType<{
+            readonly notes: readonly TravellerAgencyProfileNoteRow[];
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TravellerProfileSection({ travellerRef, onBack, components, style, }: TravellerProfileSectionProps): ReactNode;
+
+interface TriggerDetailPanelProps {
+    readonly trigger: JourneyTriggerRow;
+    readonly saving: boolean;
+    /** The header toggle — `enabled` is always live, never gated behind the
+     * edit dialog (matches the mockup's own `selToggle` sitting in the
+     * "SELECTED" card head, outside `dlgOpen`'s own scope). */
+    readonly onToggle: (next: boolean) => void;
+    /** Fired by `TriggerEditDialog`'s own Save — `anchor`/`offsetHours` only,
+     * `enabled` never travels through this path. */
+    readonly onSave: (input: {
+        readonly anchor: 'START' | 'END';
+        readonly offsetHours: number;
+    }) => void;
+    readonly phaseLabel: (phase: string) => string;
+    readonly style?: KaafilTokenOverrides;
+}
+interface TriggerTemplateEditorProps {
+    readonly title?: string;
+    readonly subtitle?: string;
+    /** Show only this trip mode's triggers. Omit to show both. */
+    readonly tripModeFilter?: 'GROUP' | 'PERSONALIZED';
+    readonly onTriggerPatched?: (trigger: JourneyTriggerRow) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TriggerTemplateEditor({ title, subtitle, tripModeFilter, onTriggerPatched, style, }: TriggerTemplateEditorProps): ReactNode;
+
+/** A booking that is not a tombstone. `useBookings` hands both through so a
+ * caller can tell the difference; this tab only ever renders the live
+ * ones. */
+type BookingLiveRow = Exclude<BookingListRow, {
+    readonly _tombstone: true;
+}>;
+type BookingKind = 'ACCOMMODATION' | 'TRANSPORT' | 'ACTIVITY';
+interface TripBookingsSectionProps {
+    readonly tripRef: string;
+    /** Offered on a row that has vouchers, so an operator can get to the
+     * files themselves. Navigation is a callback — the UIKit ships no
+     * router (hard rule #9). Absent means the affordance is not offered. */
+    readonly onOpenDocuments?: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripBookingsSection({ tripRef, onOpenDocuments, style, }: TripBookingsSectionProps): ReactNode;
+
+interface ChecklistItemRowProps {
+    readonly item: ChecklistItemLiveRow;
+    readonly readOnly: boolean;
+    readonly busy: boolean;
+    readonly onToggle: () => void;
+    readonly onEdit: () => void;
+}
+
+interface PhasePanelProps {
+    readonly phase: ChecklistPhase;
+    readonly sections: readonly ChecklistSectionRow[];
+    readonly items: readonly ChecklistItemLiveRow[];
+    readonly readOnly: boolean;
+    readonly busyItemId: string | null;
+    readonly onToggle: (item: ChecklistItemLiveRow) => void;
+    readonly onEdit: (item: ChecklistItemLiveRow) => void;
+    readonly onAddToSection: (section: ChecklistSectionRow) => void;
+    readonly onAddToPhase: (phase: ChecklistPhase) => void;
+    readonly ItemRow?: ComponentType<ChecklistItemRowProps>;
+}
+
+/** One row of `useChecklists()`'s `items[]` — a live item or a tombstone. */
+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 ChecklistPhase = ChecklistSectionRow['phase'];
+type ChecklistGate = ChecklistItemLiveRow['gate'];
+interface TripChecklistSectionProps {
+    /** The trip this section reads `useChecklists(tripRef)` for. */
+    readonly tripRef: string;
+    /** Forces every toggle/add/edit/delete affordance inert. The `423`
+     * close-out lock drives this internally too. */
+    readonly readOnly?: boolean;
+    /** Opens with one phase focused rather than all three equal-width. */
+    readonly initialPhase?: ChecklistPhase;
+    /** Multi-select bulk toggle. Gate-carrying items are excluded from a
+     * selection regardless — see this file's header. */
+    readonly enableBulkToggle?: boolean;
+    /** Fires after a toggle LANDS, once per item even for a bulk toggle. */
+    readonly onItemToggled?: (itemId: string) => void;
+    /** Tier-4 named-component overrides. Each receives exactly the props this
+     * composite's own default renders it with. */
+    readonly components?: {
+        readonly PhasePanel?: ComponentType<PhasePanelProps>;
+        readonly ChecklistItemRow?: ComponentType<ChecklistItemRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripChecklistSection({ tripRef, readOnly, initialPhase, onItemToggled, components, style, }: TripChecklistSectionProps): ReactNode;
+
+/** `Trip.eventType`, derived off the row so it cannot drift from the wire. */
+type TripEventType = AgencyTripRow['eventType'];
+interface TripRowProps {
+    readonly trip: AgencyTripRow;
+    /** This row's position in the current page — cycles the shared
+     * identity-avatar palette so adjacent rows never colour-match. */
+    readonly index: number;
+    readonly onOpen: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface TripDirectoryFlowProps {
+    /** Opens one trip. Prop-presence gates the affordance: without it rows are
+     * inert text rather than buttons, for a host that embeds this list purely
+     * as a read-only overview. */
+    readonly onOpenTrip?: (trip: AgencyTripRow) => void;
+    /** Seeds the Tours/Treks chip — for a host deep-linking into the trek view.
+     * Uncontrolled after mount. */
+    readonly initialEventType?: TripEventType;
+    readonly components?: {
+        readonly TripRow?: ComponentType<TripRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripDirectoryFlow({ onOpenTrip, initialEventType, components, style, }: TripDirectoryFlowProps): ReactNode;
+
+/**
+ * The spend facts a receipt row borrows. Deliberately narrow — this is what
+ * an expense row actually carries that helps NAME a document. Note the
+ * absence of a person: an expense has `category`/`amountMinor`/`currency`/
+ * `description`/`vendorName`/`spentAt` and no spender, so no "uploaded by"
+ * is claimed anywhere on this surface.
+ */
+interface DocumentSpend {
+    readonly description: string;
+    readonly vendorName: string | null;
+    readonly amountMinor: number;
+    readonly currency: string;
+    readonly spentAt: string;
+    readonly voidedAt: string | null;
+}
+/** One table row: the file, plus the spend it belongs to when one is known. */
+interface DocumentRowModel {
+    readonly file: FileListItem;
+    /** `undefined` for every non-receipt, and for a receipt whose spend is not
+     * in the ledger this page read. Never a reason to drop the row. */
+    readonly spend: DocumentSpend | undefined;
+}
+interface TripDocumentsSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripDocumentsSection({ tripRef, style }: TripDocumentsSectionProps): ReactNode;
+
+/** An expense that is not a tombstone. A VOID is not a tombstone — the row
+ * stays live with `voidedAt` set. */
+type ExpenseLiveRow = Exclude<ExpenseDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type ExpenseCategory = ExpenseLiveRow['category'];
+type ExpensePaymentMode = ExpenseLiveRow['paymentMode'];
+type ExpenseClaimStatus = NonNullable<ExpenseLiveRow['claimStatus']>;
+/** What the ledger is narrowed to. All client-side: `listExpenses` takes
+ * `?since=` only, so there is no server filter to pass these to. */
+interface ExpenseFilters {
+    readonly category: ExpenseCategory | null;
+    readonly paymentMode: ExpensePaymentMode | null;
+    readonly missingReceiptOnly: boolean;
+}
+interface TripExpensesSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripExpensesSection({ tripRef, style }: TripExpensesSectionProps): ReactNode;
+
+type FloatMovementType = FloatMovementRow['type'];
+type FloatDirection = FloatMovementRow['direction'];
+/** Which write a dialog is collecting. `adjust` carries a direction; the
+ * other two are fixed by their route. */
+type FloatAction = 'issue' | 'return' | 'adjust';
+interface TripFloatSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripFloatSection({ tripRef, style }: TripFloatSectionProps): ReactNode;
+
+interface FormRowProps {
+    readonly form: TripFormRow;
+    /** From `completion()`. `undefined` when that read has not landed or
+     * failed — the row then shows the submitted count ALONE rather than a
+     * fraction with an invented denominator. */
+    readonly total: number | undefined;
+    readonly readOnly: boolean;
+    readonly busy: boolean;
+    readonly onDispatch: () => void;
+    readonly onExport: () => void;
+    readonly onOpenMissing: () => void;
+}
+
+/** One line of the who-is-missing join: everyone on the manifest, with
+ * their response if they have one. */
+interface FormParticipantRow {
+    readonly travellerId: string;
+    readonly fullName: string;
+    /** `undefined` for a traveller with NO response row — the point of the
+     * whole view, so it renders as a person who has not started, never as an
+     * absence from the list. */
+    readonly response: TripFormResponseRow | undefined;
+}
+interface TripFormsSectionProps {
+    readonly tripRef: string;
+    /** Forces every dispatch/capture affordance inert. */
+    readonly readOnly?: boolean;
+    readonly components?: {
+        readonly FormRow?: ComponentType<FormRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripFormsSection({ tripRef, readOnly, components, style, }: TripFormsSectionProps): ReactNode;
+
+type ItineraryViewMode = 'days' | 'timeline';
+interface TripItinerarySectionProps {
+    readonly tripRef: string;
+    /**
+     * Host-owned navigation to a vendor. Omitted when the host has no vendor
+     * route — the item's vendor then renders as plain text rather than as a
+     * link that goes nowhere (hard rule #9: this package ships no router).
+     */
+    readonly onOpenVendor?: (vendorId: string) => void;
+    readonly style?: KaafilTokenOverrides;
+}
+/** A day plus the items that belong to it, in `sortOrder`. */
+interface ItineraryDayGroup {
+    readonly day: ItineraryDayRow;
+    readonly dayNumber: number;
+    readonly items: readonly ItineraryItemRow[];
+}
+
+declare function TripItinerarySection({ tripRef, onOpenVendor, style, }: TripItinerarySectionProps): ReactNode;
+
+/** How the body is arranged. The reference's own two modes. */
+type ManifestGroupBy = 'booking_group' | 'none';
+/**
+ * Everything the filter panel can narrow by — a subset of what the endpoint
+ * accepts, holding only the axes a real control exists for.
+ *
+ * `partyId` and `sort` are endpoint parameters this panel drives from
+ * elsewhere (a group card's own "only this group" affordance, and the column
+ * head), so they are not in the panel's own state.
+ */
+interface ManifestFilterState {
+    readonly bookingStatus?: 'CONFIRMED' | 'TENTATIVE' | 'CANCELLED';
+    readonly balanceState?: 'paid' | 'due' | 'unbilled';
+    readonly gender?: 'MALE' | 'FEMALE' | 'OTHER' | 'UNKNOWN';
+    /** `true` narrows to travellers carrying a medical flag. Never `false` —
+     * "not flagged" is not a filter an operator asks for. */
+    readonly medical?: true;
+}
+interface TripManifestSectionProps {
+    readonly tripRef: string;
+    /**
+     * Opens the agency-wide traveller profile — a DIFFERENT screen from this
+     * tab's own trip-scoped detail dialog (`TravellerProfileSection` reads the
+     * cross-trip directory profile; the dialog reads this trip's). The
+     * reference's row kebab links to it in a new tab; this Surface ships no
+     * router (hard rule #9), so it is a callback the host wires to its own
+     * travellers pane. Absent means the affordance is not offered.
+     */
+    readonly onOpenTravellerProfile?: (travellerId: string, fullName: string) => void;
+    readonly components?: {
+        readonly ManifestRow?: ComponentType<ManifestRowProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+interface ManifestRowProps {
+    readonly row: TripManifestRow;
+    /** Row position, for the avatar palette cycle. */
+    readonly index: number;
+    /** The server's own "now", for deriving age from a date of birth. Threaded
+     * in rather than read from a local clock — hard rule #6's posture. */
+    readonly serverTime: string | undefined;
+    readonly onOpen: () => void;
+    readonly onRemove: () => void;
+    readonly onShareLink: () => void;
+    readonly onOpenProfile?: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripManifestSection({ tripRef, onOpenTravellerProfile, components, style, }: TripManifestSectionProps): ReactNode;
+
+/** A collection that is not a tombstone. A VOID is not a tombstone — the row
+ * stays live with `voidedAt` set. A tombstone means the row was deleted at
+ * the source, which this API has no path to cause. */
+type CollectionLiveRow = Exclude<CollectionDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type CollectionMode = CollectionLiveRow['mode'];
+type EligibleStatus = 'due' | 'settled' | 'all';
+
+interface TripPaymentsSectionProps {
+    readonly tripRef: string;
+    /**
+     * The trip's own money rollup, straight from the trip read
+     * (`balance.{collectedMinor, totalMinor, dueMinor, currency}`). A prop
+     * rather than a second fetch: `TripWorkspace` already holds it, and two
+     * reads of the same figure is how two surfaces come to disagree about it.
+     *
+     * `undefined` when the trip has no balance rows at all — rendered as
+     * absent, never as ₹0 (`deriveTripHead.ts`'s own rule: "a trip with no
+     * balance rows has not collected ₹0, it has not been billed").
+     */
+    readonly balance: {
+        readonly collectedMinor: number;
+        readonly totalMinor: number;
+        readonly dueMinor: number;
+        readonly currency: string;
+    } | undefined;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripPaymentsSection({ tripRef, balance, style, }: TripPaymentsSectionProps): ReactNode;
+
+/** A stop that is not a tombstone. */
+type PickupStopLiveRow = Exclude<PickupStopDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type PickupKind = PickupStopLiveRow['kind'];
+type PickupRollup = PickupStopLiveRow['rollup'];
+/** Which of the two runs the switcher is showing. */
+type PickupView = 'stops' | 'boarding';
+interface TripPickupsSectionProps {
+    readonly tripRef: string;
+    /**
+     * The TRIP's IANA zone. `scheduledTime` is an instant and the DTO says to
+     * "render in `trip.timezone` — never assume the caller's own zone", and
+     * `pickups.list` does not carry the trip. Passed down by `TripWorkspace`,
+     * which already holds the trip read, rather than fetched a second time.
+     */
+    readonly timeZone: string;
+    /**
+     * The trip's own start date, used to anchor a NEW stop's wall clock to a
+     * calendar day when the run is still empty and there is no sibling stop to
+     * take the day from.
+     *
+     * A prop rather than `new Date()`: hard rule #6 forbids a local clock in
+     * `/core` and the same reasoning holds one layer out — "today" on the
+     * operator's laptop is not a fact about this trip, and for a trip that has
+     * not departed it is the wrong day outright.
+     */
+    readonly tripStartIso: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripPickupsSection({ tripRef, timeZone, tripStartIso, style, }: TripPickupsSectionProps): ReactNode;
+
+/** A room that is not a tombstone. */
+type RoomingRoomLiveRow = Exclude<RoomingRoomDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type RoomingBed = RoomingRoomLiveRow['beds'][number];
+type RoomingOccupant = NonNullable<RoomingBed['occupant']>;
+/** A stay window that is not a tombstone. `stayWindows.list` is a DELTA feed
+ * like the rooms — with `?since=` it carries drops, so the row type is a
+ * union and the tombstone branch has to be narrowed away before anything
+ * reads a `label`. */
+type StayWindowRow = Exclude<RoomingStayWindowRow, {
+    readonly _tombstone: true;
+}>;
+/** One stay window with the rooms that belong to it. */
+interface RoomingWindowGroup {
+    readonly window: StayWindowRow;
+    readonly rooms: readonly RoomingRoomLiveRow[];
+    readonly bedCount: number;
+    readonly occupiedCount: number;
+}
+interface TripRoomingSectionProps {
+    readonly tripRef: string;
+    /**
+     * The TRIP's IANA zone. A stay window's `startDate`/`endDate` are instants,
+     * and the same rule the itinerary and pickups tabs follow applies: render
+     * in the trip's zone, never the reader's.
+     */
+    readonly timeZone: string;
+    /**
+     * The trip's own first and last day. A stay window is a stretch of nights
+     * WITHIN a trip, so its date pickers are bounded to these — an unbounded
+     * calendar lets an operator pick a night the trip does not have, which the
+     * engine would then hold as a real window nobody is on.
+     *
+     * Props rather than a second read: `TripWorkspace` already holds the trip.
+     */
+    readonly tripStartIso: string;
+    readonly tripEndIso: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripRoomingSection({ tripRef, timeZone, tripStartIso, tripEndIso, style, }: TripRoomingSectionProps): ReactNode;
+
+type VendorCategory = TripVendorRow['category'];
+/** Where one supplier is used on this trip. A count is `undefined`, never 0,
+ * when its capability is dark or its read has not landed — "we cannot see"
+ * and "there are none" are different facts and must not render alike. */
+interface SupplierUsage {
+    readonly vehicles: number | undefined;
+    readonly itineraryItems: number | undefined;
+    readonly expenses: number | undefined;
+}
+/** The rows the usage scan reads, kept as one bag so `deriveSuppliers` takes
+ * a single argument rather than six. */
+interface UsageSources {
+    readonly vehicles: readonly SeatingVehicleDeltaRow[] | undefined;
+    readonly itineraryItems: readonly ItineraryItemRow[] | undefined;
+    readonly expenses: readonly ExpenseDeltaRow[] | undefined;
+}
+type SupplierSortKey = 'name' | 'category' | 'city';
+interface TripSuppliersSectionProps {
+    readonly tripRef: string;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripSuppliersSection({ tripRef, style }: TripSuppliersSectionProps): ReactNode;
+
+/** A vehicle that is not a tombstone. */
+type SeatingVehicleLiveRow = Exclude<SeatingVehicleDeltaRow, {
+    readonly _tombstone: true;
+}>;
+type SeatingSeat = SeatingVehicleLiveRow['seats'][number];
+type VehicleType = SeatingVehicleLiveRow['type'];
+type VehicleLayout = SeatingVehicleLiveRow['layout'];
+
+/** One rendered row of a seat grid: the seats at one `rowIndex`, in `side`
+ * order, with the aisle position the layout implies. */
+interface SeatRow {
+    readonly rowIndex: number;
+    readonly seats: readonly SeatingSeat[];
+    /** How many seats sit before the aisle. `0` means no aisle in this row —
+     * a bench seat spanning it, or a `FLAT` layout. */
+    readonly aisleAfter: number;
+}
+interface TripVehiclesSectionProps {
+    readonly tripRef: string;
+    /**
+     * The trip's day count, so `days[]` indexes can be named ("days 2–3") and
+     * the day picker can offer the days that exist. A prop rather than a second
+     * read: `TripWorkspace` already holds the trip.
+     */
+    readonly durationDays: number;
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function TripVehiclesSection({ tripRef, durationDays, style, }: TripVehiclesSectionProps): ReactNode;
+
+/** Every panel this surface can show. Ordered by `TAB_ORDER` in
+ * `internal/tripTabRegistry.tsx`, never by this union's declaration order. */
+type TripTabKey = 'overview' | 'manifest' | 'itinerary' | 'pickups' | 'rooming' | 'vehicles' | 'vendors' | 'payments' | 'expenses' | 'float' | 'checklist' | 'bookings' | 'forms' | 'feedback' | 'documents' | 'treks';
+/** Why a tab is not showing a real panel. Drives the placeholder's copy, so
+ * the operator is told the truth rather than a generic "coming soon". */
+type TripTabBlocker = 
+/** The module is deferred to a later pass. The API is reachable. */
+'deferred'
+/** No admin-reachable endpoint exists — the read is manager-only. */
+ | 'managerOnly'
+/** The server resolved this capability as unavailable for this trip. */
+ | 'capabilityDark';
+interface TripWorkspaceProps {
+    /** Kaafil's id for the trip, or the agency's own external id — either
+     * resolves (`trip-directory.validation.ts`'s `tripRef` param). */
+    readonly tripRef: string;
+    /** Which tab to open on mount. An unknown or now-dark key falls back to
+     * `overview` rather than rendering an empty rail. */
+    readonly initialTab?: TripTabKey;
+    /** Navigation is a callback, never a route — the UIKit ships no router
+     * (hard rule #9). */
+    readonly onBack?: () => void;
+    /**
+     * Forwarded to the People-going tab, whose row kebab offers "Open full
+     * profile". That profile is the agency-wide `TravellerProfileSection`, a
+     * different screen from this tab's own trip-scoped detail dialog — so it
+     * belongs to whichever surface owns the travellers pane, not to this one.
+     * Absent means the affordance is not offered.
+     */
+    readonly onOpenTravellerProfile?: (travellerId: string, fullName: string) => void;
+    /** Host panel overrides, merged over the registry. A host that has built
+     * its own Rooming panel can drop it in without forking this composite. */
+    readonly panels?: Partial<Record<TripTabKey, ReactNode>>;
+    readonly components?: {
+        readonly TripWorkspaceHead?: ComponentType<TripWorkspaceHeadProps>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+interface TripWorkspaceHeadProps {
+    readonly trip: AgencyTripRead;
+    readonly onBack?: () => void;
+    readonly style?: KaafilTokenOverrides;
+}
+interface TripKpiCell {
+    readonly key: string;
+    readonly labelKey: string;
+    readonly value: string;
+    /** Absent when the underlying number is genuinely absent rather than zero
+     * — the cell then renders a worded dash, never a fabricated `0`. */
+    readonly subLabel?: string;
+    readonly tone?: 'pos' | 'warn' | 'mute';
+}
+
+declare function TripWorkspace({ tripRef, initialTab, onBack, onOpenTravellerProfile, panels, components, style, }: TripWorkspaceProps): ReactNode;
+
+/** A registry key (hard rule #8), never an inline SVG passed per-item —
+ * `AdminShell` owns its own icon set, matching `ManagerShell`'s own fixed
+ * icon registry; a host wanting a different glyph for one of these seven
+ * uses `components.NavIcon`. Extended this wave (`forms`/`templates`/
+ * `journey` added) to cover every real `KaafilAgencyWorkspace` pane —
+ * extending this union is not a breaking change since it is additive. */
+type AdminShellNavIconKey = 'trips' | 'traveller' | 'manager' | 'settings' | 'forms' | 'templates' | 'journey';
+interface AdminShellNavItem {
+    readonly key: string;
+    readonly label: string;
+    readonly icon: AdminShellNavIconKey;
+    /** Already-resolved group heading text (never a translation key —
+     * `AdminShell` itself reads no i18n context, same as `label`) — items
+     * sharing the same `group` string render together under one eyebrow
+     * header, in the order groups first appear in `items`. Omit on every
+     * item to render one flat, ungrouped list (fully backward compatible);
+     * mixing grouped and ungrouped items renders the ungrouped ones with no
+     * header, in their own relative position. */
+    readonly group?: string;
+    /** Real count only — never a guessed or placeholder number. Omit to
+     * render no badge at all. */
+    readonly badge?: number;
+    /** `'warn'` gets the warn-token treatment (e.g. an overdue/blocked
+     * count) — omit for the default neutral pill. */
+    readonly badgeVariant?: 'default' | 'warn';
+    /** Renders this item visibly inert — muted, `aria-disabled`, never fires
+     * `onSelectItem` — for a real, spec'd destination whose composite doesn't
+     * exist yet (`KaafilAgencyWorkspace`'s own progressive-linking posture:
+     * the item is present from day one, wired for real the moment its
+     * composite ships, never removed and re-added). Omit for a live item. */
+    readonly disabled?: boolean;
+}
+interface AdminShellBreadcrumbEntry {
+    readonly label: string;
+    /** Optional even on the last (current-page) crumb — `AdminShell` itself
+     * decides the last entry is never interactive and always carries
+     * `aria-current="page"`, ignoring any `onSelect` supplied on it, so a
+     * caller that (accidentally, or out of habit) supplies one on every
+     * entry can never make the current page read as a clickable link. */
+    readonly onSelect?: () => void;
+}
+interface AdminShellHeaderConfig {
+    /** Small uppercase label above `title` (e.g. "AUTOMATION", "AGENCY") —
+     * omit along with `title` for the "content owns its own page head" case;
+     * never shown with a `breadcrumb`-only header. */
+    readonly eyebrow?: string;
+    /** Omit when the mounted content already owns its own page head (e.g.
+     * `TravellerProfileSection`'s own hero renders the avatar/name) — showing
+     * `AdminShell`'s own `<h1>` above it would just duplicate that name.
+     * `breadcrumb` still renders without a `title`. */
+    readonly title?: string;
+    /** Optional supporting copy directly under `title`, tightly paired with
+     * it (its own small top margin, `title`'s own bottom margin shrinks to
+     * match) — never the larger title-to-content gap a title-only page uses.
+     * A composite mounted below (e.g. `TravellerDirectoryFlow`) should NOT
+     * also render its own `title`/`subtitle` in this case — one page head per
+     * screen, owned by whichever component is closest to the root; here,
+     * `AdminShell` itself. */
+    readonly subtitle?: string;
+    readonly breadcrumb?: readonly AdminShellBreadcrumbEntry[];
+    /** Collapses a longer trail to `first … lastN` (a non-interactive
+     * ellipsis marker, never a caller-supplied entry) once `breadcrumb.length`
+     * exceeds this — mirrors the real `maxItems` prop on this package's own
+     * `Breadcrumb` primitive spec (`atomic/11-navigation.md`). Defaults to 4. */
+    readonly breadcrumbMaxItems?: number;
+    /** The page-level primary action (e.g. "New template", "Add traveller")
+     * — rendered beside `title`, never duplicated inside the mounted
+     * content's own card header. Verified against the mockup's own generic
+     * page-header pattern: every pane's fixture carries a `cta` field
+     * alongside `title`/`eyebrow`/`sub`, rendered in the SAME flex row as the
+     * heading, not inside whatever card sits below it. */
+    readonly primaryCta?: {
+        readonly label: string;
+        readonly onClick: () => void;
+    };
+}
+interface AdminShellBrand {
+    readonly name: string;
+    /** The host CRM's own brand mark — this package never renders a
+     * Kaafil-branded default here, matching `BrandShell`'s "host controls
+     * branding" posture elsewhere in this package. */
+    readonly logo?: ReactNode;
+}
+interface AdminShellUser {
+    readonly name: string;
+    readonly roleLabel?: string;
+    /** 2-letter avatar initials — omit renders a person-less initial block
+     * derived from `name`, never a "?" (same reasoning `ManagerShell`'s own
+     * header documents for its avatar). */
+    readonly avatarInitials?: string;
+    /** Renders a sign-out affordance only when supplied — prop-presence
+     * gates the button, same convention `ManagerMeSection`/`KaafilManagerApp`
+     * already establish. */
+    readonly onSignOut?: () => void;
+}
+interface AdminShellProps {
+    readonly header: AdminShellHeaderConfig;
+    /** Caller-supplied, never hardcoded (hard rule #9's own "host owns
+     * navigation" extended to what destinations even exist) — this wave's
+     * real value is the 4-item Trips/Traveller/Manager/Settings set, but
+     * `AdminShell` itself has no opinion on that list's contents. */
+    readonly items: readonly AdminShellNavItem[];
+    readonly activeItemKey: string;
+    readonly onSelectItem: (key: string) => void;
+    readonly brand?: AdminShellBrand;
+    readonly user?: AdminShellUser;
+    /** The content region — `AdminShell` renders chrome only, exactly as
+     * `ManagerShell` does for its own `main` region. */
+    readonly children?: ReactNode;
+    readonly components?: {
+        readonly NavIcon?: ComponentType<{
+            readonly iconKey: AdminShellNavIconKey;
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+/** The spec's own `initialPane` union (`01-surface.md`), plus `settings` —
+ * see this file's header for why. */
+type KaafilAgencyWorkspacePaneKey = 'trips' | 'managers' | 'travellers' | 'forms' | 'templates' | 'journey' | 'settings';
+interface KaafilAgencyWorkspaceProps {
+    /** Seeds which pane is selected on first mount. Ignored once `selectedPane`
+     * (below) is supplied. Defaults to `'trips'`, per spec. */
+    readonly initialPane?: KaafilAgencyWorkspacePaneKey;
+    /** Fully controls which pane is selected — omit to let this component own
+     * its own selection state. `onPaneChange` still fires so the host can
+     * react. */
+    readonly selectedPane?: KaafilAgencyWorkspacePaneKey;
+    /**
+     * Fired alongside the internal trip-workspace push opening — the same
+     * analytics/URL-sync mirror every other `onOpen*` below is, paired with
+     * `onCloseTrip`.
+     *
+     * ITS MEANING CHANGED, AND DELIBERATELY KEEPS ITS SPEC'D NAME. It used to
+     * be the ONLY way a trip opened: this Surface had no trip detail of its
+     * own, so the spec had the host respond by "navigating to its own
+     * `KaafilTripWorkspace`-mounting route". This Surface now mounts
+     * `TripWorkspace` itself, so opening a trip no longer depends on the host
+     * doing anything — a host that ignores this callback still gets a working
+     * drill-down. Kept under the spec's own name rather than joined by a
+     * second `onOpenTrip` prop meaning the identical thing: two doors to one
+     * event is exactly the duplication the rest of this Surface avoids.
+     *
+     * The second argument is new. Existing handlers that take only `tripRef`
+     * keep working unchanged.
+     */
+    readonly onSelectTrip?: (tripRef: string, name: string) => void;
+    /** Fired alongside the internal trip-workspace push closing — the mirror
+     * of `onSelectTrip`, matching every other pane's own pair. */
+    readonly onCloseTrip?: () => void;
+    /** Fires whenever the active pane changes — per spec, T2. */
+    readonly onPaneChange?: (pane: KaafilAgencyWorkspacePaneKey) => 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 `TravellerDirectoryFlow`).
+     * `KaafilManagerApp`'s own exact `onOpenTraveller`/`onCloseTraveller`
+     * precedent. */
+    readonly onOpenTraveller?: (travellerId: string, fullName: string) => void;
+    readonly onCloseTraveller?: () => void;
+    /** Fired alongside the internal manager-profile push opening/closing — the
+     * identical `onOpenTraveller`/`onCloseTraveller` shape, for the Managers
+     * pane's own directory → profile journey. */
+    readonly onOpenManager?: (managerId: string, fullName: string) => void;
+    readonly onCloseManager?: () => void;
+    /** Fired alongside the internal template-editor push opening/closing — the
+     * identical `onOpenTraveller`/`onCloseTraveller` shape, for the Checklist
+     * templates pane's own library → editor journey. */
+    readonly onOpenTemplate?: (templateId: string, title: string) => void;
+    readonly onCloseTemplate?: () => void;
+    /** Fired alongside the internal form-builder push opening/closing — the
+     * identical `onOpenTraveller`/`onCloseTraveller` shape, for the Forms
+     * pane's own library → builder journey. */
+    readonly onOpenForm?: (formId: string, title: string) => void;
+    readonly onCloseForm?: () => void;
+    /** Renders "Sign out" on `AdminShell`'s own user footer only when
+     * supplied (prop-presence gates the affordance, same convention
+     * `KaafilManagerApp`/`ManagerMeSection` already establish) — this Surface
+     * has no credential/session-teardown method of its own to call first. */
+    readonly onSignOut?: () => void;
+    readonly components?: {
+        /** Maps onto `AdminShell`'s own existing `components.NavIcon` slot — the
+         * only real nav-chrome customization point that exists today. Narrower
+         * than the spec's "TabBar" name implies, the identical mapping
+         * `KaafilManagerApp.types.ts` already documents for its own
+         * `TabBar`→`ManagerShell.components.TabIcon`. */
+        readonly TabBar?: ComponentType<{
+            readonly iconKey: AdminShellNavIconKey;
+        }>;
+    };
+    readonly style?: KaafilTokenOverrides;
+}
+
+declare function KaafilAgencyWorkspace(props: KaafilAgencyWorkspaceProps): ReactNode;
+
+declare function AdminShell({ header, items, activeItemKey, onSelectItem, brand, user, children, components, style, }: AdminShellProps): ReactNode;
+
+export { AdminShell, type AdminShellBrand, type AdminShellBreadcrumbEntry, type AdminShellHeaderConfig, type AdminShellNavIconKey, type AdminShellNavItem, type AdminShellProps, type AdminShellUser, AgencySettingsScreen, type AgencySettingsScreenProps, type BookingKind, type BookingLiveRow, type BuilderHeaderProps, type ChecklistGate, type ChecklistPhase, ChecklistTemplateEditor, type ChecklistTemplateEditorProps, type ChecklistTemplateItemDraft, ChecklistTemplateLibrary, type ChecklistTemplateLibraryProps, ChecklistTemplateRow, type CollectionLiveRow, type CollectionMode, type DocumentRowModel, type DocumentSpend, type EligibleStatus, type ExpenseCategory, type ExpenseClaimStatus, type ExpenseFilters, type ExpenseLiveRow, type ExpensePaymentMode, type FieldDef, type FieldRowProps, type FloatAction, type FloatDirection, FloatMovementRow, type FloatMovementType, FormBuilder, type FormBuilderProps, FormDetailRow, FormFieldRow, type FormParticipantRow, FormRow, type FormRowProps$1 as FormRowProps, FormsAuthoringFlow, type FormsAuthoringFlowProps, FormsLibrary, type FormsLibraryProps, type ItineraryDayGroup, type ItineraryViewMode, JourneyTriggerRow, KaafilAgencyWorkspace, type KaafilAgencyWorkspacePaneKey, type KaafilAgencyWorkspaceProps, type ManagerAgencyProfileTripRow, ManagerDirectoryFlow, type ManagerDirectoryFlowProps, ManagerListRowResponse, ManagerProfileSection, type ManagerProfileSectionProps, type ManagerResultRowProps, type ManifestFilterState, type ManifestGroupBy, type ManifestRowProps, type PickupKind, type PickupRollup, type PickupStopLiveRow, type PickupView, type PlanLockedReason, PlanLockedScreen, type PlanLockedScreenProps, type RoomingBed, type RoomingOccupant, type RoomingRoomLiveRow, type RoomingWindowGroup, type SeatRow, type SeatingSeat, type SeatingVehicleLiveRow, type SectionCardProps, type SectionDef, type StayWindowRow, type SupplierSortKey, type SupplierUsage, TemplateAuthoringFlow, type TemplateAuthoringFlowProps, type TemplateRowProps, type TravellerAgencyProfileLifetime, type TravellerAgencyProfileNoteRow, type TravellerAgencyProfileTripRow, TravellerDirectoryFlow, type TravellerDirectoryFlowProps, TravellerDirectoryItemResponse, TravellerProfileSection, type TravellerProfileSectionProps, TravellerSearchBox, type TravellerSearchBoxProps, type TriggerDetailPanelProps, TriggerTemplateEditor, type TriggerTemplateEditorProps, TripBookingsSection, type TripBookingsSectionProps, TripChecklistSection, type TripChecklistSectionProps, TripDirectoryFlow, type TripDirectoryFlowProps, AgencyTripRow as TripDirectoryRow, type TripRowProps as TripDirectoryRowProps, TripDocumentsSection, type TripDocumentsSectionProps, TripExpensesSection, type TripExpensesSectionProps, TripFloatSection, type TripFloatSectionProps, TripFormsSection, type TripFormsSectionProps, TripItinerarySection, type TripItinerarySectionProps, type TripKpiCell, TripManifestRow, TripManifestSection, type TripManifestSectionProps, TripPaymentsSection, type TripPaymentsSectionProps, TripPickupsSection, type TripPickupsSectionProps, TripRoomingSection, type TripRoomingSectionProps, TripSuppliersSection, type TripSuppliersSectionProps, type TripTabBlocker, type TripTabKey, TripVehiclesSection, type TripVehiclesSectionProps, TripVendorRow, TripWorkspace, type TripWorkspaceHeadProps, type TripWorkspaceProps, AgencyTripRead as TripWorkspaceTrip, type UsageSources, type VehicleLayout, type VehicleType, type VendorCategory };