@ai-matrx/detail 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,505 @@
+import { ComponentType, ReactNode } from 'react';
+
+/** The three ways a record detail can show. `window` is the platform default. */
+declare const DETAIL_PRESENTATIONS: readonly ["window", "docked", "page"];
+type DetailPresentation = (typeof DETAIL_PRESENTATIONS)[number];
+/**
+ * The knob every presentation decision reads (`platform.feature_knob`,
+ * feature `ui.detail`, key `default_presentation`; seeded by matrx-frontend's
+ * `migrations/detail_presentation_knob.sql`). Enum of DETAIL_PRESENTATIONS,
+ * overridable by organization and user. The package never reads the settings
+ * ladder itself — the host resolves this key and answers through the
+ * `usePresentationSetting` / `resolvePresentation` ports.
+ */
+declare const DETAIL_PRESENTATION_KNOB = "ui.detail.default_presentation";
+/**
+ * The PER-RECORD-TYPE override of the setting above (`platform.feature_knob`,
+ * feature `ui.detail`, key `presentation_by_type`): a json object keyed by
+ * record type token, e.g. `{"file": "docked"}`. Nearest wins over
+ * `default_presentation` for the type it names, and the same organization →
+ * user ladder resolves it, so an organization can set "contracts open as a
+ * page" and a person can still choose otherwise for themselves.
+ *
+ * WHY A SECOND KEY AND NOT THE `table` RUNG. The platform's per-table rung
+ * (DD-131, precedence 50) is keyed by a `platform.entity_types` ROW ID, and
+ * that table is admin-only by a restrictive policy — a browser cannot read the
+ * id, so a `table` rung would be a setting the screen offers and the reader
+ * never honours. One json key on the ladder the client already has is the
+ * override the settings platform supports today.
+ */
+declare const DETAIL_PRESENTATION_BY_TYPE_KNOB = "ui.detail.presentation_by_type";
+/**
+ * How many records of the list a detail was opened FROM may ride the page
+ * presentation's URL (`platform.feature_knob`, feature `ui.detail`, key
+ * `list_context_max_ids`; seeded by matrx-frontend's
+ * `migrations/detail_list_context_max_knob.sql`). Organization-overridable.
+ *
+ * Why a knob and not a constant: it is a ceiling, and every ceiling here is a
+ * row an admin owns (`common-docs/policies/limits-are-knobs-agents-set-them.md`).
+ * Why it exists at all: uncapped, a 500-row list produced a >20 KB href no
+ * server accepts (NEW-7, VERIFY-U-P1-R2). Beyond the cap the URL carries the
+ * window around the current record and the detail says the list was trimmed.
+ */
+declare const DETAIL_LIST_CONTEXT_MAX_KNOB = "ui.detail.list_context_max_ids";
+/**
+ * The cap when the knob has not answered yet (a cold cache, a signed-out
+ * render, a host that binds no settings ladder). 100 `type.id` pairs with uuid
+ * ids is the most the strictest presentation's FINAL URL can carry inside the
+ * budget below, and it is far more neighbours than a person arrows through in
+ * one sitting.
+ */
+declare const DEFAULT_DETAIL_LIST_CONTEXT_MAX = 100;
+/**
+ * 🚨 NEW-19 (VERIFY-U-P1-R4) — THE BUDGET BELONGS TO THE FINAL URL, ONCE.
+ *
+ * It used to be 6,000 characters measured on the list VALUE, one escaping layer
+ * too early, and nothing bounded the whole address:
+ *
+ *   * a detail window's deep link measured 5,992 against that 6,000 and reached
+ *     the address bar at 7,416, because the host's panel-URL writer re-serializes
+ *     the `?panels=` token through `new URLSearchParams(...).toString()`, which
+ *     re-escapes every `%` the token's own escaping already produced (a uuid's
+ *     `-` goes `-` → `%2D` → `%252D`);
+ *   * a detail PAGE that also carried an open window was 13,433 characters —
+ *     its own `?l=` plus the merged `panels=` — past the 8 KB request line, so
+ *     the edge answers 414 and the link is dead (VERIFY-U-P1-R4, NEW-19).
+ *
+ * 8,000 characters is the strictest edge in front of this platform (an 8 KB
+ * request line), and the method, the path, every other parameter and the
+ * token's own non-list args share it: a caller passes what the rest of the URL
+ * already costs as `reservedBytes` and `trimListContext` measures the FINAL
+ * serialized form. No caller may skip it, and the record SAYS what was cut
+ * (`trimmedFrom`).
+ */
+declare const DETAIL_URL_BUDGET_BYTES = 8000;
+/**
+ * The hard ceiling on the knob — the number of records the final URL can really
+ * carry in EVERY presentation, so a value below it always changes what travels.
+ *
+ * 🚨 NEW-20 (VERIFY-U-P1-R4). The ceiling was 500 while the byte budget stopped
+ * a uuid list at 139, so every value an administrator could set from 139 to 500
+ * behaved identically and the knob's own live basis text told them 200 records
+ * would travel. Measured against the final URL: 100 uuid entries under a short
+ * type token cost ~6.7 KB in the window's `?panels=` token (the strictest
+ * spelling) and ~4.3 KB in the page query, both inside the budget above; 150
+ * costs ~10 KB in the token and does not fit. matrx-frontend's
+ * `migrations/detail_list_context_max_deliverable.sql` lowers the knob's own
+ * `max_value` and default to the same number and rewrites its basis text, so
+ * the settings screen cannot offer records the URL can never carry. A longer
+ * type token still trims below the cap — and still says so.
+ */
+declare const DETAIL_LIST_CONTEXT_MAX_IDS_CEILING = 100;
+/**
+ * The knob's value as a usable cap; the default for anything that is not one,
+ * and never more than the ceiling the byte budget can honour (NEW-12). The ONE
+ * place the knob is turned into a number — the page href builder, the window's
+ * deep-link token and the trim itself all read it through here.
+ */
+declare function detailListContextMax(raw: unknown): number;
+/** The per-type entry for `type`, when the map holds a usable one. */
+declare function presentationForTypeFromMap(raw: unknown, type: string): DetailPresentation | undefined;
+declare function isDetailPresentation(value: unknown): value is DetailPresentation;
+/** A record, named the way the platform names records: type token + id. */
+interface DetailRef {
+    type: string;
+    id: string;
+}
+/** What the opener already knows, shown instantly until the row loads. */
+interface DetailSeed {
+    name?: string | null;
+    about?: string | null;
+}
+/**
+ * The list the record was opened FROM, so `[` / `]` move to the previous /
+ * next record without going back to the list. Plain data — it travels through
+ * the host's state store and the URL.
+ */
+interface DetailListContext {
+    items: DetailRef[];
+    index: number;
+    /**
+     * Set when this list is a WINDOW cut out of a longer one (the page
+     * presentation carries the list in the URL and it is capped —
+     * `ui.detail.list_context_max_ids`): the length of the list it was cut from,
+     * so the detail can say the neighbours beyond it are not reachable from here
+     * instead of presenting the window as the whole list (NEW-7).
+     */
+    trimmedFrom?: number;
+}
+/** What `useOpenDetail` accepts. */
+interface DetailOpenRequest extends DetailRef {
+    /** Skip the setting and open this way. Omit to honour the user's setting. */
+    presentation?: DetailPresentation;
+    seed?: DetailSeed | null;
+    list?: DetailListContext | null;
+}
+/** The payload a presentation receives — everything an open request carried. */
+interface DetailInstanceData extends DetailRef {
+    seed: DetailSeed | null;
+    list: DetailListContext | null;
+}
+type DetailRow = Record<string, unknown>;
+type DetailLoadResult<Row extends DetailRow = DetailRow> = {
+    row: Row;
+} | {
+    notFound: true;
+};
+/** One rendered field. `ref` makes the value a door instead of text. */
+interface DetailField {
+    key: string;
+    label: string;
+    text: string;
+    /** Render in a monospace block (JSON, long identifiers). */
+    mono?: boolean;
+    /**
+     * This value names another record — render it as a door.
+     *
+     * 🚨 AND THE DOOR SAYS WHAT IT OPENS (chair, 2026-09-18). The body used to
+     * render the door from `ref.id` alone, so a field whose `text` was
+     * "Acme Robotics" printed a truncated uuid instead: a door nobody can read is
+     * half a dead end. `name` is the record's own name for the host's `RefCell` to
+     * render; when it is omitted the body falls back to `text` (unless `text` is
+     * the id itself, in which case there is nothing better to say).
+     */
+    ref?: {
+        token: string;
+        id: string;
+        name?: string | null;
+    } | null;
+}
+/**
+ * The "source health strip" for a synced record — where it came from, when it
+ * was last refreshed, whether the grant behind it still works, and how to open
+ * it at the source. Absent for records the platform owns outright.
+ */
+interface DetailSourceHealth {
+    /** Human name of the source ("Google Drive", "Search Console"). */
+    source: string;
+    lastRefreshedAt?: string | null;
+    /**
+     * 🚨 THE GRANT-STATE VOCABULARY. Five of the six say what is wrong with the
+     * CONNECTION; `blocked` says the record cannot be refreshed and NOTHING the
+     * person can click repairs it (chair, 2026-09-18).
+     *
+     *   - `ok`       → the grant behind this record works;
+     *   - `expired`  → it lapsed and a reconnect renews it;
+     *   - `revoked`  → someone withdrew it and a reconnect re-grants it;
+     *   - `missing`  → we never had it, or the record is not shared with us;
+     *   - `unknown`  → we could not check (a read failed) — reconnecting is safe;
+     *   - `blocked`  → the source itself refuses, and no control repairs it: a
+     *                  provider outage, a quota, a platform-configuration fault,
+     *                  a connection the server reports as unavailable. The strip
+     *                  says BLOCKED, states the reason, and offers NO Reconnect —
+     *                  which `reconnectFor` enforces for this word whatever the
+     *                  producer or the host supplies, because a button that
+     *                  cannot work is a control that does nothing (law 4).
+     *
+     * `unknown` used to carry both meanings, so a blocked record was offered the
+     * consent window it could not be repaired by (VERIFY-U-P1-R5, N1's class).
+     */
+    grant: "ok" | "expired" | "revoked" | "missing" | "unknown" | "blocked";
+    /** One sentence for the grant state, in the person's language. */
+    grantDetail?: string | null;
+    openAtSourceHref?: string | null;
+    /**
+     * The per-record label for the "open at source" control, when the
+     * registration knows it precisely (chair, 2026-09-18). `DetailBody` derives
+     * a label from `source` on its own (see `deriveOpenAtSourceLabel`) for a
+     * producer that has no opinion, but that derivation guesses from a family
+     * name ("Google Docs, Sheets & Drive files" → "Open in Google") — a
+     * registration that knows the row's exact kind (a Doc vs. a Sheet vs. a
+     * plain Drive file; a Calendar event) sets this instead and it wins.
+     */
+    openAtSourceLabel?: string;
+    /**
+     * The repair offered when the grant is not `ok`. 🚨 THREE-VALUED, AND THE
+     * THREE MEAN DIFFERENT THINGS (Bugbot round 18 on frontend PR 228):
+     *
+     *   - a function  → offer THIS action;
+     *   - `null`      → offer NOTHING: the producer has decided a reconnect
+     *                   would not repair this refusal (a share the owner must
+     *                   grant, a record we own, an unclassified failure) and a
+     *                   Reconnect button would be a control that does nothing;
+     *   - omitted     → the producer has no opinion; the host's `reconnectSource`
+     *                   port supplies the action when it has one.
+     *
+     * `useDetailHealth` honours `null` explicitly — it used to fill the host
+     * action back in with `??`, which reads `null` as "unset", so a synced record
+     * whose refusal a reconnect cannot fix still showed Reconnect.
+     */
+    onReconnect?: (() => void) | null;
+    /** Offered when the record can be refreshed on demand. */
+    onRefresh?: (() => void | Promise<void>) | null;
+}
+/** What a `health` producer is told about the record it is answering for. */
+interface DetailHealthContext {
+    ref: DetailRef;
+    /** Aborted when the record changes or the detail closes. */
+    signal: AbortSignal;
+}
+/**
+ * The health producer: sync or async, and free to answer `null` for a record
+ * that is not synced. A throw or a rejection is rendered as an honest "we could
+ * not check the connection" strip, never as silence (`useDetailHealth`).
+ */
+type DetailHealthProducer<Row extends DetailRow = DetailRow> = (row: Row, ctx: DetailHealthContext) => DetailSourceHealth | null | Promise<DetailSourceHealth | null>;
+/** An extra section a record type adds under the fixed ones. */
+interface DetailSection {
+    id: string;
+    label: string;
+    content: ReactNode;
+}
+/** What a registration's optional `Frame` and sections receive. */
+interface DetailFrameContext {
+    ref: DetailRef;
+    recordType: DetailRecordType;
+    title: string;
+    about: string | null;
+    status: DetailStatus;
+    fields: DetailField[];
+    presentation: DetailPresentation;
+}
+/**
+ * ONE registration per record type. The core component (header + fixed
+ * sections) is derived from this; a record type never writes presentation
+ * code. Everything optional degrades to "section absent", never to a dead
+ * or disabled-looking control.
+ */
+interface DetailRecordType<Row extends DetailRow = DetailRow> {
+    /** The type token this registration answers for (as opened). */
+    type: string;
+    /** Human label ("Task", "File"). */
+    label: string;
+    icon: ComponentType<{
+        className?: string;
+    }>;
+    /** Accent classes for the icon and type chip; semantic tokens only. */
+    accent?: {
+        text: string;
+        bg: string;
+        ring: string;
+    } | null;
+    /**
+     * The canonical entity-registry token for doors, associations and history.
+     * `null` when the type is not a registry entity — the header then offers
+     * copy-id only, and the associations / history sections are absent.
+     */
+    entityToken: string | null;
+    /**
+     * Load the full row. `null` when the type has no single canonical source
+     * (the detail then renders from the seed alone and says so).
+     */
+    load: ((id: string, signal: AbortSignal) => Promise<DetailLoadResult<Row>>) | null;
+    /** The title to show; receives the loaded row (or null) and the seed. */
+    title: (row: Row | null, seed: DetailSeed | null) => string;
+    /**
+     * 🚨 WHAT THIS ROW IS, WHEN THE TYPE CANNOT SAY (chair, 2026-09-18). `label` is
+     * per TYPE, and a registered type is regularly a family: `crm.party` holds
+     * 1,432 companies and 460 persons, so a type labelled "Person" told a person
+     * that a company is a person — twice on screen, above a field reading
+     * `organization` (VERIFY-U-P1-R5, N6). A registration that can tell the
+     * difference from the row answers here.
+     *
+     * It names the RECORD, so it is used for the header's type chip and for the
+     * stand-in titles ("Company 3f2a1b9c") only. The presentation pane keeps the
+     * type-level `label`, because "Every contact record now opens as a window" is a
+     * statement about the TYPE's setting, not about the row on screen.
+     *
+     * `null` (or omitted) falls back to `label`, then to the raw type token.
+     */
+    labelForRow?: (row: Row | null) => string | null;
+    /** The field list for the fields section. */
+    fields: (row: Row) => DetailField[];
+    /**
+     * 🚨 THE SOURCE HEALTH STRIP'S PRODUCER. Source health for a SYNCED record;
+     * omit it, or answer `null`, for a record the platform owns outright.
+     *
+     * It may be ASYNC, because whether the grant behind a synced record still works
+     * is not in the row — it is the connector's recorded per-capability health, read
+     * from the server. The host wires this field when it registers the record type
+     * (never a second reader of the connector's health), and `useDetailHealth`
+     * resolves it. Until 2026-09-17 nothing set it, so the strip could not render on
+     * any record and the promise that a refusal anywhere shows on every dependent
+     * record with the same Reconnect had no witness (VERIFY-U-P1-R4).
+     */
+    health?: DetailHealthProducer<Row> | null;
+    /**
+     * Tokens the associations section shows. `null` hides the section.
+     * Omitted → the host's default set minus this record's own token.
+     */
+    associationTokens?: string[] | null;
+    /** Show the history section (row versions). Default: when `entityToken` is set. */
+    history?: boolean;
+    /** Extra sections under the fixed ones. */
+    extraSections?: ((row: Row | null, ctx: DetailFrameContext) => DetailSection[]) | null;
+    /**
+     * Wraps the whole body (surface runtime, right-click menu, …). Receives the
+     * live context so a host can expose the dossier to its agents. Optional.
+     */
+    Frame?: ComponentType<{
+        ctx: DetailFrameContext;
+        children: ReactNode;
+    }> | null;
+}
+type DetailStatus = "loading" | "ready" | "not-found" | "error"
+/** The type has no `load` — rendered from the seed alone. */
+ | "none";
+type DetailLoadState<Row extends DetailRow = DetailRow> = {
+    status: "loading";
+} | {
+    status: "ready";
+    row: Row;
+} | {
+    status: "not-found";
+} | {
+    status: "error";
+    message: string;
+} | {
+    status: "none";
+};
+/** One row of the history section. */
+interface DetailHistoryEntry {
+    version: number;
+    operation: string;
+    actorId: string | null;
+    occurredAt: string;
+    isCurrent: boolean;
+}
+
+/** One half of a `type.id` pair, carrying no character the decoders split on. */
+declare function encodeRefPart(value: string): string;
+/** Inverse of `encodeRefPart`; a hand-edited value comes back as its own text. */
+declare function decodeRefPart(value: string): string;
+/** `type.id,type.id` — the ONE spelling of a list in a URL, page or panel token. */
+declare function encodeListItems(items: readonly DetailRef[]): string;
+/** Inverse of `encodeListItems`; entries that do not name a record are dropped. */
+declare function decodeListItems(value: string | null | undefined): DetailRef[];
+/** How many characters these records cost in a URL — what the budget measures. */
+declare function listQueryBytes(items: readonly DetailRef[]): number;
+interface TrimListContextOptions {
+    /**
+     * The character budget for the whole URL. Defaults to the platform's request
+     * line (`DETAIL_URL_BUDGET_BYTES`).
+     */
+    budgetBytes?: number;
+    /**
+     * What the rest of the FINAL address already costs — the path, the query it is
+     * being merged into, the token's own non-list args. The list gets what is
+     * left, never a private allowance of its own (NEW-19).
+     */
+    reservedBytes?: number;
+    /**
+     * How many characters these records cost IN THE FINAL URL. The `?panels=`
+     * token escapes every separator and `URLSearchParams` escapes the result
+     * again, so the same records cost about 1.6× there what they cost in the page
+     * query (NEW-15, NEW-19).
+     */
+    measure?: (items: readonly DetailRef[]) => number;
+}
+/**
+ * The list as it may travel, plus what was left behind. Returns the same list
+ * when it already fits both limits, and `null` for no list at all.
+ */
+declare function trimListContext(list: DetailListContext | null | undefined, max: number, options?: TrimListContextOptions): DetailListContext | null;
+
+declare const DETAIL_URL_TYPE_KEY = "detail";
+declare const DETAIL_URL_AS_ARG = "as";
+/** The list the window was opened from, so a REFRESH keeps it (NEW-15). */
+declare const DETAIL_URL_LIST_ARG = "l";
+declare const DETAIL_URL_INDEX_ARG = "i";
+declare const DETAIL_URL_LIST_TOTAL_ARG = "lt";
+/**
+ * `type.id` — the panel URL splits tokens on `:` and args on `-`/`_`, never on
+ * `.`, so the two halves carry no `.` `:` or `,` of their own.
+ *
+ * 🚨 NEW-25 (VERIFY-U-P1-R4) — the halves used to be raw, so a type token or an
+ * id containing a dot came back as a DIFFERENT record: `{type: "gr.ant", id:
+ * "x.y"}` parsed as `{type: "gr", id: "ant.x.y"}`. One encoder, one decoder
+ * (`encodeRefPart` / `decodeRefPart`), the same pair the list spelling uses.
+ */
+declare function detailInstanceKey(ref: DetailRef): string;
+/** Inverse of `detailInstanceKey`; `null` when the key is not `type.id`. */
+declare function parseDetailInstanceKey(key: string | null | undefined): DetailRef | null;
+/** Which in-place presentation a URL arg names; `window` when unspecified. */
+declare function presentationFromUrlArg(value: string | undefined): Exclude<DetailPresentation, "page">;
+/** A value safe to carry as a `?panels=` arg — no `,` `:` `_` or `-`. */
+declare function encodePanelArgValue(value: string): string;
+/** Inverse of `encodePanelArgValue`. */
+declare function decodePanelArgValue(value: string): string;
+/**
+ * 🚨 NEW-19 (VERIFY-U-P1-R4) — MEASURE THE VALUE AS THE ADDRESS BAR CARRIES IT.
+ * The token's own escaping is only the first layer: the host's panel-URL writer
+ * serializes the whole `?panels=` value through `new URLSearchParams(...).toString()`,
+ * which escapes every `%` again (a uuid's `-` goes `-` → `%2D` → `%252D`, three
+ * characters becoming five). Measuring the token's spelling said 5,992 for a URL
+ * the browser carried at 7,416.
+ */
+declare function panelListValueBytes(items: readonly DetailRef[]): number;
+/**
+ * The length of the FINAL address a detail window's deep link produces: the path
+ * and query it is merged into, plus the `panels` parameter as
+ * `URLSearchParams` serializes it. What the budget is measured against, and what
+ * a guard can assert.
+ */
+declare function finalPanelUrlLength(pathAndQuery: string, tokenWithoutListArgs: string, listArgs: Record<string, string>): number;
+/**
+ * What the address a panel token is written INTO really costs, after
+ * `URLSearchParams` re-serializes it — a detail page's own `?l=` list carries raw
+ * commas that become `%2C` the moment a `panels` parameter is merged beside it,
+ * so the page's query grows by ~2× its comma count at the instant the window
+ * opens. Reserving the pre-serialization length is how a page + window address
+ * still overran the budget by 70 characters in the guard that found this.
+ */
+declare function panelUrlReserveBytes(pathAndQuery: string): number;
+/**
+ * The window's deep-link args for a list context — `{}` when there is no list.
+ * `max` is the resolved `ui.detail.list_context_max_ids`; the budget is the
+ * platform's REQUEST LINE, measured on the final serialized value, with whatever
+ * the rest of the address already costs reserved (NEW-19). A caller that knows
+ * the address it is writing into passes its length; one that does not gets the
+ * conservative reserve above, which is what a long detail-page query costs.
+ */
+declare function detailListToUrlArgs(list: DetailListContext | null | undefined, max: number, options?: {
+    reservedBytes?: number;
+}): Record<string, string>;
+/** The list a `?panels=detail:` token carries; `null` when it carries none. */
+declare function detailListFromUrlArgs(args: Record<string, string> | null | undefined): DetailListContext | null;
+/**
+ * 🚨 NEW-7 — CAPPED, ALWAYS. `max` is the resolved
+ * `ui.detail.list_context_max_ids` knob; the default is used when the host has
+ * no answer yet, never "no cap". A 500-row list uncapped produced a >20 KB href
+ * no server accepts (VERIFY-U-P1-R2).
+ *
+ * 🚨 NEW-19 (VERIFY-U-P1-R4) — AND THE BUDGET IS THE WHOLE URL'S. The path this
+ * query hangs off is part of the request line, so the caller passes what it
+ * costs (`reservedBytes`) and the list gets what is left. Measuring the list
+ * alone is how a detail page reached 8,464 characters while the code claimed a
+ * 2 KB margin.
+ */
+declare function encodeListQuery(list: DetailListContext | null | undefined, max?: number, options?: {
+    reservedBytes?: number;
+}): string;
+/** Inverse of `encodeListQuery`, from the three query values. */
+declare function decodeListQuery(l: string | null | undefined, i: string | null | undefined, 
+/** `lt` — the length of the list this window was cut from, when it was. */
+lt?: string | null | undefined): DetailListContext | null;
+
+/** Columns that are pure plumbing — hidden from a formatted field list. */
+declare const HIDDEN_FIELDS: Set<string>;
+declare function titleizeKey(key: string): string;
+declare function formatValue(value: unknown): {
+    text: string;
+    mono?: boolean;
+} | null;
+/**
+ * Every populated scalar column of a row as a field; a `<token>_id` column
+ * holding a real uuid becomes a door (the host decides which token names a
+ * registry entity — a wrong link is worse than no link).
+ */
+declare function fieldsFromRow(row: Record<string, unknown>, doors: {
+    tokenFromColumnName: (column: string) => string | null;
+    isUuidValue: (value: unknown) => value is string;
+}): DetailField[];
+declare function formatWhen(iso: string): string;
+
+export { DEFAULT_DETAIL_LIST_CONTEXT_MAX, DETAIL_LIST_CONTEXT_MAX_IDS_CEILING, DETAIL_LIST_CONTEXT_MAX_KNOB, DETAIL_PRESENTATIONS, DETAIL_PRESENTATION_BY_TYPE_KNOB, DETAIL_PRESENTATION_KNOB, DETAIL_URL_AS_ARG, DETAIL_URL_BUDGET_BYTES, DETAIL_URL_INDEX_ARG, DETAIL_URL_LIST_ARG, DETAIL_URL_LIST_TOTAL_ARG, DETAIL_URL_TYPE_KEY, type DetailField, type DetailFrameContext, type DetailHealthContext, type DetailHealthProducer, type DetailHistoryEntry, type DetailInstanceData, type DetailListContext, type DetailLoadResult, type DetailLoadState, type DetailOpenRequest, type DetailPresentation, type DetailRecordType, type DetailRef, type DetailRow, type DetailSection, type DetailSeed, type DetailSourceHealth, type DetailStatus, HIDDEN_FIELDS, type TrimListContextOptions, decodeListItems, decodeListQuery, decodePanelArgValue, decodeRefPart, detailInstanceKey, detailListContextMax, detailListFromUrlArgs, detailListToUrlArgs, encodeListItems, encodeListQuery, encodePanelArgValue, encodeRefPart, fieldsFromRow, finalPanelUrlLength, formatValue, formatWhen, isDetailPresentation, listQueryBytes, panelListValueBytes, panelUrlReserveBytes, parseDetailInstanceKey, presentationForTypeFromMap, presentationFromUrlArg, titleizeKey, trimListContext };