kaafil-react-uikit 0.1.0-beta.1

package/dist/useAgencyTrip-BzyJB1D9.d.ts

@@ -0,0 +1,454 @@
+import { KaafilClient, AgencyManagersResource, TravellersResource, AgencyManagerFilters, TravellerDirectoryFilters, TripManagersResource, PartyKind, TripPartiesResource, AgencyTripsResource, AgencyTripFilters, AgencyTripSegmentCounts, TripManifestFilters, TripManifestFacets, CollectionsResource, ListEligibleCollectionsOptions, RecordCollectionOptions, OutboxOp, VoidCollectionOptions } from 'kaafil-js/client';
+import { H as CreateAgencyChecklistTemplateInput, P as PatchAgencyChecklistTemplateInput, J as RemoveAgencyChecklistTemplateInput, K as PublishAgencyChecklistTemplateInput, D as DomainHookResult } from './useVendors-DXOuZWhZ.js';
+
+type BoundAgencySettings = KaafilClient['agencies']['settings'];
+/** `AgencySettingsResponse` — never imported by name, derived off the one
+ * exported anchor (`useAgencyJourneyTriggers.ts`'s own convention). */
+type AgencySettingsDocument = Awaited<ReturnType<BoundAgencySettings['get']>>;
+type PatchAgencySettingsInput = Omit<Parameters<BoundAgencySettings['patch']>[0], 'signal'>;
+interface AgencySettingsReady {
+    readonly document: AgencySettingsDocument | undefined;
+    readonly loaded: boolean;
+    readonly lastFetchFailed: boolean;
+    readonly refresh: () => Promise<void>;
+    readonly patchSettings: (input: PatchAgencySettingsInput) => Promise<AgencySettingsDocument>;
+}
+declare function useAgencySettings(): AgencySettingsReady;
+
+type BoundAgencyChecklistTemplates = KaafilClient['checklists']['agencyTemplates'];
+/** `ChecklistTemplateSectionResponse` (`kaafil-js/src/generated
+ * /schema.d.ts`) — never imported by name, the same "derive off the one
+ * exported anchor" discipline `useChecklists.ts` itself documents for this
+ * exact resource. */
+type ChecklistTemplateRow = Awaited<ReturnType<BoundAgencyChecklistTemplates['list']>>['templates'][number];
+type ChecklistTemplateItemRow = ChecklistTemplateRow['items'][number];
+interface AgencyChecklistTemplatesReady {
+    readonly templates: readonly ChecklistTemplateRow[];
+    /** `true` once at least one `list()` call has settled (success or
+     * failure) — same `loaded` contract every other agency-wide list hook
+     * this package ships already uses. */
+    readonly loaded: boolean;
+    /** `true` when the MOST RECENT fetch threw. */
+    readonly lastFetchFailed: boolean;
+    readonly refresh: () => Promise<void>;
+    readonly createTemplate: (input: CreateAgencyChecklistTemplateInput) => Promise<ChecklistTemplateRow>;
+    readonly patchTemplate: (input: PatchAgencyChecklistTemplateInput) => Promise<ChecklistTemplateRow>;
+    readonly removeTemplate: (input: RemoveAgencyChecklistTemplateInput) => Promise<void>;
+    readonly publishTemplate: (input: PublishAgencyChecklistTemplateInput) => Promise<ChecklistTemplateRow>;
+}
+declare function useAgencyChecklistTemplates(): AgencyChecklistTemplatesReady;
+
+type BoundForms = KaafilClient['forms'];
+/** `FormListResponse.items[]` — the agency's whole catalog (metadata only,
+ * no sections/fields). */
+type FormRow = Awaited<ReturnType<BoundForms['list']>>['items'][number];
+/** `FormDetailResponse` — one form's full definition: metadata + sections +
+ * fields. `FormBuilder`'s own read. */
+type FormDetailRow = Awaited<ReturnType<BoundForms['get']>>;
+/** The patch-transition family's own return shape (`FormDefinitionResponse`
+ * — metadata only, no `sections`/`fields`) — `patch`/`archive`/`unarchive`/
+ * `publish`/`close`/`reopen`/`clone` all answer this, distinct from
+ * `FormDetailRow`, which only `get`/`create` return. */
+type FormSummaryRow = Awaited<ReturnType<BoundForms['patch']>>;
+type FormSectionRow = FormDetailRow['sections'][number];
+type FormFieldRow = FormDetailRow['fields'][number];
+/** `GET /api/v1/forms/bindings` row — the closed profile/CRM-key catalog a
+ * field's `binding` may target. */
+type BindingRow = Awaited<ReturnType<BoundForms['bindings']['list']>>['items'][number];
+type CreateFormInput = Omit<Parameters<BoundForms['create']>[0], 'idempotencyKey' | 'signal'>;
+type PatchFormInput = Omit<Parameters<BoundForms['patch']>[0], 'signal'>;
+type DeleteFormInput = Omit<Parameters<BoundForms['delete']>[0], 'signal'>;
+type CloneFormInput = Omit<Parameters<BoundForms['clone']>[0], 'idempotencyKey' | 'signal'>;
+type ReorderFormInput = Omit<Parameters<BoundForms['reorder']>[0], 'signal'>;
+type CreateFormSectionInput = Omit<Parameters<BoundForms['sections']['create']>[0], 'signal'>;
+type PatchFormSectionInput = Omit<Parameters<BoundForms['sections']['patch']>[0], 'signal'>;
+type DeleteFormSectionInput = Omit<Parameters<BoundForms['sections']['delete']>[0], 'signal'>;
+type CreateFormFieldInput = Omit<Parameters<BoundForms['fields']['create']>[0], 'signal'>;
+type PatchFormFieldInput = Omit<Parameters<BoundForms['fields']['patch']>[0], 'signal'>;
+type DeleteFormFieldInput = Omit<Parameters<BoundForms['fields']['delete']>[0], 'signal'>;
+interface AgencyFormsReady {
+    readonly forms: readonly FormRow[];
+    /** `true` once at least one `list()` call has settled (success or
+     * failure). */
+    readonly loaded: boolean;
+    /** `true` when the MOST RECENT fetch threw. */
+    readonly lastFetchFailed: boolean;
+    readonly refresh: () => Promise<void>;
+    readonly createForm: (input: CreateFormInput) => Promise<FormDetailRow>;
+    /** Live read of one form's full definition — `FormBuilder`'s own load. */
+    readonly getForm: (formId: string) => Promise<FormDetailRow>;
+    readonly patchForm: (input: PatchFormInput) => Promise<FormSummaryRow>;
+    /** See this file's header — real, but UI-gated to `DRAFT` as a safety
+     * convention, not a wire restriction. */
+    readonly deleteForm: (input: DeleteFormInput) => Promise<void>;
+    readonly archiveForm: (formId: string) => Promise<FormSummaryRow>;
+    readonly unarchiveForm: (formId: string) => Promise<FormSummaryRow>;
+    readonly publishForm: (formId: string) => Promise<FormSummaryRow>;
+    readonly closeForm: (formId: string) => Promise<FormSummaryRow>;
+    readonly reopenForm: (formId: string) => Promise<FormSummaryRow>;
+    readonly cloneForm: (input: CloneFormInput) => Promise<FormSummaryRow>;
+    /** One idempotent transaction over every section's and field's
+     * `sortOrder` — never one call per row. */
+    readonly reorderForm: (input: ReorderFormInput) => Promise<void>;
+    readonly createSection: (input: CreateFormSectionInput) => Promise<FormSectionRow>;
+    readonly patchSection: (input: PatchFormSectionInput) => Promise<FormSectionRow>;
+    readonly deleteSection: (input: DeleteFormSectionInput) => Promise<void>;
+    readonly createField: (input: CreateFormFieldInput) => Promise<FormFieldRow>;
+    readonly patchField: (input: PatchFormFieldInput) => Promise<FormFieldRow>;
+    readonly deleteField: (input: DeleteFormFieldInput) => Promise<void>;
+    readonly listBindings: () => Promise<readonly BindingRow[]>;
+}
+declare function useAgencyForms(): AgencyFormsReady;
+
+interface PaginatedListFetchResult<TRow> {
+    readonly rows: readonly TRow[];
+    readonly nextCursor: string | undefined;
+}
+type PaginatedListFetch<TRow> = (cursor: string | undefined) => Promise<PaginatedListFetchResult<TRow>>;
+interface PaginatedListOptions {
+    readonly pageSize?: number;
+}
+interface PaginatedListResult<TRow> {
+    readonly rows: readonly TRow[];
+    readonly hasNext: boolean;
+    readonly hasPrev: boolean;
+    readonly loadNext: () => Promise<void>;
+    readonly loadPrev: () => Promise<void>;
+}
+/**
+ * `pageSize` (`08-core-hooks.md §4`'s `options?.pageSize`) is accepted for
+ * call-site parity with the documented signature; whether the SUPPLIED
+ * `fetch` function actually honours it as a page-size hint is up to the
+ * caller — this hook is domain-agnostic plumbing over `fetch`, never a
+ * binding to one resource group, and has no wire-level knowledge of any one
+ * endpoint's own page-size parameter name.
+ */
+declare function usePaginatedList<TRow>(fetch: PaginatedListFetch<TRow>, options?: PaginatedListOptions): PaginatedListResult<TRow>;
+
+type ManagerListRowResponse = Awaited<ReturnType<AgencyManagersResource['listPage']>>[number];
+type TravellerDirectoryItemResponse = Awaited<ReturnType<TravellersResource['listForAgencyPage']>>[number];
+type TripManagerRowResponse = Awaited<ReturnType<TripManagersResource['patch']>>;
+type TripManifestItemResponse = Awaited<ReturnType<TravellersResource['listForTrip']>>[number];
+interface PromoteManagerInput {
+    readonly tripRef: string;
+    readonly managerRef: string;
+    /** The row's own `version` — `If-Match`, required (`trips.managers.patch`'s
+     * own doc comment: a missing or stale one are the same `409`). */
+    readonly version: number;
+    readonly role?: 'MANAGER' | 'COORDINATOR';
+    readonly isLead?: boolean;
+}
+/** Put an existing agency manager onto a trip.
+ *
+ * NO `sourceUpdatedAt`. The wire's `assignManager` takes one — it is a CRM's
+ * own last-changed instant, used to order concurrent writes last-writer-wins
+ * — and this pass made it OPTIONAL precisely so a desk need not send one. A
+ * desk has no such instant, and minting `new Date()` here would be a local
+ * clock deciding a conflict, which is the thing hard rule #6 keeps out of
+ * `/core`. Omitted, the server stamps the write itself. */
+interface AssignManagerInput {
+    readonly tripRef: string;
+    /** Kaafil's id for the manager, or your own external ref — either
+     * resolves. Comes from `agencyManagers`, which this hook already lists. */
+    readonly managerRef: string;
+    readonly role?: 'MANAGER' | 'COORDINATOR';
+    /** `true` demotes whatever manager currently leads the trip, in the same
+     * transaction — at most one lead per trip, the server's rule. */
+    readonly isLead?: boolean;
+}
+interface UnassignManagerInput {
+    readonly tripRef: string;
+    readonly managerRef: string;
+}
+interface AddTravellerInput {
+    readonly tripRef: string;
+    /** Client-minted — this trip-manifest write (`pushManifest`) has no
+     * "omit to auto-mint" behaviour of its own, unlike the agency-directory
+     * `createAgencyTraveller` below. */
+    readonly externalTravellerId: string;
+    readonly fullName: string;
+    readonly phone?: string;
+}
+interface CreateAgencyTravellerInput {
+    readonly fullName: string;
+    readonly phone?: string;
+    readonly email?: string;
+    readonly locale?: string;
+    /** Omit to let the server mint `externalId: null` — real server-side
+     * behaviour (`GAP-008`, confirmed against the live `kaafil-engine`
+     * route), never a client-side id workaround. Supplying one that already
+     * resolves within this agency returns the existing row rather than
+     * erroring. */
+    readonly externalTravellerId?: string;
+}
+interface RemoveFromManifestInput {
+    readonly tripRef: string;
+    /** Kaafil's id for the traveller, or your own external id — either resolves. */
+    readonly travellerRef: string;
+}
+type PartyWriteResponse = Awaited<ReturnType<TripPartiesResource['patch']>>;
+interface CreatePartyInput {
+    readonly tripRef: string;
+    readonly kind: PartyKind;
+    /** OPTIONAL, and deliberately not nullable — unlike `PatchPartyInput.label`.
+     * The wire lets a create omit a label but not send an explicit null, and it
+     * lets a patch CLEAR one; those are different operations and this pair
+     * mirrors the contract rather than flattening both to `string | null`. */
+    readonly label?: string;
+    /** Traveller refs — Kaafil ids or your own external ids. Creating a party
+     * PINS it (FRD §4.10.5): it stops being re-derived from shared contact
+     * details on the next manifest push. */
+    readonly travellerRefs: readonly string[];
+}
+interface PatchPartyInput {
+    readonly tripRef: string;
+    readonly partyId: string;
+    /** The PARTY row's version, from `trips.parties.list` or a manifest row's
+     * denormalised party. A stale one answers `409 CONFLICT_VERSION`, which the
+     * caller surfaces rather than retries blind. */
+    readonly version: number;
+    readonly kind?: PartyKind;
+    /** `null` CLEARS the label; omitting the key leaves it alone. */
+    readonly label?: string | null;
+    readonly travellerRefs?: readonly string[];
+}
+interface DeletePartyInput {
+    readonly tripRef: string;
+    readonly partyId: string;
+}
+/**
+ * ── WHY A SECOND NOTE WRITE EXISTS, AND WHY IT IS NOT A DUPLICATE ──────────
+ *
+ * `useTravellerProfile().addNote` already wraps `travellers.addNote`. It
+ * enqueues through `useOfflineMutation`, which is right for the field — a
+ * manager writes a note standing in a car park — and which THROWS ("this
+ * write has nowhere to enqueue to yet") when no `OfflineShell` is mounted. A
+ * desk console mounts none, so that door is closed to this family.
+ *
+ * This is the same operation through the office door: awaited directly,
+ * classified on failure, retried by the caller. Exactly the split
+ * `promoteManager` and the party writes above already make, and the reason
+ * this file's "WRITES ARE DIRECT" section exists. The READ half is NOT
+ * duplicated — an admin surface uses `useTravellerProfile`'s own live
+ * `getDetail` read unchanged.
+ *
+ * Named `DirectNoteInput` rather than `AddTravellerNoteInput` so the two
+ * doors are distinguishable at a glance in the barrel.
+ */
+interface DirectNoteInput {
+    readonly tripRef: string;
+    readonly travellerRef: string;
+    readonly body: string;
+}
+interface DirectoriesReady {
+    /** One page-fetcher factory per instance of `ManagerDirectoryTable` — a
+     * fresh `usePaginatedList()` binding per distinct `filters` value (a
+     * caller remounts on a filter change, the same "reset paging on scope
+     * change" idiom `trip-manifest-panel.tsx`'s own `useEffect` documents). */
+    readonly makeManagersFetch: (filters: AgencyManagerFilters) => PaginatedListFetch<ManagerListRowResponse>;
+    /** Same shape, for `TravellerSearchBox` — `filters.q` is REQUIRED
+     * upstream (`TravellerDirectoryFilters`'s own type), so a caller must
+     * never invoke the returned fetch while `q` is under the 2-character
+     * floor (`travellers.listForAgency`'s own doc comment: a guaranteed `422`
+     * otherwise). */
+    readonly makeTravellersFetch: (filters: TravellerDirectoryFilters) => PaginatedListFetch<TravellerDirectoryItemResponse>;
+    /** `travellers.listForTrip` — the bounded, non-paginated manifest read
+     * `TripTravellerManifestTable` would use if it were not, per its own
+     * Offline note, a cache-first `useSnapshotList()` read instead; kept here
+     * for a caller that genuinely wants a live one-shot manifest fetch. */
+    readonly listTripManifest: (tripRef: string) => Promise<readonly TripManifestItemResponse[]>;
+    /** `trips.managers.patch` — role change and/or lead promotion/demotion.
+     * Throws `DirectoriesWriteError` on failure; see this file's header for
+     * why this is a direct call, not an outbox enqueue. */
+    readonly promoteManager: (input: PromoteManagerInput) => Promise<TripManagerRowResponse>;
+    /** `trips.managers.assign` — puts an existing agency manager on the trip.
+     * Both this and `unassignManager` were `apiKey`-only until this pass
+     * widened them, which is why the roster card had a promote control and no
+     * way to add anyone. Same direct-call posture as `promoteManager`. */
+    readonly assignManager: (input: AssignManagerInput) => Promise<void>;
+    /** `trips.managers.unassign` — a SOFT unlink, not a delete: the manager
+     * stays in the agency directory and can be re-assigned, which is why this
+     * needs no confirm-with-consequences dialog. */
+    readonly unassignManager: (input: UnassignManagerInput) => Promise<void>;
+    /** `trips.travellers.pushManifest`, single-traveller — resolves to the
+     * echoed `externalTravellerId` on `verdict: 'applied'`, matching
+     * `AddTravellerControl.onAdded`'s own contract. Throws
+     * `DirectoriesWriteError` (including a synthesized one for
+     * `verdict !== 'applied'`, which the wire never surfaces as an HTTP
+     * failure) otherwise. */
+    readonly addTraveller: (input: AddTravellerInput) => Promise<string>;
+    /**
+     * `trips.travellers.remove` — soft-removes a traveller's LINK to this trip.
+     * The traveller stays in the agency directory; only their place on this
+     * manifest goes.
+     */
+    readonly removeFromManifest: (input: RemoveFromManifestInput) => Promise<void>;
+    /** `trips.parties.add` — a PINNED party (the manager override, FRD §4.10.5). */
+    readonly createParty: (input: CreatePartyInput) => Promise<PartyWriteResponse>;
+    /** `trips.parties.patch` — kind, label and/or membership. Also pins the party. */
+    readonly patchParty: (input: PatchPartyInput) => Promise<PartyWriteResponse>;
+    /** `trips.parties.remove` — retires a party. Its members become solo, which
+     * is the ABSENCE of a party rather than a party of one. */
+    readonly deleteParty: (input: DeletePartyInput) => Promise<void>;
+    /** `travellers.addNote` — appends to this traveller's note thread on this trip. */
+    readonly addTravellerNote: (input: DirectNoteInput) => Promise<void>;
+    /** `travellers.create` — the real, non-workaround agency-directory create
+     * (`GAP-008`, closed). Never trip-attached; a caller that needs "add this
+     * traveller to THIS trip's manifest" still wants `addTraveller` above.
+     * Throws `DirectoriesWriteError` on failure. */
+    readonly createAgencyTraveller: (input: CreateAgencyTravellerInput) => Promise<TravellerDirectoryItemResponse>;
+}
+declare function useDirectories(agencyRef?: string): DirectoriesReady;
+
+type BoundJourneyTriggers = KaafilClient['journey']['triggers'];
+/** `JourneyTriggerResponse` — one row of `GET /agencies/{ref}/journey-triggers`. */
+type JourneyTriggerRow = Awaited<ReturnType<BoundJourneyTriggers['list']>>[number];
+type PatchJourneyTriggerInput = Omit<Parameters<BoundJourneyTriggers['patch']>[0], 'idempotencyKey' | 'signal'>;
+interface AgencyJourneyTriggersReady {
+    readonly triggers: readonly JourneyTriggerRow[];
+    /** `true` once at least one `list()` call has settled (success or failure). */
+    readonly loaded: boolean;
+    /** `true` when the MOST RECENT fetch threw. */
+    readonly lastFetchFailed: boolean;
+    readonly refresh: () => Promise<void>;
+    readonly patchTrigger: (input: PatchJourneyTriggerInput) => Promise<JourneyTriggerRow>;
+}
+declare function useAgencyJourneyTriggers(): AgencyJourneyTriggersReady;
+
+type AgencyTripRow = Awaited<ReturnType<AgencyTripsResource['listPage']>>[number];
+interface AgencyTripsResult {
+    /**
+     * One `PaginatedListFetch` per filter set, for the caller's own
+     * `usePaginatedList()`. Remount (or re-key) the consumer when `filters`
+     * changes — `usePaginatedList`'s own contract fetches page 0 exactly once
+     * per mount.
+     */
+    readonly makeTripsFetch: (filters: AgencyTripFilters) => PaginatedListFetch<AgencyTripRow>;
+    /**
+     * Per-bucket counts over the WHOLE agency, for the list's filter chips —
+     * `undefined` until the first page lands.
+     *
+     * These arrive on the envelope's `facets` key rather than in the page
+     * body, because they are computed over the whole filtered set rather than
+     * the page. `PaginatedListFetchResult` has no slot for them and must not
+     * grow one: that type is shared, domain-agnostic plumbing (its own header
+     * insists on it), and a `facets` field there would mean nothing for the
+     * four other lists that use it. So this hook keeps them itself, written
+     * as each page resolves.
+     */
+    readonly segmentCounts: AgencyTripSegmentCounts | undefined;
+}
+declare function useAgencyTrips(): AgencyTripsResult;
+
+/**
+ * Returns the single `KaafilClient` instance `SessionShell` opened via
+ * `session.open`/`admin.open`/`share.open`. Throws outside the provider
+ * tree — see `08-core-hooks.md §1.1`.
+ */
+declare function useKaafilClient(): KaafilClient;
+
+type BoundManifestResource = ReturnType<typeof useKaafilClient>['agencies']['trips']['manifest'];
+type TripManifestRow = Awaited<ReturnType<BoundManifestResource['listPage']>>[number];
+interface AgencyTripManifestResult {
+    /**
+     * One `PaginatedListFetch` per filter set, for the caller's own
+     * `usePaginatedList()`. Remount (or re-key) the consumer when `filters`
+     * changes — `usePaginatedList`'s own contract fetches page 0 exactly once
+     * per mount.
+     *
+     * `pageSize` lets the grouped and flat modes ask for different pages off
+     * the same hook without a second door.
+     */
+    readonly makeManifestFetch: (filters: TripManifestFilters, pageSize?: number) => PaginatedListFetch<TripManifestRow>;
+    /**
+     * Whole-set aggregates for the tiles above the table — `undefined` until
+     * the first page lands.
+     *
+     * These describe the CURRENT FILTERED SET (unlike `useAgencyTrips`'
+     * `segmentCounts`, which spans the whole agency): a head-count above a
+     * filtered table has to describe that table. They arrive on the envelope's
+     * `facets` key for the same reason those do — `PaginatedListFetchResult` is
+     * shared, domain-agnostic plumbing and must not grow a `facets` slot that
+     * would mean nothing for the five other lists using it.
+     */
+    readonly facets: TripManifestFacets | undefined;
+    /** The page size a grouped read should pass — see `GROUPED_PAGE_LIMIT`. */
+    readonly groupedPageSize: number;
+}
+declare function useAgencyTripManifest(tripRef: string): AgencyTripManifestResult;
+
+type CollectionDeltaRow = Awaited<ReturnType<CollectionsResource['list']>>[number];
+type EligibleRow = Awaited<ReturnType<CollectionsResource['eligible']>>[number];
+type EligibleCollectionsStatus = NonNullable<ListEligibleCollectionsOptions['status']>;
+
+type RecordCollectionInput = Omit<RecordCollectionOptions, 'tripRef' | 'idempotencyKey' | 'signal'>;
+type VoidCollectionInput = Omit<VoidCollectionOptions, 'tripRef' | 'signal'>;
+/**
+ * The eligible-balance roster — `collections.eligible()`, ranked "who owes
+ * money," the manager family's own p90 read (`families/manager/
+ * 01-collections.md`'s own header prose). Its own live-fetch state,
+ * deliberately not a `SnapshotList` — see this file's header comment.
+ */
+interface CollectionsEligiblePool {
+    readonly rows: readonly EligibleRow[];
+    /** The `status` this pool's current `rows` were fetched with. */
+    readonly status: EligibleCollectionsStatus;
+    /** `true` once at least one `client.collections.eligible()` call has
+     * settled (success or failure) for the CURRENT `status` — distinguishes
+     * "never fetched yet" from "fetched and genuinely empty" (everyone
+     * settled, or nobody has a `Balance` row at all). */
+    readonly loaded: boolean;
+    /** `true` when the MOST RECENT fetch threw — rendered distinctly from
+     * `rows: [], loaded: true`, never collapsed into the same empty state. */
+    readonly lastFetchFailed: boolean;
+    /** The server time (`meta.serverTime`) of the last successful fetch. */
+    readonly fetchedAt: string | undefined;
+    /** Re-runs the live read. Passing a `status` switches the pool's own
+     * filter and refetches under it; omitting it re-runs the CURRENT
+     * `status`. `record()` already calls this on its own success (a payment
+     * can move a traveller from `'due'` to `'settled'`) — a composite calls
+     * it again after any other action that changes who is eligible. */
+    readonly refresh: (status?: EligibleCollectionsStatus) => Promise<void>;
+}
+interface CollectionsReady {
+    /** Recorded collections, cache-first — `collections.list()`'s own delta
+     * feed. Includes tombstones for a row's own soft-void is NOT a tombstone
+     * (`void()` corrects a live row in place, `CollectionResponse.voidedAt`
+     * flips, the row is never removed) — a tombstone here means the
+     * collection itself was deleted at the source, which this API surface
+     * has no path to cause; the branch exists only because
+     * `CollectionDeltaResponse`'s own generated union carries one. */
+    readonly collections: readonly CollectionDeltaRow[];
+    readonly syncedAt: string | undefined;
+    /** Re-reads the desk lane after a write. A NO-OP on a field device, where
+     * the outbox drain emits `snapshot.updated` and the cache-first read
+     * re-renders itself — a composite need not know which lane it is on. */
+    readonly refreshLive: () => Promise<void>;
+    readonly eligible: CollectionsEligiblePool;
+    /** Records one customer payment. The overpay guard is server-authoritative
+     * (`collections.ts`'s own header comment) — this method does not
+     * pre-validate `amountMinor` against anything; a `422
+     * BUSINESS_RULE_VIOLATION` surfaces through the outbox op's own
+     * `parkReason`, same as any other refused write. */
+    readonly record: (input: RecordCollectionInput) => Promise<OutboxOp | null>;
+    /** Voids a collection — a correction, never an edit or hard delete.
+     * `version` is required (mirrors `VoidCollectionOptions`, which makes a
+     * missing `If-Match` impossible to construct, not merely discouraged). */
+    readonly void: (input: VoidCollectionInput) => Promise<OutboxOp | null>;
+}
+/**
+ * PERSONALIZED mode-dark. Returns `{ status: 'dark', reason }` before any
+ * fetch when the `'collections'` capability triple isn't `lit`
+ * (`06-capability-and-personas.md §3`).
+ */
+declare function useCollections(tripRef: string): DomainHookResult<CollectionsReady>;
+
+type AgencyTripRead = Awaited<ReturnType<AgencyTripsResource['get']>>;
+interface AgencyTripResult {
+    readonly read: AgencyTripRead | undefined;
+    readonly readFailed: boolean;
+    readonly refresh: () => Promise<void>;
+}
+declare function useAgencyTrip(tripRef: string): AgencyTripResult;
+
+export { type AgencyTripRow as A, type BindingRow as B, type ChecklistTemplateRow as C, type DeleteFormFieldInput as D, type PaginatedListResult as E, type FormDetailRow as F, type PatchAgencySettingsInput as G, type PatchFormFieldInput as H, type PatchFormInput as I, type JourneyTriggerRow as J, type PatchFormSectionInput as K, type PatchJourneyTriggerInput as L, type ManagerListRowResponse as M, useAgencyChecklistTemplates as N, useAgencyForms as O, type PaginatedListFetch as P, useAgencyJourneyTriggers as Q, type ReorderFormInput as R, useAgencySettings as S, type TravellerDirectoryItemResponse as T, useAgencyTrip as U, useAgencyTripManifest as V, useAgencyTrips as W, useCollections as X, useDirectories as Y, useKaafilClient as Z, usePaginatedList as _, type ChecklistTemplateItemRow as a, type FormFieldRow as b, type FormRow as c, type TripManifestRow as d, type CollectionDeltaRow as e, type AgencyTripRead as f, type AgencySettingsDocument as g, type FormSectionRow as h, type AgencyChecklistTemplatesReady as i, type AgencyFormsReady as j, type AgencyJourneyTriggersReady as k, type AgencySettingsReady as l, type AgencyTripManifestResult as m, type AgencyTripResult as n, type AgencyTripsResult as o, type CloneFormInput as p, type CollectionsReady as q, type CreateFormFieldInput as r, type CreateFormInput as s, type CreateFormSectionInput as t, type DeleteFormInput as u, type DeleteFormSectionInput as v, type DirectoriesReady as w, type FormSummaryRow as x, type PaginatedListFetchResult as y, type PaginatedListOptions as z };