Ga naar hoofdinhoud

CnDetailPage

A generic detail/overview page component. The simpler counterpart to CnIndexPage — designed for pages that display statistics, charts, card grids, or other detail content without multi-object tables or CRUD dialogs.

Wraps: NcEmptyContent, NcLoadingIcon, NcButton (from @nextcloud/vue), CnIcon

Try it​

Loading CnDetailPage playground…

Props​

PropTypeDefaultDescription
titleString''Page title
titleTemplateString''A line the header names the record by, built from its fields (manifest config.titleTemplate, "Shift {floatAt|date}, {drawer}"), in the host's translation. Wins over titleField; a template with an empty field falls back to it.
cardButtonsString'compact'How tall the labelled buttons in the page's card title rows stand in the board look: compact (34px, setting and case-type pages) or regular (the 40px control height, as the case page's tab cards draw them, DqZaakContact "Live gesprek"). Manifest config.cardButtons.
gridFloatBooleantrueGridStack's float for the body grid (manifest config.gridFloat). True keeps every widget on its authored row; false packs widgets upward, so a size-to-content widget ends at its content and the one below closes up (DqHandhaving: the violation card sits 20px under the matrix).
descriptionString''Optional subtitle shown below the title
iconString''MDI icon name (rendered via CnIcon)
iconSizeNumber28Icon size in pixels
loadingBooleanfalseLoading state
loadingLabelString'Loading...'Message shown during loading
sidebarBoolean | ObjectfalseSidebar configuration. Accepts EITHER the legacy Boolean form (deprecated) OR the new Object form mirroring CnIndexPage.sidebar. See Sidebar config object below.
bandArray[]A row of widgets across the whole page, above the body and the side column (manifest config.band). Each entry is a widget id from widgets, a widget definition, or { widgetId, span, chrome }: span is the entry's share of the row in twelfths (default 12), and chrome is card or bare (a banner defaults to bare). Each entry follows its visibleWhen.
bandDensityString''The band's density (manifest config.bandDensity). compact (board look) keeps 12px between tiles and 20px between rows, lets a tile shrink to 120px and draws a stacked stat as a small white tile (13px label over a 20px value), as boards PqKlant and PqOrganisatie draw their figures.
pageFiltersArray[]Page-level filters (manifest config.pageFilters), as on a dashboard: each writes its choice into the page's workspace context, which the widgets read through @page.<key> / @workspace.<key>. Drawn in the band, above its widgets (PtPortal "Periode").
sidebarOpenBooleantrueWhether the sidebar starts open (only relevant when sidebar is active)
objectTypeString''Object type slug passed to the sidebar (e.g. 'pipelinq_lead'). Used by legacy direct mounts; manifest-driven detail pages prefer the register + schema pair below and let the page fuse them.
objectIdString|Number''Object ID passed to the sidebar and (in schema-driven mode) to objectStore.fetchObject.
registerString''Schema-driven mode — OpenRegister register slug. When paired with schema (and objectId), the page fuses them into an internal ${register}-${schema} object-type slug, registers it on the store, fetches the object + its schema via useObjectStore, and auto-renders CnObjectDataWidget + CnObjectMetadataWidget when the default slot is empty. objectType wins on collision so existing direct mounts stay untouched.
schemaString''Schema-driven mode — OpenRegister schema slug. See register.
entitySourceString''Name a registered entity source that reads ONE record, for a record that is not a register/schema object (manifest config.entitySource). The same registry and name as CnIndexPage's entitySource: organisations reads the OpenRegister organisation whose uuid is objectId (GET /apps/openregister/api/organisations/{uuid}). The record feeds the header, pills, header fields, widgets and the @objectId / @object.* tokens exactly as a fetched object does; its id is the uuid. Wins over register + schema. A 403 or 404 shows the not-found state; an unknown name shows no record and warns. Refresh and cn:page:refresh re-read the record.
sourceConfigObjectnullThe config of a record source that takes one (manifest config.sourceConfig). With entitySource: "endpoint" the record comes from an app's own endpoint: url is an app path with {id} for the record id (/apps/pipelinq/api/kassakoppeling/audit/{id}), read with the session so the endpoint does its own authorization, and recordPath names where the record sits in the answer (the whole answer by default). attach puts other parts of the answer on the record, by record key and answer path ({ "messages": "messages", "terms": "terms" } beside recordPath: "report"), so a widget such as conversation or facts reads them like any field; a path the answer does not hold is left out. A 403 or 404, or an answer without a record, shows the not-found state.
hideEmptyBooleanfalseHide valueless fields on the auto-rendered data widget (see CnObjectDataWidget's hide-empty). Set it from the manifest as config.hideEmpty for a discriminated supertype — one schema holding several variants, where each object only carries the fields its variant uses. A widget declaring its own content.hideEmpty still wins over this page-level default.
createFormString'auto'Create archetype switch (ADR-062). Whether this page renders its OWN create form dialog when reached without an object id. Set from the manifest as config.createForm. 'auto' (default) — heuristic: only when the page is schema-bound, has no object id, and supplies no body of its own (no default slot, no grid layout). 'never' — never render it; use when the body owns data entry (e.g. a CnObjectDataWidget or registry component already provides the form), which stops two form dialogs stacking. 'always' — render it even when the page has a body, for a page that deliberately pairs custom content with a create form. The dialog is always the generic schema-driven CnFormDialog, so it follows the same OpenRegister/schema form rules (required, readOnly, enum/$ref, visibleWhen).
includeFieldsArraynullFields the create and edit forms ask for, in this order. null asks for every property the schema declares. Same three keys as CnIndexPage, so one manifest describes the record's form wherever it opens rather than the list page and the detail page each carrying their own.
excludeFieldsArray[]Fields the create and edit forms never ask for. Applied after includeFields.
fieldOverridesObject{}Per-field widget / label overrides for the create and edit forms, keyed by field name. Forwarded to CnFormDialog.
sidebarTabsArray[]Tab definitions for the host App's CnObjectSidebar. Forwarded via the injected objectSidebarState; mirrors sidebar.tabs / sidebarProps.tabs but lives at the top level so the manifest's config.sidebarTabs flows in directly. Empty array → the consumer's CnObjectSidebar falls back to its default tab set.
sidebarPropsObject{}Extra sidebar configuration forwarded to CnObjectSidebar (register, schema, hiddenTabs, title, subtitle, tabs). Set sidebarProps.tabs to an open-enum tab array to drive the host app's mounted CnObjectSidebar from manifest.json — see CnObjectSidebar custom tabs. The array flows through the existing objectSidebarState provide/inject channel. Note: when both sidebar (Object) AND sidebarProps set the same field, the Object form wins and a console.warn lists the conflicting fields once per component instance.
errorBooleanfalseError state
errorMessageString'An error occurred'Message shown in error state
onRetryFunctionnullCallback for retry button in error state. If null, no retry button shown.
retryLabelString'Retry'Retry button text
notFoundRouteObject|StringnullRouter location of the not-found state's back button. null sends the user to /. CnPageRenderer fills it with the index page the record was opened from (_from), else the index page on the same register and schema.
notFoundRouteLabelString''Name of the notFoundRoute page, shown as "Back to {page}". Without it the button reads "Back to home".
emptyBooleanfalseEmpty state
emptyLabelString'No data available'Message shown in empty state
statsTitleString''Title above the statistics table
statsColumnsArray[]Column defs for stats table: [{ key: string, label: string, align?: 'left'|'center'|'right' }]
statsRowsArray[]Row data for stats table (objects keyed by column keys; set indent: true for sub-row styling)
maxWidthString'1200px'Maximum width of the page content
columnOptsObject | nullresponsive tableResponsive reflow for the body grid, measured against the grid's own width rather than the window's — so a page rendered in a narrow container (a split pane beside a list) reflows even though the viewport is wide. Defaults to a single threshold — the authored 12 columns above 1000px, one stacked column at or below it (columnMax: 12). There are deliberately no steps in between: moveScale rescales the authored geometry, so an intermediate count puts widgets at fractional positions nobody placed (a gridWidth: 3 tile becomes 1 of 4), which reads as a broken page rather than a narrow one. 1000px is where a gridWidth: 3 side panel drops under 250px — below its own title. With a side column (sideColumn) beside the grid, the default stacks at 600px of grid width instead, because the side column takes about 320px and the grid it leaves is narrow even on a wide page: a row of small tiles (a KPI row of 5 or 6 stat tiles at gridWidth: 2) stays a row at about 790px. A columnOpts you pass yourself is used as given. Pass null for a fixed 12-column grid at every size. Note this is not getDashboardColumnOpts(), which sets breakpointForWindow: true and so cannot see a narrow container.
lifecycleActionsObject | nullnullDeclarative lifecycle transitions. When set, lists status-gated transitions in the header Actions menu driven by the object's x-openregister-lifecycle. { field?: 'status' } fetches the allowed transitions live from OpenRegister's /available-actions endpoint; an explicit { transitions: [{ from, to, action, label, confirm?, variant? }] } is filtered client-side by the object's current state. See CnLifecycleActions.
inlineActionsNumber | nullnullSet to fold this page's own Edit button in with the header actions, so it becomes an entry in the Actions menu rather than a button beside it. null keeps Edit standalone. The number caps nothing here — this page draws its header actions as Actions-menu entries (display: "menu"), where there are no buttons to cap; it remains CnActionButtons' inline count for a host that mounts that component in buttons mode.
relatedCollectionsArray[]Declarative related-object list sections rendered below the detail body. Each entry { title?, register, schema, filter?, columns?, sort?, limit?, rowRoute? } renders a titled CnObjectListWidget scoped to this object via @objectId / @object.<field> tokens. See CnRelatedCollections.
summaryAggregatesArray[]Declarative cross-schema summary chips in the header. Each entry { label, register, schema, metric?, field?, filter?, format? } runs one count/sum/avg over a related schema scoped to this object. See CnSummaryAggregates.
relationLinksArray[]Declarative relation-link actions. Each entry { label?, register, schema, fkField, labelField?, allowCreate?, title?, selectLabel? } renders a button that opens a search-and-link modal which patches a foreign key on this object. See CnRelationLinkModal.
bodyWidgetsArray[]Declarative IN-BODY sections. Each entry { id?, component, title?, props?, placement?, colSpan?, card? } renders a REGISTERED host-app component as a titled section in the page body (not the sidebar), with the object/page context injected. component is a registry name resolved from the app's v2 registry (any kind exposing a .component, e.g. kind:"section" / kind:"widget") or the legacy customComponents map — no sidebar tab is required. props values are token-resolved (@objectId, @object.<field>, @workspace.<key>, @config.<key>; unset optional @…? tokens are dropped). placement is before-body | after-data | after-related | end (default end). colSpan (1–12) lays sections out on a grid when several share a placement. card: true draws the section in the same card as the grid's widgets. Instead of component, an entry may name a library widget type (handoff, facts, field-list, ...) with its content: it renders with the page's record, in the same placement and card. The loaded object + objectId are also provided on cnSectionContext so a host component can inject them instead of taking props; its setObject(object) puts an object the section saved into the page, so the rest of the page shows it without a re-fetch. A section whose component can't be resolved, or that throws while rendering, degrades to an inline error and never breaks the page. See CnBodySections.
appConfigObject{}Page-level app config exposed to declarative widget / section config via the @config.<key> token and provided on cnAppConfig. Lets a stat widget's format: { style: 'currency', currency: '@config.currency' } format with a configured value (e.g. the reporting currency a setup wizard captures) instead of a hard-coded EUR, and an endpoint KPI's URL / params + filter values interpolate @config.<key>. A manifest renderer typically seeds it from loadState(appId, 'config', {}). Backwards-compatible: a literal "EUR" still works, and an unset required @config.<key> falls back to the format default.
editConfirmLabelString''The edit form's save button (manifest config.editConfirmLabel), through the host translate. Empty keeps the form's own label.
editEyebrowString''One short line over the edit form's title (PqTicketBewerken "Bewerken · PQ-2026-0417"), run through the host translate. Like the title and subtitle it may name the record with {field} tokens. Empty shows none.
draftAppIdString''The app a form draft belongs to, forwarded to every form this page opens as CnFormDialog's draftAppId, so what a user typed and did not save is kept and offered back under this app's key (manifest config.draftAppId).
allowDraftBooleanfalseOffer "Save draft" on the create form, forwarded as CnFormDialog's allowDraft. On an edit form it is offered only while the record is still a draft (manifest config.allowDraft).
draftFieldString'isDraft'The boolean property that marks a record as a draft, CnFormDialog's draftField (manifest config.draftField).
headerActionsBelowBooleanfalseThe header buttons on a row of their own under the title (manifest config.headerActionsBelow), instead of beside it.

The action model​

A record page can carry forty actions in one menu, and then nobody finds the one they need. These keys put the actions on four levels. Each is opt in, so a page that sets none of them renders as before.

LevelWhereKey
1. The next stepOne primary button. Its label follows the record's stage.primaryActionByStage
2. Quick actionsAt most three buttons that are always visible.quickActions
quickActionsFromString''
3. The restThe overflow menu, in named groups.group on a header action
4. Admin actionsThe last group of that menu, for admins only.adminOnly on a header action
PropTypeDefaultDescription
primaryActionByStageObject | nullnullMap from a stage value to the page's primary action. A value is an action in the headerActions shape, or the id of a declared header action. A stage without an entry falls back to primaryAction. The action's primaryLabel (a headerMeta-style template such as "Call {phone}") is what the button says, filled from the record; it falls back to label.
stageFieldString'status'Dot-path to the field that holds the record's stage. Read by primaryActionByStage and nextStep.
quickActionsArray[]Always visible header buttons. At most three render. An entry is an action object or the id of a declared header action, which then leaves the menu. { id, tabs?, notTabs? } is a button only beside those body tabs and stays in the menu on the others.
actionsMenuObject | nullnull{ showRefresh?, showHelpLinks?, showMarkUnread?, showOpenSidebar?, label? }. showRefresh: false removes Refresh. showHelpLinks: false removes Request a feature, Report a bug and Documentation. showMarkUnread: false and showOpenSidebar: false remove those built-in entries (DqZaakMeer draws neither). label names the menu. In the board look each adminOnly entry carries a muted "admin" tag at the end of its row ("beheerder").
nextStepObject | nullnullThe "what now" card above the body: { field?, stagesFrom?, stages: { <stage>: { title?, checklist, after? } } }. stagesFrom is a field path read like a visibleWhen field (@context.caseType.nextStep): when it holds a stages map, or an object with stages, that map replaces stages for the record, so each case type keeps its own stage texts; otherwise stages stays. tabs / notTabs tie the card to body tabs as they do a side card. See CnNextStepCard.
typePillObject | nullnullA pill above the title: { field, colorMap?, labels?, variant?, resolve? }, rendered through CnStatusBadge. With resolve: { register, schema, labelField? } the field holds the id of a record of that schema, and the pill shows that record's label ("Woo-verzoek" for a case type uuid), looked up with the index tables' reference-label resolver; the label also keys colorMap.
statusPillObject | nullnullA second pill, same shape, for where the record stands. A pill's label can name the record's fields: "Version {version} published" reads "Version 4 published"; an empty field is left out.
headerFieldsArray[]Fields shown as chips under the title (manifest config.headerFields). Each entry is a property key, or { key, format, labelField, colorField, warnWhenPast }; format is text (default), mono, badge, user or date. A $ref value shows labelField of the referenced object and falls back to the raw id in mono; a badge maps colorField (success, warning, error, info, neutral) to a variant; warnWhenPast gives a past date the error variant. An empty value shows no chip, a page without the key shows no row. Each chip reads "Title: value" to a screen reader, and the row prints as plain text.
sideColumnArray[]A column of cards beside the body. An entry is a widget definition or the id of a widget in widgets. An entry with visibleWhen shows only while it holds for the record and the visibilityContext records, exactly as a grid widget (local fields, @context.<name>.*, endpoint and source conditions); edit mode shows them all. An entry with tabs (ids of the body's tabs widget tabs) shows only while one of those tabs is open, so the column follows the tab (DqZaaktypeVelden: the option list and the parent type beside Velden); edit mode shows them all.
sideColumnFromString''A field path, read like a visibleWhen field, whose value picks the side column and its order for this record, e.g. @context.caseType.sideCards. A non-empty list of ids keeps those sideColumn entries in that order and leaves the rest out; each still follows its own visibleWhen, and an id that names no entry is skipped. Any other value keeps sideColumn as declared; edit mode shows them all.
sideColumnOrderString'board'The side column's order in the board look. board puts a notice first and the History card last; declared keeps the order of sideColumn, for a board that draws History on top.
tabsFromString''A field path, read like a visibleWhen field, whose list of tab ids picks the tabs of the page's tabs widgets and their order for this record: @context.caseType.tabs reads the list a case type keeps (DqAanbesteding: Inschrijvingen, Publicaties, Bestanden, Historie). A tab's id is its id, else its widgetId, or the string entry. An empty or missing list keeps the declared tabs; edit mode shows them all.
verbEndpointsObjectnullApp routes that replace a record source's own route for a verb, by verb id (manifest config.verbEndpoints), such as { "complete": "/apps/dossiq/api/case-tasks/{id}/complete" } for an app that checks something of its own before the engine completes the task. {id} is the record id. Only read with entitySource. A record source's verbs are drawn as header buttons, or listed in the Actions menu when the source marks them menu. A verb with a form ({ schema, item, fieldOverrides? }) asks for values first: the page opens that form, sends only its fields to the source and redraws from the record the source keeps; a refusal shows in the form. The tasks source offers Edit this way on an open task, saving title, description, due date and priority through PATCH /api/flow-tasks/{uuid}, where the engine decides who may.
accessPurposeObjectnullAsk for a purpose before the record opens (manifest config.accessPurpose): { when, options, url, title?, description? }. when is a visibleWhen condition on the record and its visibilityContext records; options are the purposes offered ({ value, label }; "Other" with a written purpose is always added); url is the app endpoint that records the purpose (POST { purpose, note }, {objectId} filled in). Nothing of the record shows until the endpoint accepts, and the same record is not asked again in the same browser session. A refusal keeps the record closed. null asks nothing.
isAdminBoolean | nullnullWhether the viewer administers this instance, for adminOnly actions. null reads it from Nextcloud.

The next step follows the stage​

"config": {
"stageField": "status",
"primaryActionByStage": {
"ontvangen": { "id": "take-on", "label": "Take on", "type": "api-call", "method": "POST", "url": "/apps/dossiq/api/cases/@objectId/claim", "refresh": true },
"in_behandeling": "continue-review",
"besluit": "record-decision"
}
}

The button is dispatched the same way a header action is: the same dialogs, the same toast, the same visibleWhen. An action named by id leaves the menu while it is the button. The skip link at the top of the page lands on it. When the stage's action is hidden by its own visibleWhen, the page falls back to primaryAction.

Stage keys are matched exactly first, then ignoring case.

Quick actions​

"quickActions": ["message", "document", "log-contact"]

Keep them the same on every record of a type, so a handler finds them without looking. A fourth entry is dropped, and the manifest schema refuses it.

A tab can leave some out. Name the action by id with tabs (only beside these tabs) or notTabs (not beside these); on the other tabs it is in the Actions menu. nextStep takes the same two keys.

"quickActions": ["message", { "id": "document", "notTabs": ["ai-oversight"] }],
"nextStep": { "notTabs": ["ai-oversight"], "stagesFrom": "@context.caseType.nextStep" }

Groups and admin actions in the menu​

"headerActions": [
{ "id": "hand-over", "label": "Hand over to team", "type": "open-modal", "target": "HandOverDialog", "group": "Case" },
{ "id": "extend-term", "label": "Extend term", "type": "open-modal", "target": "ExtendTermDialog", "group": "Case" },
{ "id": "withdraw", "label": "Withdraw publication", "type": "api-call", "url": "/apps/dossiq/api/cases/@objectId/withdraw", "group": "Publication" },
{ "id": "raw-data", "label": "Raw data", "type": "open-modal", "target": "RawDataDialog", "adminOnly": true }
]

Ungrouped actions come first. Each group follows under a caption, in the order the groups first appear. adminOnly actions form the last group, titled "Administration", and only an instance admin sees them.

adminOnly hides a control. It does not protect anything: the endpoint behind the action decides who may call it.

"headerActions": [
{ "id": "connections", "label": "Add integration", "href": "/apps/integriq/connections?app=stackiq" },
{ "id": "guide", "label": "Integration guide", "href": "https://example.org/guide", "target": "_blank" }
]

An action with href is a real link (<a href>) in the Actions menu, and as a quick or primary action button, so it can be opened in a new tab or copied. An instance path (leading /) goes through generateUrl(), an absolute http(s), mailto:, tel: or //host/... URL is used as written. It opens in place unless target is "_blank", and it is never dispatched, so it carries no handler; as the primary button it emits no primary-action. The Actions menu lists top-level actions only, so a children[] entry does not render here, link or not. See CnIndexPage for the full rules.

"actionsMenu": { "showRefresh": false, "showHelpLinks": false, "label": "More" }

Use this when your app offers Request a feature, Report a bug and Documentation in its own help menu. The record's menu then holds the record's actions and nothing else. Leave a key out and that part stays as it is.

What now​

"nextStep": {
"stages": {
"in_behandeling": {
"title": "What now? Step 2: handling",
"after": "Then: step 3, decision",
"checklist": [
{ "label": "Confirm receipt to the resident", "doneField": "receiptConfirmedAt" },
{ "label": "Review the documents", "doneWhen": { "field": "openDocuments", "op": "eq", "value": 0 } },
{ "label": "Draft the decision", "doneField": "decision" }
]
}
}
}

The card renders above the body and the side column. While it shows, the primary button sits inside it, next to the checklist that explains it, and not in the header as well. A stage without an entry shows no card and the button stays in the header.

Pills above the title​

"typePill": { "field": "caseTypeName", "variant": "error" },
"statusPill": {
"field": "status",
"colorMap": { "ontvangen": "info", "in_behandeling": "primary", "afgehandeld": "success" },
"labels": { "ontvangen": "Received", "in_behandeling": "Handling", "afgehandeld": "Closed" }
}

colorMap is keyed on the raw value. labels maps a raw value to the text to show, and goes through the translate function. A pill whose field is empty does not render.

A pill does not need a field (schema 2.85.0, screens-relation-pages). text is a constant ("Inwoner", "Klant"). countFrom counts a related list with one list request and countLabel names the count; the pill does not render at 0, while counting or after a failed count:

"typePill": { "text": "Inwoner", "variant": "info" },
"statusPill": {
"countFrom": { "register": "my-register", "schema": "case", "filter": { "requester": "@objectId", "status": { "ne": "closed" } } },
"countLabel": { "one": "{count} lopende zaak", "other": "{count} lopende zaken" },
"variant": "purple"
}

The count is read again for another record and after a page refresh.

Side column​

"sideColumn": [
"case-term",
{ "type": "data", "title": "Handling", "content": { "include": ["assignee", "team", "startDate"], "columns": 1, "editable": false } },
"case-requester"
]

The column sits to the right of the body and holds facts: the deadline, the requester, the handler, the links. A string names a widget declared in the page's widgets, which is how a custom widget gets there. An object is a widget definition of its own.

The column drops under the body when the page is too narrow for both. That is decided by the room the page has, not by the viewport, so it also holds beside an open sidebar. A layout grid keeps working next to it.

A widget title that depends on the record​

A widget definition may carry titleWhen: [{ when?, text }]. The page resolves it against the record and its @context rows before the card, the tab strip or a leaf card reads the title: the first entry whose when holds becomes the plain title, an entry without when always holds, and while the record loads or no entry holds the written title stays. An empty text is a card without a title row. dossiq titles the case Files card "Documents for this request" on a case type that reviews its documents and draws it untitled on the others (DqZaakDocumenten, DqDocumentenBeheer):

{ "id": "case-files", "title": "Files", "titleWhen": [{ "when": { "field": "@context.caseType.documentReview.enabled", "op": "eq", "value": true }, "text": "Documents for this request" }, { "text": "" }] }

Widgets inside another widget's card​

content.leadWidgetIds names other widgets on the page that a widget's card draws inside itself, after its title row and before its own content, each without a card of its own and only while its own visibleWhen holds. dossiq draws the review summary ("4 van 7 beoordeeld") inside the case Files card (DqZaakDocumenten): "content": { "view": "tab", "leadWidgetIds": ["case-document-verdicts-card"] }, with the summary left out of the tab's own widgetIds so it does not draw twice.

content.trailWidgetIds does the same after the card's own content. dossiq ends the Zaakplan card with the case's goals (DqZaak): "content": { "trailWidgetIds": ["case-goals"] }.

A body widget's own cards in the side column​

A widget in the body can show cards about what is selected in it in the side column, in place of the generic side cards (DqDocumentenBeheer: Wie mag dit zien: <file> and "Controlegetal" while files are ticked). The page provides cnDetailSideColumn:

MemberMeaning
availableWhether the page draws a side column. Without one the widget keeps its cards where they were.
targetA selector for the slot at the top of the side column, to <Teleport> the cards to.
claim(owner, on)Start (true) or stop (false) showing cards there. While any owner claims, the generic side cards stand aside; they come back when the last one lets go. Release on unmount.

The record as a place​

These three are what make a record somewhere a handler stays, rather than somewhere they pass through. Each is off by default, so a page that declares none renders exactly as it does today.

PropTypeDefaultDescription
listNavigationObjectnullNext and previous within the list this record was opened from, as returned by useListNavigation. Shape: { available, isFirst, isLast, position, total }. Omit it and neither control renders, which is what a record reached by a bare link must do. In a manifest app CnPageRenderer passes it (with previousTo and nextTo) on a detail page that declares listNavigation: true, when it was opened from an index page on OpenRegister: the address names the list (_from) and its search, sort and filters.
previousToObject | StringnullRouter location of the previous record, as useListNavigation's previousRoute. When set, the previous control is a real link (middle-click and open in new tab work) and previous-record is emitted with { event, to } after the link navigated. null keeps it a button that only emits.
nextToObject | StringnullRouter location of the next record, as useListNavigation's nextRoute. Same behaviour as previousTo.
primaryActionObjectnullThe page's primary action, as declared on its manifest page. Renders as the header's primary button and is where the skip link lands. Shape: { id?, label, icon?, route?, href? }.
tabInAddressBooleanfalsePuts the active tab in the address as ?_tab=<id>, so a link points at a tab of this record rather than at the record.

Wire the navigation in the host, because the host owns the router:

const nav = reactive(useListNavigation({
route: useRoute(),
router: useRouter(),
currentId: toRef(props, 'objectId'),
objectType: 'case',
}))
<CnDetailPage
:listNavigation="nav"
:previousTo="nav.previousRoute"
:nextTo="nav.nextRoute"
:primaryAction="{ id: 'afhandelen', label: 'Zaak afhandelen' }"
tabInAddress
@next-record="nav.goNext"
@previous-record="nav.goPrevious" />

With previousTo and nextTo the two controls are links, so they can be opened in a new tab. The link navigates by itself; goNext and goPrevious see the { event, to } payload and do not push a second time, so keeping the listeners is safe.

Three refusals are deliberate. A record opened without list context offers no next and no previous, rather than inferring an order nobody chose. The first and the last record say so rather than wrapping. An address naming a tab that does not exist, or one this reader may not see, falls back to the first tab they can see and says so once.

The tabless address is corrected with replace, not push, so the back button does not walk into the address the reader was just moved off (ADR-052). Later tab changes push, so back and forward walk the tabs they actually visited.

Events​

EventPayloadDescription
editedobjectThe header Edit form saved successfully; payload is the saved record. Only fires when showEditAction is set.
transitioned{ action, to, object }A declarative lifecycle transition (from lifecycleActions) succeeded on this page's object.
relation-linkedobjectA relationLinks action patched a foreign key on this page's object; payload is the updated object.
related-row-click{ collection, row, index }A row in a relatedCollections section was clicked.
related-object-clickobjectAn object in the Related widget was clicked. Payload is the raw object; @self carries its register, schema and id. On a manifest page CnPageRenderer opens the matching detail page.
layout-changeArrayA widget in the body grid was dragged or resized in edit mode. Payload is the updated layout array. The sibling update:layout event fires with the same payload so an explicit-layout page can use :layout.sync.
widget-config-changeobject | nullA body-grid widget's config was saved via the cog editor (the widget def), or the widget was removed (null).
next-record{ event, to } | noneThe reader asked for the next record of the list this one was opened from. With nextTo set the link has navigated already and the payload is { event, to }; without it there is no payload and the host steps.
previous-record{ event, to } | noneThe reader asked for the previous record of that same list. Payload as next-record, keyed on previousTo.
primary-actionobjectThe declared primary action was pressed. Payload is the declaration.
tab-changestringThe active tab changed. Fires whether or not tabInAddress is set.

Slots​

SlotScopeDescription
#icon—Custom icon (replaces CnIcon)
#header-actions—Action buttons in the header (right side)
#translation-badge{ object }Replace the default CnTranslatedBadge rendered between the title and description when the resolved object's _translationMeta.translatedFrom is set. The badge auto-hides on source-of-truth objects, so consumers don't need to gate the slot. Introduced by the cn-detail-translation-aware-surfacing change.
#error—Custom error state content
#error-actions—Extra buttons inside the default error state
#not-found{ target }Replace the default not-found state. It shows instead of the header and body when the schema-driven fetch answers 404; target is the back button's router location.
#empty—Custom empty state content
#empty-actions—Extra buttons inside the default empty state
#stats-header—Custom header above the stats table (replaces default h3)
#stats-rows—Custom table body rows (replaces auto-generated rows)
#default—Main content below the stats table
#sections—Additional content below the default slot
#footer—Footer content (separated by a border)
#widget-{widgetId}{ item, widget }Per-widget slot in the body grid (name is widget-<widgetId>). Override the default render for one grid cell. item is the layout descriptor, widget the resolved definition.

The detail body is, at its core, a real drag/resize grid powered by CnDashboardGrid (GridStack):

  • Default body. In schema-driven mode (register + schema + objectId), once the object loads the body is seeded with two default widgets — a data widget (CnObjectDataWidget) and a related widget (CnRelatedObjectsWidget). Set showRelatedObjects: false to seed only the data widget.
  • Edit mode. When the page is in Buildiq edit mode (injected cnEditingBody), widgets can be dragged, resized and configured (the per-widget cog opens the registered config editor). Geometry changes emit layout-change / update:layout.
  • Explicit grid pages. Passing layout + widgets props (a manifest grid page) feeds the same engine, so hand-authored grid pages are draggable too. The default body is only synthesized when no explicit layout is supplied.
  • Widget types rendered by the grid: data, related, integration, and any registered content-driven catalog type (stat / chart / delta / gauge / object-list / …). A #widget-<widgetId> slot overrides any cell.
  • Field-scoped data widgets (ADR-062). A data widget's content accepts include (field whitelist) / exclude (blacklist), forwarded to CnObjectDataWidget — so one object can be presented as several purposeful data widgets ("Core case data" / "Process"), each sized to its field count. collapsedFields pins how many fields show before "Show all N fields"; left out, the widget keeps the whole rows that fit its cell.
  • Content-only catalog widgets get card chrome. object-list / table cells render on CnWidgetWrapper with the widget def's title (they have no chrome of their own); self-chromed catalog widgets (stat / chart / …) render bare, as before.
  • Cell-overflow dev warning (ADR-062: the cell is the budget). In non-production builds the page console.warns any grid cell whose rendered content is taller than its gridHeight — overflow is a design bug (enlarge the cell or scope the widget's content), never a scroll surface.

CnDetailPage.sidebar accepts EITHER form:

  • Boolean (legacy, deprecated) — :sidebar="true" activates the external CnObjectSidebar via the objectSidebarState inject; false deactivates. The first time this form is observed per component instance a one-shot console.warn fires pointing at the migration path.

  • Object (preferred) — mirrors CnIndexPage.sidebar plus detail-specific fields:

    sidebar: {
    show: true, // default true; false suppresses the sidebar
    enabled: true, // default true; false bypasses the external sidebar
    register: 'leads', // forwarded via objectSidebarState
    schema: 'lead',
    hiddenTabs: ['notes'],
    title: 'Lead detail',
    subtitle: '...',
    tabs: [ // see manifest-abstract-sidebar
    { id: 'overview', label: 'lead.overview', widgets: [{ type: 'data' }] },
    ],
    }

    Use show: false to hide the sidebar declaratively without removing the rest of the config (e.g. behind a feature flag or a responsive layout watcher).

Migrating from boolean​

Replace:

<CnDetailPage
:sidebar="true"
:sidebar-props="{ register: 'leads', schema: 'lead', tabs: [...] }"
object-type="lead"
:object-id="id" />

With:

<CnDetailPage
:sidebar="{ register: 'leads', schema: 'lead', tabs: [...] }"
object-type="lead"
:object-id="id" />

sidebarProps continues to work for backwards compatibility — when both sidebar (Object) and sidebarProps are set with overlapping fields, the Object form wins and a console.warn fires once per component instance listing the conflicting fields.

Manifest type:'detail' pages declare their sidebar tabs in config.sidebarTabs[] (the human-authored source of truth). Each entry has id + label (required), optional icon, order, component, _note. Widgets bound to a tab carry tabGroup: "<tab.id>" on slot:"sidebar" entries.

{
"id": "ZaakDetail",
"route": "/zaken/:id",
"type": "detail",
"title": "Case",
"config": {
"register": "zaakafhandelapp",
"schema": "zaak",
"sidebarTabs": [
{ "id": "overview", "label": "Overview", "order": 10 },
{ "id": "history", "label": "History", "order": 20, "icon": "icon-history" }
]
},
"widgets": [
{ "widgetKey": "data", "slot": "sidebar", "tabGroup": "overview", "gridX": 0, "gridY": 0, "gridWidth": 1, "gridHeight": 1 }
]
}

The validator checks two invariants:

  1. Tab shape — each sidebarTabs[] entry MUST have non-empty id + label; ids MUST be unique within the page.
  2. Cross-reference — every widgets[] entry with slot:"sidebar" and a tabGroup value MUST match a declared sidebarTabs[].id. Catches the silent-typo case where a tab-bound widget references a non-existent tab.

The CLI manifest-migrate transform lifts config.sidebarTabs[].widgets[] into top-level widgets[] with slot:"sidebar" + tabGroup at build time. Component-only tab entries (declaring only component) are carried forward in the residual sidebarTabs[] for runtime resolution against the customComponents registry.

Usage​

Basic detail page with statistics table​

<template>
<CnDetailPage
title="Register Overview"
description="Statistics for this register"
icon="DatabaseOutline"
:loading="loading"
:stats-title="'Register Statistics'"
:stats-columns="[
{ key: 'type', label: 'Type' },
{ key: 'total', label: 'Total' },
{ key: 'size', label: 'Size' },
]"
:stats-rows="[
{ type: 'Objects', total: 150, size: '2.4 MB' },
{ type: 'Invalid', total: 3, size: '-', indent: true },
{ type: 'Deleted', total: 7, size: '-', indent: true },
{ type: 'Files', total: 42, size: '1.1 MB' },
{ type: 'Logs', total: 230, size: '512 KB' },
]">
<div class="chart-grid">
<ChartCard title="Audit Trail"><LineChart :data="auditData" /></ChartCard>
<ChartCard title="Objects by Schema"><PieChart :data="schemaData" /></ChartCard>
</div>
<div class="card-grid">
<SchemaCard v-for="schema in schemas" :key="schema.id" :schema="schema" />
</div>
</CnDetailPage>
</template>

With error handling and retry​

<template>
<CnDetailPage
title="Schema Details"
:error="hasError"
error-message="Failed to load schema details"
:on-retry="loadSchema">
<template #error-actions>
<NcButton @click="$router.push('/registers')">
Back to Registers
</NcButton>
</template>
<DetailContent :schema="schema" />
</CnDetailPage>
</template>

Custom stats rows (manual table body)​

When the auto-generated rows from statsRows aren't flexible enough, use the #stats-rows slot to render your own <tr> elements:

<template>
<CnDetailPage
title="Register Stats"
:stats-columns="[
{ key: 'type', label: 'Type' },
{ key: 'total', label: 'Total' },
{ key: 'size', label: 'Size' },
]">
<template #stats-rows>
<tr>
<td>Objects</td>
<td>{{ stats.objects?.total || 0 }}</td>
<td>{{ formatBytes(stats.objects?.size || 0) }}</td>
</tr>
<tr class="cn-detail-page__stats-row--sub">
<td class="cn-detail-page__stats-cell--indented">Invalid</td>
<td>{{ stats.objects?.invalid || 0 }}</td>
<td>-</td>
</tr>
</template>
</CnDetailPage>
</template>

A record from an app endpoint​

A record that is not a register object (a report kept behind an app's own access check, an audit row) is still a type: "detail" page: entitySource: "endpoint" reads it from the app, and the widgets, header actions and side column work as on an object.

{
"id": "ReportDetail",
"route": "/reports/:id",
"type": "detail",
"config": {
"entitySource": "endpoint",
"sourceConfig": {
"url": "/apps/myapp/api/reports/{id}",
"recordPath": "report",
"attach": { "messages": "messages", "terms": "terms" }
},
"titleField": "summary",
"widgets": [
{ "id": "facts", "type": "facts", "content": { "fields": [{ "label": "Received", "path": "receivedAt", "format": "date" }] } },
{
"id": "thread",
"type": "conversation",
"content": {
"field": "messages",
"textField": "body",
"timeField": "writtenAt",
"sideField": "author",
"usValue": "handler",
"endpoint": "/apps/myapp/api/reports/@objectId/messages",
"messageKey": "body",
"replyOption": { "label": "Visible to the reporter", "key": "visibleToReporter", "value": false }
}
}
],
"headerActions": [
{
"id": "ask",
"label": "Ask to reveal the contact",
"type": "open-form",
"endpoint": { "url": "/apps/myapp/api/reports/@objectId/reveal-requests", "method": "POST" },
"formProperties": { "motivation": { "type": "string", "title": "Motivation", "format": "textarea" } }
}
]
}
}
  • The endpoint answers { report, messages, terms }: recordPath picks the record, and attach puts messages and terms on it, so the conversation widget reads messages as a field of the record.
  • The reply is posted to the widget's endpoint with the text under messageKey and the switch's state under its key; the page then reads the record again.
  • The endpoint does the access check. A 403 or 404 shows the not-found state.

Public (unauthenticated) detail pages​

pages[].config.mode: 'public' marks a detail route as unauthenticated — token-scoped reader pages like credential verification or shared-link views. Pair with the @route.<param> sentinel (see resolveRouteSentinels) for the token binding:

{
"id": "CredentialVerify",
"route": "/credentials/:token/verify",
"type": "detail",
"title": "Verify credential",
"config": {
"register": "scholiq",
"schema": "credential",
"mode": "public",
"filter": { "token": "@route.token" }
}
}

The schema's typed mode enum (edit | create | public) gives consumers IDE completion + sharp validator errors on typos. Today the manifest carries the intent — CnDetailPage does not yet branch on mode for auth-header bypass; the host app skips auth headers based on the route. A follow-up will wire native public-mode handling into the component so consumers don't have to coordinate auth-bypass externally.

When to use CnDetailPage vs other page components​

ComponentUse when...
CnDetailPageDisplaying detail info, stats tables, charts, card overviews — no multi-object CRUD
CnIndexPageListing objects with table/cards, pagination, search, mass actions, CRUD dialogs
CnDashboardPageBuilding a widget-based dashboard with drag-and-drop grid layout

Collaborative editing defaults​

CnDetailPage auto-subscribes to live updates for the current object. This wires useObjectSubscription into the page lifecycle so users see remote changes without polling — including remote pessimistic locks. The store it binds to resolves in two ways:

  1. Explicit objectStore prop (existing behaviour, unchanged) — pass your own store instance; the page subscribes when objectType/objectId (or register+schema+objectId) are known.
  2. Schema-driven / manifest mode — when register + schema are set and no objectStore prop is passed (the CnPageRenderer path), the page falls back to the library's default useObjectStore() — the same store its self-fetch uses — so manifest-driven detail pages get live updates with zero app-side wiring. Legacy objectType-only mounts without an explicit store keep today's behaviour (no subscription).

Live events are hints: the underlying liveUpdatesPlugin refetches the object (burst-coalesced, in-flight-deduped), the store cache updates, and the page re-renders reactively. When notify_push is unavailable the transport falls back to visibility-gated polling.

When the cached @self.locked block indicates another user holds the lock, CnDetailPage mounts CnLockedBanner above the content. The banner renders only when lockedByMe === false.

Opt-out props:

PropDefaultBehaviour
subscribetrueWhen false, skips the auto-subscribe (useful for read-only / archive views). From a manifest: pages[].config.subscribe: false.
objectStorenullPinia store instance. When set it always wins over the schema-driven fallback. When omitted and the page is not in schema-driven mode, both subscribe and lock-state are skipped.

See useObjectLock for the lock state contract; the lib does not yet auto-acquire on edit-mode toggle (planned for a follow-up cycle that wires the form dialogs).

Integration props (AD-19)​

PropTypeDefaultNotes
surfaceString'detail-page'Rendering surface forwarded to integration widgets in the grid layout (widget defs with type === 'integration'). Drives the AD-19 surface fallback.
integrationContext (integration-context)Object | nullnullObject context { register, schema, objectId } forwarded to integration widgets. When omitted it is derived from sidebarProps.register / sidebarProps.schema (or objectType) and objectId.

Built-in Actions menu​

The header carries the shared CnActionsMenu overflow … — Refresh, Documentation, and Request a feature — after any #actions slot content. Request-a-feature is on by default; Refresh is shown only when it will do something — showRefresh is tri-state (true/false force it; the default null is auto: shown when a consumer attached an @refresh listener or the page is in schema-driven mode and can self-fetch). A legacy objectType-mode page that never wires @refresh therefore shows no dead Refresh button. Force it with :show-refresh="true"/false; opt out of Request-a-feature with :show-request-feature="false".

  • Refresh emits @refresh and, unless the host calls event.preventDefault(), fires the cn:page:refresh event-bus channel with { widgetId, title }.
  • Documentation renders only when documentationUrl is set, opening it in a new tab.
  • Request a feature opens the forge's feature-request issue form with the detail:<id> surface as its English headline, when mounted under CnAppRoot.

Set :page-id for a stable id/surface (it otherwise falls back to a slugified title). All the menu props are forwarded to CnActionsMenu:

PropDefaultDescription
documentationUrl''When set, renders the Documentation entry (opens in a new tab).
documentationLabelt('Documentation')Pre-translated Documentation label.
specRef''Forwarded to the feature-request modal.
refreshingfalseWhile true, the Refresh item is disabled and shows a loading spinner for as long as this stays true (reflects the real refresh time).
refreshLabelt('Refresh')Pre-translated Refresh label.
requestFeatureLabelt('Request a feature')Pre-translated Request-a-feature label.
actionsMenuLabelt('Actions')Pre-translated overflow-menu trigger label.
SlotDescription
action-itemsExtra items appended inside the overflow menu, after the built-in trio.

Reference (auto-generated)​

The tables below are generated from the SFC source via vue-docgen-cli. They reflect what's actually in CnDetailPage.vue and update automatically whenever the component changes.

OpenRegister reliance​

heavy: this component cannot work without OpenRegister. 12 direct references, 229 files reached through imports.

Through: CnActionButtons, CnActionDialog, CnActionsMenu, CnAnalyticsReportPicker, CnAssignDialog, CnAuditTrailCard, CnBannerWidget, CnBookmarkPicker, CnBuildiqEditButton, CnBulkJobProgress, CnCalendarEventCreate, CnCalendarEventPicker, CnCellRenderer, CnChartWidget, CnChartWidgetForm, CnChecklistRunWidget, CnChildRecordsField, CnCollectivePageCreate, CnCollectivePagePicker, CnConflictResolveCard, CnContactPicker, CnCospendCreate, CnCospendPicker, CnCreateFormWidget, CnDataTable, CnDeckCardCreate, CnDeckCardPicker, CnDeltaWidgetForm, CnDetailWidgetHost, CnEmailPicker, CnEventsCard, CnExportsWidget, CnFactsWidget, CnFieldListWidget, CnFilesBrowser, CnFilesCard, CnFilesWidget, CnFkResolveCell, CnFlowDetail, CnFlowOperationPicker, CnFlowRunsWidget, CnFlowRunsWidgetForm, CnFormDialog, CnGaugeWidgetForm, CnGraphCanvas, CnIndexPage, CnIndexSidebar, CnIntegrationWidget, CnInteractionFormWidget, CnKbSearchWidget, CnMacrosWidget, CnMapPoiPicker, CnMapWidget, CnMapWidgetForm, CnMenuWidget, CnNavCardGrid, CnNoteComposer, CnNotesCard, CnObjectDataWidget, CnObjectFilesWidget, CnObjectGeoWidget, CnObjectLinksWidget, CnObjectListWidget, CnObjectListWidgetForm, CnObjectMetadataWidget, CnObjectPartiesWidget, CnObjectSidebar, CnOpenProjectCreate, CnOpenProjectPicker, CnPartyPicker, CnPhotoAlbumPicker, CnPlanWidget, CnPollPicker, CnRecordListWidget, CnRecordNotesWidget, CnRegisterSchemaSelect, CnRelatedFieldFilters, CnRelatedObjectsWidget, CnResourceSelect, CnRetentionWidget, CnSchemaFormDialog, CnSchemaRulesWidget, CnSettingsFormWidget, CnSlotGrid, CnStackedBarWidgetForm, CnStagesWidget, CnStagesWidgetForm, CnStatWidget, CnStatWidgetForm, CnStatsBlockWidget, CnStatsBlockWidgetForm, CnTabsWidget, CnTagsCard, CnTalkRoomPicker, CnTaskFormDialog, CnTasksCard, CnTasksWidget, CnTemplateSelect, CnTimeTrackerCreate, CnTimeTrackerPicker, CnTimelineWidget, CnTranslatedBadge, CnVersionHistory, CnWeekStripWidget, CnWeekStripWidgetForm, CnWidgetObjectTable, CnWorkingCalendarWidget, CnWorkspaceFilterWidget, CnXwikiPageCreate, CnXwikiPagePicker.

See the reliance overview for the filterable list.

Props​

NameTypeRequiredDefaultDescription
layout{ id: number, widgetId: string, gridX: number, gridY: number, gridWidth: number, gridHeight?: number, showTitle?: boolean }[][]Grid layout definition. Array of placement objects defining where each widget appears in the 12-column grid.
widgets{ id: string, title: string, type?: string }[][]Widget definitions. Array of widget objects with id and title.
columnsnumber12Number of grid columns.
viewsArray<{id: string, label: string, title?: string, icon?: string, widgets?: Array<object>, layout?: Array<object>, emptyText?: string}>[]Views of this page, each its own widget grid behind one segmented control. Each is { id, label, icon?, widgets, layout, emptyText? }: widgets and layout have the same shape as the page's own. The chosen view renders in a region below the page's own grid. Empty (the default) draws no switch and no region. A view's title is the page title while that view is open (on a dashboard).
defaultViewstring''The id of the view chosen when neither the address nor the browser store names one. Empty chooses the first view.
viewsLabelstring''Accessible name of the view switch (through the host translate function). Empty reads "View".
titlestring''Page title
gridFloatbooleantrueGridStack's float for the body grid (manifest config.gridFloat). True (the default) keeps every widget on its authored row; false packs widgets upward, so a size-to-content widget ends at its content and the one below closes up (DqHandhaving: the violation card sits 20px under the matrix).
cardButtonsstring'compact'How tall the labelled buttons in the page's card title rows stand in the board look: compact (34px, setting and case-type pages) or regular (the 40px control height, the case page's tab cards: DqZaakContact "Live gesprek"). Manifest config.cardButtons.
formSizestring'normal'NcDialog size for this page's create and edit form dialogs. CnFormDialog has taken a size since it shipped; this page never passed one, so both its forms were stuck at normal however many properties the schema declared.
formColumnsnumber1How many columns the create and edit forms flow their fields into. Pair 2 with formSize: 'large', or the two columns are merely two narrow ones. CnFormDialog collapses back to one column below 700px on its own, so this is safe on a narrow viewport.
draftAppIdstring''The app a form draft belongs to, forwarded to every form this page opens as CnFormDialog's draftAppId, so what a user typed and did not save is kept and offered back under this app's key.
allowDraftbooleanfalseOffer "Save draft" on the create form, forwarded as CnFormDialog's allowDraft. On an edit form it is offered only while the record is still a draft: saving a record that is already in use as a draft would take it out of use.
draftFieldstring'isDraft'The boolean property that marks a record as a draft (CnFormDialog's draftField).
includeFieldsarraynullFields the create and edit forms ask for, in this order. Null asks for every property the schema declares. Same three keys as CnIndexPage, so one manifest describes the record's form wherever it opens rather than the list page and the detail page each having their own.
excludeFieldsarray[]Fields the create and edit forms never ask for.
fieldOverridesobject\{\}Per-field widget / label overrides for the create and edit forms.
descriptionstring''Page description (shown below title)
iconstring''Optional MDI icon name (rendered via CnIcon)
iconSizenumber28Icon size in pixels
loadingbooleanfalseWhether the page is in a loading state
loadingLabelstring() =&gt; t('nextcloud-vue', 'Loading…')Message shown during loading
sidebarboolean &#124; object() =&gt; (\{ enabled: false \})Sidebar configuration. Accepts EITHER form: - Boolean (legacy, deprecated): true activates the external sidebar, false deactivates. The first time this form is observed per component instance a one-shot console.warn is logged pointing at the migration path. Continues to work in v1.x for back-compat. - Object (preferred): mirrors CnIndexPage.sidebar plus the detail-specific fields previously on sidebarProps: ts { show?: boolean, // default true; false suppresses sidebar enabled?: boolean, // default true; false bypasses external sidebar register?: string, schema?: string, hiddenTabs?: string[], title?: string, subtitle?: string, tabs?: Array&lt;TabDef&gt;, // see manifest-abstract-sidebar } When BOTH sidebar (Object) and sidebarProps are set with overlapping fields, the Object form wins and a console.warn lists the conflicting fields once per component instance.
sidebarOpenbooleanfalseInitial open state of the object sidebar when it first activates. Defaults to closed so the detail content fills the page; the user opens it on demand via the header sidebar-toggle (and the sidebar's own X closes it). After the first activation the open state is owned by the shared objectSidebarState channel (toggle / close), so this prop only seeds the initial value.
objectTypestring''The registered object type slug for the sidebar
objectIdstring&#124;number''The object ID to display in the sidebar
createFormstring'auto'Whether a schema-bound page without an object id shows an empty CnFormDialog for its schema instead of a blank page. Set from the manifest as config.createForm: - 'auto' (default) — heuristic: only when the page is schema-bound, has no object id, and supplies no body of its own (no default slot, no grid layout). Existing behaviour. - 'never' — never render it. Use when the body owns data entry, e.g. a page whose CnObjectDataWidget (or a registry component) already provides the form; this is what stops two form dialogs stacking. - 'always' — render it even when the page has a body, for a page that deliberately pairs custom content with a create form. The dialog itself is always the generic, schema-driven CnFormDialog, so whichever way it is summoned it follows the same OpenRegister/schema form rules (required, readOnly, enum/$ref, visibleWhen).
subtitlestring''Subtitle shown in the sidebar header
sidebarPropsobject\{\}Additional sidebar configuration (register, schema, hiddenTabs, title, subtitle)
surfacestring'detail-page'Rendering surface forwarded to integration widgets in the grid layout (widget defs with type === 'integration'). Drives the AD-19 surface fallback. Defaults to 'detail-page' — the surface this page represents.
integrationContextunionnullObject context forwarded to integration widgets: { register, schema, objectId }. When omitted it is derived from sidebarProps.register / sidebarProps.schema (or objectType) and objectId, so CnFilesCard etc. can fetch the right object's sub-resources without extra wiring.
errorbooleanfalseWhether the page is in an error state
errorMessagestring() =&gt; t('nextcloud-vue', 'An error occurred')Error message shown in error state
onRetryfuncnullCallback for retry button in error state. If null, no retry button is shown.
retryLabelstring() =&gt; t('nextcloud-vue', 'Retry')Label for the retry button
notFoundRouteobject&#124;stringnullRouter location the not-found state's button opens, shown when the schema-driven fetch answers 404. Usually the record's list; null sends the user to the app's root (/). CnPageRenderer fills it with the index page the record was opened from.
notFoundRouteLabelstring''Name of the notFoundRoute page, used in the button's "Back to …" label.
emptybooleanfalseWhether the page has no data to show
emptyLabelstring() =&gt; t('nextcloud-vue', 'No data available')Message shown when page is empty
statsTitlestring''Title shown above the statistics table
statsColumnsArray<{ key: string, label: string, align: string }>[]Column definitions for the statistics table. Each column: { key: string, label: string, align?: 'left'|'center'|'right' }
statsRowsArray<object>[]Row data for the statistics table. Each row is an object keyed by column keys. Set indent: true on a row for sub-row styling.
maxWidthstring'1800px'Maximum width of the page content
columnOptsunion\{ ...DEFAULT_DETAIL_COLUMN_OPTS \}Responsive columnOpts for the body grid, measured against the GRID's own width rather than the window's — so a page rendered in a narrow container (a split pane beside a list) reflows even though the viewport is wide. Defaults to a table that stacks to one column at or below 1000px. Pass null for a fixed 12-column grid at every size.
subscribebooleantrueWhether to auto-subscribe to live updates for this object. Defaults to true. The page calls store.subscribe(type, objectId) on mount and unsubscribes on unmount, against the explicit objectStore prop when passed, else (schema-driven / manifest mode: register + schema set) against the library's default useObjectStore(). Set false (manifest: config.subscribe: false) for read-only / archive views.
showRelatedObjectsbooleantrueWhether the schema-driven auto-body renders the related-objects widget beneath the data widget. Defaults to true (back-compat). Set false on a page that surfaces relations elsewhere (e.g. in the sidebar) to drop the "Related" section from the body.
objectStoreunionnullOptional explicit Pinia store instance to subscribe / lock against; always wins when passed. When omitted, a page in schema-driven mode (register + schema — the manifest renderer path) falls back to the library's default useObjectStore() so auto-subscribe still engages; the resolution is defensive so consumer apps that haven't activated Pinia yet (e.g. tests) don't crash.
entitySourcestring''Name of a registered entity source that reads ONE record (manifest config.entitySource), for a record that is not a register/schema object. The same registry and the same name as CnIndexPage's entitySource: organisations shows the OpenRegister organisation whose uuid is objectId. The record feeds the header, pills, facts, widgets and the @objectId / @object.* tokens exactly as a fetched object does. Wins over register + schema. Empty (the default) leaves the page on its object store.
sourceConfigunionnullThe config of a record source that needs one (manifest config.sourceConfig). With entitySource: "endpoint": url, an app path with {id} for the record id, and optional recordPath, where the record sits in the answer.
verbEndpointsunionnullApp routes that replace a record source's own route for a verb, by verb id (manifest config.verbEndpoints), such as { "complete": "/apps/dossiq/api/case-tasks/{id}/complete" } for an app that checks something of its own before the engine completes the task. {id} is the record id. Only read with entitySource.
registerstring''OpenRegister register slug. Pair with schema to opt into the schema-driven mode: the page fuses the two into an internal \$\{register}-\$\{schema} object-type slug, registers it on the store, fetches the object identified by objectId, and auto- renders CnObjectDataWidget + CnObjectMetadataWidget when no default-slot content is supplied. Compatible with the existing objectType prop — objectType wins on collision, so legacy direct mounts are unaffected.
schemastring''OpenRegister schema slug. See register for the schema-driven contract.
favouriteunionnullDeprecated and ignored: the star is gone, a favourite is a follow with notifications off (OpenRegister merge-follow-and-favourites). Kept so a manifest that still sets config.favourite stays valid; use follow.
followRow{presence?: boolean, count?: boolean}&#124;nullnullThe board look's follow row (manifest config.followRow): presence: true says who else has the record open now, with their initials, before the Follow control (DqZaak "Anouk Bakker kijkt nu ook naar deze zaak"); count: false draws no follower count.
followunionnullFollow toggle beside the title (manifest config.follow). Automatic (null): shown when the object carries @self.watching. false removes it, and the read then no longer asks for @self.can.
followNotifiesbooleantrueFalse when the register sends no change notifications to followers; the Follow tooltip then says so.
markReadbooleantrueSend PUT .../read-state once per page load after the object has rendered, when it carries @self.unread. false (manifest config.markRead: false) keeps the page from marking anything read.
markUnreadNavigatesBackbooleanfalseAfter Mark as unread, go back one step in the router history. Default: stay, and emit marked-unread.
extendstring[][]Extra _extend[] values for the object read (for markers OpenRegister returns only on request). @self.can is added whenever the Follow toggle can render.
permissionsbooleanfalseRead the record's rights (manifest config.permissions): the object read asks for @self.can, and while can.update is false the edit form, the header actions with role edit or update and the inline editors are off. A record without can keeps today's controls.
hideEmptybooleanfalseHide valueless fields on the auto-rendered data widget, instead of showing them with an em dash. See CnObjectDataWidget's hide-empty. Set this from the manifest (config.hideEmpty) for a discriminated supertype — one schema holding several variants, where each object only carries the fields its variant uses. A widget that declares its own content.hideEmpty still wins over this page-level default.
sidebarTabsArray<object>[]Tab definitions forwarded to the host App's CnObjectSidebar via the injected objectSidebarState. Each entry follows the CnObjectSidebar tab shape (see that component for the exact fields). When empty (default) the sidebar falls back to its own default tab set. The actual &lt;CnObjectSidebar&gt; is rendered at NcContent level by CnAppRoot (ADR-017 — external sidebar pattern); this page only publishes the tabs.
documentationUrlstring''Documentation link surfaced in the page-header Actions menu. When set, the menu renders a "Documentation" entry that opens this URL in a new tab. The Refresh and Request-a-feature entries render by default regardless of this value.
documentationLabelstring''Label for the Documentation entry in the header menu.
pageIdstring''Stable id for the page-header Actions menu — forwarded as the widgetId on the @refresh / cn:page:refresh payloads and as the surface: "detail:&lt;pageId&gt;" on the feature-request modal. Falls back to a slugified title when empty.
userLayoutbooleanfalseWhether the user arranges each view (views) for themselves. On, the header offers Arrange view next to the view switch; the arrangement is stored per view and per user (the server, mirrored in the browser) and a reset returns the view to its manifest layout. Off (the default), a view renders as the manifest says.
showRefreshunionnullWhether the Refresh entry renders in the page-header menu. Tri-state: - true / false — force it on or off. - null (the default) — auto: show Refresh only when it will do something, i.e. a consumer attached an @refresh listener OR the page is in schema-driven mode (register + schema + objectId) and can self-fetch. Legacy objectType-mode detail pages that never wire @refresh therefore show no dead button.
showEditActionbooleanfalseShow an Edit button in the header that opens the record's schema form. Needs register + schema + objectId to have something to edit; without them the button stays hidden however this is set. CnPageRenderer turns this on for every schema-bound type:"detail" page, which is the same set of pages whose index tables stop offering an edit modal — the two are one rule, and shipping either half alone would leave records with two edit surfaces or none.
editLabelstring''Label for the header Edit button, run through the host translate. Defaults to a translated "Edit".
editTitlestring''Title of the record edit form, run through the host translate. Empty uses the Edit button's label.
editSubtitlestring''One line under the edit form's title, run through the host translate. Empty shows none.
editEyebrowstring''One short line over the edit form's title (PqTicketBewerken "Bewerken · PQ-2026-0417"), run through the host translate. Like the title and subtitle it may name the record with {field} tokens. Empty shows none.
editConfirmLabelstring''The edit form's save button, run through the host translate. Empty keeps the form's own label.
editFootnotestring''A note the record edit form closes on, under its fields (PqTicketBewerken "De status wijzig je hier niet: ..."), run through the host translate. Empty shows none.
refreshingbooleanfalseWhether a header refresh is in flight. Disables the Refresh entry and swaps its icon for a spinner. Wire this to the same flag the host toggles around its @refresh handler.
showRequestFeaturebooleantrueWhether the Request-a-feature entry renders in the page-header menu.
showReportBugbooleantrueWhether the "Report a bug" entry renders in the page-header menu. On by default — the trio Request a feature / Report a bug / Documentation is the contract for every Conduction surface.
showDocumentationbooleantrueWhether the Documentation entry renders in the page-header menu. On by default; the shared menu resolves the target itself, so leaving it on costs the host nothing.
lifecycleActionsunionnullDeclarative lifecycle/transition actions (manifest config.lifecycleActions). When set, renders status-gated transition buttons in the page header driven by the object's x-openregister-lifecycle. Shape: { field?: 'status', transitions?: [{ from, to, action, label, confirm?, variant? }], autoFetch?: boolean }. With just { field: 'status' } the allowed transitions are fetched live from OpenRegister's /available-actions endpoint (server-authoritative). An explicit transitions array is filtered client-side by the object's current state. Omit (default null) to keep the current behaviour (no transition buttons). See CnLifecycleActions.
headerActionsArray<object>[]Declarative header actions (manifest config.headerActions, #91 Wave 3) rendered as items in the header's Actions menu via CnActionButtons — api-call (POST/PUT + toast + refresh), open-form, toggle, navigate / open-modal, each with an optional visibleWhen predicate. Distinct from lifecycleActions (state-machine transitions): these are free-form record actions (approve, send, archive). The page's object context drives @objectId / @object.&lt;field&gt; token + local-predicate resolution. Empty (the default) renders nothing. An entry with href is a link, never dispatched: an absolute http(s), mailto:, tel: or //host/... URL as written, or an instance path (leading /) through generateUrl(), opening in place unless target is '_blank'. The menu, not a row of buttons: that is what the manifest schema has always said this key is, and what CnIndexPage already does with it. The two surfaces had drifted, and on a dossiq case — twelve actions — the button row squeezed the record's own title to a truncated stub. Edit stays a button because it is the one action a handler reaches for on nearly every visit.
inlineActionsunionnullSet to fold this page's own Edit button in with the header actions, so it becomes an entry in the Actions menu instead of a button standing beside it. null (the default) keeps Edit standalone, so every existing consumer's header is unchanged. The number itself no longer caps anything HERE: this page draws its header actions as Actions-menu entries (display: "menu"), where there are no buttons to cap. It is still CnActionButtons' inline count for a host that mounts that component in buttons mode — see that component's inline prop.
relatedCollectionsArray<object>[]Declarative related-object list sections (manifest config.relatedCollections). Each entry renders a titled CnObjectListWidget below the detail body, filtered to this object via @objectId / @object.&lt;field&gt; tokens. Shape per entry: { title?, register, schema, filter?, columns?, sort?, limit?, rowRoute? }. Empty / omitted (default []) renders nothing. See CnRelatedCollections.
summaryAggregatesArray<object>[]Declarative cross-schema summary chips (manifest config.summaryAggregates). Each entry runs ONE count/sum/avg over a related schema scoped to this object and shows it as a stat chip in the header. Shape per entry: { label, register, schema, metric?, field?, filter?, format? }. Empty / omitted (default []) renders nothing. See CnSummaryAggregates.
relationLinksArray<object>[]Declarative relation-link actions (manifest config.relationLinks). Each entry renders a button that opens a search-and-link modal which patches a foreign-key field on THIS object with the chosen object's id. Shape per entry: { label?, register, schema, fkField, labelField?, allowCreate?, title?, selectLabel? }. Empty / omitted (default []) renders nothing.
bodyWidgetsArray<{id?: string, component: string, title?: string, props?: object, placement?: string, colSpan?: number}>[]Declarative IN-BODY sections (manifest config.bodyWidgets). Each entry renders a REGISTERED host-app component as a titled section in the page BODY (not the sidebar), with the object/page context injected. This is the primitive that lets a rich bespoke detail page (BRP panels, activity timelines, comms history, relationship graphs, bookings, …) become declarative while keeping its sections in the body. Shape per entry: { id?, component, title?, props?, placement?, colSpan? }. - component — registry name resolved from the app's v2 registry (any kind exposing a .component, e.g. kind:"section" or kind:"widget") or the legacy customComponents map. NO sidebar tab is required (unlike integration widgets). - props — values are token-resolved: @objectId → this object's id, @object.&lt;field&gt; → a field off it, @workspace.&lt;key&gt; → page context; unset @…? optional / unresolved tokens are dropped. - placement — before-body | after-data | after-related | end (default end). Controls where in the body the section lands. - colSpan — 1–12 grid span when sections share a placement. The loaded object + objectId are also provided on cnSectionContext so a host component can inject them instead of taking explicit props. Empty / omitted (default []) renders nothing. See CnBodySections.
createRoutestring''Vue-router route NAME to navigate to after a create-form save (the create archetype: a type:"detail" page whose route carries no :id). The created object's id is passed as the id route param. When empty (the default) the page navigates back in history after a successful create instead. See isCreateMode.
appConfigobject\{\}Page-level app config map exposed to declarative widget / section config via the @config.&lt;key&gt; token (e.g. the reporting currency the setup wizard captures). Provided to descendants on cnAppConfig, so a stat widget's format: { style: 'currency', currency: '@config.currency' } formats with the configured value (falling back to the literal default when unset). A manifest renderer typically seeds this from loadState(appId, 'config', {}). Empty (default) leaves every @config.&lt;key&gt; token to fall back to its literal default.
listNavigation{ available: boolean, isFirst: boolean, isLast: boolean, position: number, total: number }nullNext and previous within the list this record was opened from, as returned by useListNavigation. Omit it and neither control renders, which is what a record reached by a bare link must do: stepping through an order the reader never chose is worse than offering no step at all.
previousTounionnullRouter location of the previous record, as useListNavigation's previousRoute. When set, the previous control is a real link (middle-click, open in new tab) and previous-record is emitted with { event, to } after it navigated. Null keeps it a button.
nextTounionnullRouter location of the next record, as useListNavigation's nextRoute. Same behaviour as previousTo.
primaryAction{ id?: string, label: string, icon?: string, route?: string, href?: string }nullThe page's primary action, as declared on its manifest page. Renders as the header's primary button and is the target the skip link lands on. Omit it and neither renders.
tabInAddressbooleanfalsePuts the active tab in the address as ?_tab=&lt;id&gt;, so a link points at a tab of this record rather than at the record. Off by default, which leaves the address exactly as it is today.
primaryActionByStageunionnullThe primary action per stage (manifest config.primaryActionByStage): a map from a stage value to an action. When the record's stage has an entry, that action is the page's primary button, so the button names the next step: "Take on" on a new case, "Publish" on a decided one. An entry is an action object in the headerActions shape, or the id of a declared header action. A stage without an entry falls back to primaryAction.
stageFieldstring'status'Dot-path to the field that holds the record's stage. Read by primaryActionByStage and nextStep.
quickActionsunion[]Always visible buttons in the header (manifest config.quickActions) for the few actions a handler uses on every record. At most three render; later entries are dropped. An entry is an action object in the headerActions shape, or the id of a declared header action, which then leaves the Actions menu. { id, tabs?, notTabs? } names a declared action that is a button only beside those body tabs, as a side card follows them; elsewhere it stays in the Actions menu.
actionsMenu{showRefresh?: boolean, showHelpLinks?: boolean, showMarkUnread?: boolean, showOpenSidebar?: boolean, label?: string}&#124;nullnullWhat the Actions menu itself shows (manifest config.actionsMenu): { showRefresh?, showHelpLinks?, showMarkUnread?, showOpenSidebar?, label? }. showRefresh: false removes Refresh. showHelpLinks: false removes Request a feature, Report a bug and Documentation, for an app that offers them in its own help menu. showMarkUnread: false and showOpenSidebar: false remove those two built-in entries, for a menu the board draws without them (DqZaakMeer). label names the menu, for example "More". null (the default) changes nothing.
nextStepunionnullThe "what now" card (manifest config.nextStep): { field?, stagesFrom?, stages: { &lt;stage&gt;: { title?, checklist, after? } } }. Each checklist item is { label, doneField?, doneWhen?, hint? }. stagesFrom is a field path read like a visibleWhen field (@context.caseType.nextStep): when it holds a stages map (or an object with stages), that map replaces stages for this record, so a case type keeps its own stage texts. Otherwise stages stays. Rendered above the body for a stage that declares a checklist, with the primary button inside it. tabs / notTabs tie the card to body tabs as a side card. See CnNextStepCard.
typePill{field?: string, text?: string, countFrom?: object, countLabel?: object, colorMap?: object, labels?: object, variant?: string, resolve?: object, values?: Array<string>}&#124;nullnullA pill above the title saying what kind of record this is (manifest config.typePill): { field, colorMap?, labels?, variant? }. Rendered through CnStatusBadge; colorMap is keyed on the field's raw value, labels maps a raw value to the text to show. Instead of field: text, a constant ("Inwoner"), or countFrom ({ register, schema, filter? }) with countLabel ({ one, other } with {count}), a count of a related list ("1 lopende zaak") that shows nothing at 0. With resolve: { register, schema, labelField?, colorField?, iconField? } the pill shows the referenced record's label, takes its tone from that record's colour (an NL Design System hue such as red, or a badge role) and shows its icon. values draws a field pill only for those raw values (a priority pill for high and urgent only).
statusPill{field: string, colorMap?: object, labels?: object, variant?: string}&#124;nullnullA pill above the title saying where the record stands (manifest config.statusPill). Same shape as typePill.
headerFieldsArray<string&#124;{key: string, format?: string, labelField?: string, colorField?: string, warnWhenPast?: boolean}>[]Fields shown as chips under the title (manifest config.headerFields): each entry a property key, or { key, format, labelField, colorField, warnWhenPast }. format is text (default), mono, strong (bold text, no chip frame), badge, user or date. An empty value shows no chip; no row without chips.
showTypeEyebrowbooleantrueWhether the type eyebrow (the type label above the record name) renders once the record resolves. false (manifest config.showTypeEyebrow: false) drops it for a header that says the type in a pill instead.
breadcrumb{label: string, route?: string, params?: object, href?: string, icon?: string, currentField?: string, separator?: string}&#124;Array<object>&#124;nullnullA breadcrumb line above the header (manifest config.breadcrumb): { label, route?, params?, href? } names the list the record belongs to; the record's display name follows as the current crumb. label goes through the host translate function and shows as text; icon (an MDI name, e.g. Home) draws that icon instead, with the label as its accessible name. currentField names a field of the record (a dotted path, e.g. identifier) whose value is the current crumb instead of the display name; an empty value falls back to the display name. separator draws that text (e.g. /) between the crumbs instead of the chevron. Null (the default) draws no trail.
showWidgetActionsbooleannullWhether the record's widget cards (the body grid and the side column) keep their overflow Actions menu when their definition does not say (showActions). false (manifest config.showWidgetActions: false) drops it, as on a dashboard; a widget with showActions: true keeps its menu. A card that offers an Add action keeps the menu that holds it. When the key is not set it is true, and false under the board look.
tabsFromstring''A field path whose value picks the tabs of the page's tabs widgets and their order for this record (manifest config.tabsFrom), read like a visibleWhen field: @context.caseType.tabs reads the list a case type keeps. A non-empty list of tab ids (a tab's id, else its widgetId, or the string entry itself) keeps those tabs in that order and leaves the rest out. Any other value keeps the declared tabs. Edit mode shows them all.
sideColumnunion[]A column of cards beside the body (manifest config.sideColumn), for the record's facts: deadline, requester, handler, links. Each entry is a widget definition ({ id?, type, title?, content? }) or the id of a widget declared in widgets. The column stacks under the body on a narrow page. Empty (the default) leaves the layout as it is. An entry with tabs (tab ids of the body's tabs widget) shows only while one of those tabs is open (DqZaaktypeVelden: the option list beside Velden).
bandunion[]A row of widgets across the whole page, above the body and the side column (manifest config.band). Each entry is the id of a widget declared in widgets, a widget definition, or { widgetId, span, chrome }; span is the entry's share of the row in twelfths (default 12) and the row wraps; chrome is card or bare (a banner defaults to bare, anything else to card, so a widget that draws its own card, such as a KPI, asks for bare). Each entry follows its visibleWhen. Empty (the default) draws no band.
bandDensitystring''The band's density (manifest config.bandDensity). compact draws it as boards PqKlant and PqOrganisatie do: 12px between tiles, 20px between rows, tiles down to 120px, and a figure as a small white tile (13px label over a 20px value). Empty keeps the default band.
pageFiltersunion[]Page-level filters (manifest config.pageFilters), the same a dashboard takes: each writes its choice into the page's workspace context, which every widget on the page reads through @page.&lt;key&gt; / @workspace.&lt;key&gt;. Drawn in the band, above its widgets (PtPortal "Periode").
sideColumnFromstring''A field path whose value picks the side column and its order for this record (manifest config.sideColumnFrom), read like a visibleWhen field: @context.caseType.sideCards reads the list a case type keeps. A non-empty list of ids keeps those sideColumn entries, in that order, and leaves the rest out; each still follows its own visibleWhen. Any other value keeps sideColumn as declared, so a record whose list is empty changes nothing.
sideColumnOrderstring'board'The side column's order in the board look (manifest config.sideColumnOrder): board puts a notice first and the History card last; declared keeps the order of sideColumn, for a board that draws History on top. A list the record picks (sideColumnFrom) keeps its own order either way.
quickActionsFromstring''A field path, read like a visibleWhen field, whose list of declared header action ids picks this record's quick actions (manifest config.quickActionsFrom, e.g. @context.caseType.quickActions). Only ids of headerActions are taken, so the record's data never defines an action. An empty or missing list keeps quickActions.
headerCardbooleanfalseDraw the header as a card (manifest config.headerCard: true): the pills, the title and the actions on the page's surface colour inside a bordered, rounded box, as the board's case header. Off by default, which keeps the header on the page ground.
headerActionsBelowbooleanfalseThe header buttons on a row of their own under the title (manifest config.headerActionsBelow), as board PqLead draws them, instead of beside it.
headerWidgetstring''The id of a widget declared in widgets to render inside the header, on its own row under the title and the actions (manifest config.headerWidget), e.g. the stages bars. It renders without a card of its own and leaves the body grid. Empty (the default), or an id that names no widget, renders nothing extra.
visibilityContextobject\{\}Records the page reads beside the loaded one, so a visibleWhen can ask about them (manifest config.visibilityContext). Each entry is { &lt;name&gt;: { field, register, schema } }: field is the property of the loaded record holding the other record's id, and a condition reads that record as @context.&lt;name&gt;.&lt;path&gt;. A case page that declares { caseType: { field: "caseType", register: "dossiq", schema: "caseType" } } can show a widget for some case types only with { field: "@context.caseType.category", op: "in", value: [...] }. A record that cannot be read is absent, so its condition fails safe. Empty (the default) reads nothing extra.
accessPurposeunionnullAsk why the reader opens the record before the page shows it, and record the answer (manifest config.accessPurpose). { when, options, url, title?, description? }: when is a condition in the visibleWhen grammar on the record and its visibilityContext records (DqSociaalDomein: the case type lists special categories of personal data); options the purposes offered ({ value, label }, "Other" with a written purpose is always added); url the app endpoint that records the purpose (POST { purpose, note }, {objectId} filled in). The page shows nothing of the record until the endpoint accepts, and does not ask again for the same record in the same browser session. A refusal keeps the record closed. null (the default) asks nothing. checkUrl (GET, {objectId} filled in) is asked first: an answer { required: false } opens the record without the dialog (the app recorded the purpose itself, as for the case's own handler); any other answer, or a failure, shows the dialog. An option's hint is a line under it saying what choosing it does besides recording it.
isAdminunionnullWhether the current user administers this instance. Shows the adminOnly header actions. null (the default) reads it from getCurrentUser(). Visibility only, never an authorization decision: the endpoint behind an action decides who may call it.
lookstring''The look this page is drawn in (nextcloud or board). Empty (the default) takes the app's look, which CnAppRoot or CnPageRenderer provides, so a manifest's look reaches the page without a prop.
headerMetastring&#124;object''The meta line on row 2 of the board look's header (manifest config.headerMeta): a field template such as "via {channel}". Every {path} is read from the record (an enum field as its label); {path|format} formats it (weekday, longdate, time, user, currency:EUR, ...). An empty token drops itself and its separator; a line with no value at all is dropped. Only the board look draws it. { count, one, other, zero? } picks a form by the headerMetaCounts total named count ("1 lopende zaak" / "2 lopende zaken"); each form is translated on its own, and zero (when given) is used for none.
headerMetaWhenarray[]Header lines that depend on the record (manifest config.headerMetaWhen): [{ when, text }], a local visibleWhen condition on the record and a template like headerMeta's. The first entry whose condition holds replaces headerMeta; none leaves it. PqOfferte: "not sent yet" on a draft.
headerMetaCountsRecord<string, object>&#124;nullnullThe lists headerMeta counts (manifest config.headerMetaCounts), as on a list page: { &lt;name&gt;: { register, schema, filter? } | { entitySource } }, each read as one total and filled in for {count:&lt;name&gt;} ("een van {count:organisations} organisaties op deze omgeving", DqTenant). While a count loads, or when it fails, the line is left out.
headerMetaLastChangebooleanfalseRead the record's newest create or update entry from its audit trail and offer it to headerMeta as {_lastChange.userName}, {_lastChange.user|user} and {_lastChange.created|date} ("laatst gewijzigd 2 okt door Lars de Koning", DqZaaktype). A record does not say who changed it last; its trail does. A trail that cannot be read leaves the tokens empty.
recordLastChangebooleanfalseRead the record's newest create or update entry (as headerMetaLastChange does) for the widgets on the page: a facts card reads it as _lastChange.userName / _lastChange.created ("Laatst gewijzigd op 3 oktober door Pieter Jansen", DqContact "Historie"). headerMetaLastChange provides it as well.
tabsLabelstring''The accessible name of the tab list under the board look (manifest config.tabsLabel). Empty gives "<type> parts", for example "Case parts", from the page title.
identifierFieldstring''The field holding the record's identifier (manifest config.identifierField, for example identifier). Under the board look the side column's History card ends with a line naming it.
titleFieldstring''The record field the header names the record by (manifest config.titleField, a dotted path such as number), as an invoice page names the invoice number. An empty value falls back to the display name. Empty (the default) changes nothing.
titleTemplatestring''A line the header names the record by, built from its fields (manifest config.titleTemplate, "Shift {floatAt|date}, {drawer}"), in the host's translation. Wins over titleField; a template with an empty field falls back to it.

Events​

NamePayloadDescription
page-filter-change—Emitted when a page-level filter selection changes.
view-layout-change—Emitted when a widget in a view's grid is dragged or resized.
view-layout-reset—Emitted when the user drops their arrangement of a view and it returns to the manifest layout.
create-cancel—Emitted when the create form is dismissed.
created—Emitted after a successful create-form save.
edited—Emitted after the record edit form saves successfully.
geo-saved—The object's @self.geo was saved via the geo widget. Payload is the saved geo value (GeoJSON Point or null).
layout-change—Emitted when a body-grid widget is dragged or resized. Payload is the updated layout array.
marked-unread—Emitted after the record was marked unread; the page stays open unless markUnreadNavigatesBack.
open-integration—A related-objects "Linked apps" row was clicked on the auto-body. Payload is the leaf id.
refreshundefinedThe page-header Refresh action was clicked.
related-object-click—An object in the Related widget was clicked. Payload is the raw object; @self carries its register, schema and id.
related-row-click—A row in a relatedCollections section was clicked. Payload is { collection, row, index }.
relation-linked—A relation-link action patched a foreign key on this page's object. Payload is the updated object.
request-featureundefinedThe page-header Request-a-feature action was clicked.
transitioned—A declarative lifecycle transition succeeded on this page's object. Payload is { action, to, object }.
update:layout—Sibling of layout-change so v-model:layout consumers stay in sync.
widget-config-change—Emitted after a grid widget's config is saved via the cog editor, or after the widget is removed (payload null). Consumers persist the updated page/widget config.
next-record—The reader asked for the next record of the list this one was opened from. The host steps, because the host owns the router. With nextTo set the link has navigated already and the payload is { event, to }.
previous-record—The reader asked for the previous record of that same list. Payload as next-record.
primary-action—The page's declared primary action was pressed. Payload is the declaration.
tab-change—The active tab changed. Payload is the tab id. Emitted whether or not tabInAddress is set, so a host may mirror it somewhere else.

Slots​

NameBindingsDescription
headertitle, description, icon, iconSizeheader
icon—icon
translation-badgeobjecttranslation-badge
actionsobject, objectId, schema, objectType, store, openEditForm, canEditRecord, canactions
widget-${headerWidgetDef.id}name, item, widget, objectId, object, objectData, objectType, register, schemawidget-\$\{headerWidgetDef.id}
widget-${entry.widget.id}name, item, widget, objectId, object, objectData, objectType, register, schemawidget-\$\{widget.id}
not-foundtargetnot-found
error—error
error-actions—error-actions
empty—empty
empty-actions—empty-actions
before-bodyobject, schema, objectType, objectId, storebefore-body
widget-${item.widgetId}name, item, widget, objectId, object, objectData, objectType, register, schemawidget-\$\{item.widgetId}
stats-header—stats-header
stats-rows—stats-rows
default—default
sections—sections
footer—footer
widget-${widget.id}name, item, widget, objectId, object, objectData, objectType, register, schemawidget-\$\{widget.id}
form-dialogshow, item, schema, confirm, closeform-dialog Replace the built-in create/edit form dialog (use CnFormDialog or CnAdvancedFormDialog). Deliberately the SAME slot name and the same scope as CnIndexPage's form-dialog, so one replacement component serves both pages and an app author learns one contract, not two. Covers both of this page's built-in dialogs — the create archetype's empty form and the record edit form — which are mutually exclusive, exactly as CnIndexPage's single slot covers create and edit.

Additional props​

PropTypeDefaultDescription
showRelatedObjectsBooleantrueWhether to render the Related section beneath the data widget. Set false on pages that surface relations elsewhere (e.g. the sidebar) to drop the section.
createRouteString | Object''Route pushed when the page's "create" action fires (empty disables it).
showEditActionBooleanfalseShow an Edit button in the header that opens the record's schema form (CnFormDialog) scoped to this record, saving through the object store and emitting @edited. Needs register + schema + objectId; hidden without them. CnPageRenderer sets it for every schema-bound type:"detail" page — the same set of records whose index tables stop offering an edit modal. Declare config.showEditAction: false to keep a detail page read-only.
formSize (form-size)String'normal'NcDialog size for this page's create and edit form dialogs ('small', 'normal', 'large'). Set from the manifest as config.formSize. Before 2.44.0 the page passed no size, so both forms sat at normal however many properties the schema declared, while a manifest open-form header action could already ask for large.
formColumns (form-columns)Number1How many columns the create and edit forms flow their fields into (1 or 2). Pair 2 with formSize: 'large', or the two columns are merely two narrow ones. Textareas and JSON editors still span both, and the layout collapses back to one column below 700px. Set from the manifest as config.formColumns.
editLabelString''Label for the header Edit button. Defaults to a translated "Edit".
editTitleString''Title of the record edit form, run through the host translate. Empty uses the Edit button's label.
editSubtitleString''One line under the edit form's title, run through the host translate. Empty shows none.
editFootnoteString''A note under the edit form's fields (manifest config.editFootnote), run through the host translate and passed to the form as its footnote. Empty shows none.

Widget icons (ADR-062)​

Every config.widgets[] def may carry icon (an MDI component name, e.g. "CheckboxMarkedOutline"). Data widgets forward it to their card header via CnIcon; content-only catalog widgets (object-list / table) render it in their CnWidgetWrapper title. Together with the shared var(--border-radius-large, 8px) card radius this keeps all detail-page widgets in one visual family.

Header actions menu​

The page header's overflow menu carries Refresh plus the mandatory trio Request a feature / Report a bug / Documentation. showReportBug and showDocumentation (both true by default) exist for a surface that must suppress one deliberately; the shared menu resolves each target itself, so leaving them on costs nothing. The Documentation entry deep-links to this page's own section using the page id as its anchor.

Type eyebrow and breadcrumb​

PropTypeDefaultDescription
showTypeEyebrowBooleantruefalse (manifest config.showTypeEyebrow: false) drops the type label above the record name once the record resolves, for a header that says the type in a pill instead.
breadcrumbObject | nullnullA breadcrumb line above the header (manifest config.breadcrumb): { label, route?, params?, href? } names the list the record belongs to; the record's display name follows as the current crumb. The label goes through the host translate function.
"config": { "showTypeEyebrow": false, "breadcrumb": { "label": "All cases", "route": "Cases" } }

A breadcrumb's label shows as text. breadcrumb.icon (an MDI name such as Home) draws that icon as the first crumb instead, with the label as its accessible name.

Views behind a switch (views)​

A detail page can offer a few views of a record, each its own widget grid, behind a segmented control in the page header. The chosen view renders in a region below the body grid. The props are the same as on CnDashboardPage: views, defaultView and viewsLabel.

  • Each view is { id, label, icon?, emptyText?, widgets, layout }. widgets and layout have the same shape as the page's own and render with the same grid.
  • The page's own widgets and layout stay above the region. Choosing a view swaps only the region.
  • The chosen view is in the address (?view=<id>, so a link opens it) and in the user's preferences (the app's preferences endpoint, mirrored in the browser). The address wins, then the stored choice, then defaultView, then the first view.
  • The switch is a radio group named by viewsLabel (default "View"). Every option carries aria-controls pointing at the region, a region landmark named after the chosen view. Arrow keys, Home and End move the choice and focus stays on the switch.
  • A view with nothing to draw shows its emptyText, else "This view has no widgets yet.", never a blank area.
  • On a detail page, views replace the automatic Data and Related body. Put a data widget in a view, or in the page's own layout, to keep it.
  • The stored choice is kept per page (its pageId, else its route name), not per record.
{
"id": "CaseDetail", "type": "detail", "route": "/cases/:id",
"config": {
"register": "dossiq", "schema": "case",
"viewsLabel": "Case view",
"views": [
{ "id": "overview", "label": "Overview",
"widgets": [{ "id": "case-data", "type": "data", "title": "Details" }],
"layout": [{ "id": "o1", "widgetId": "case-data", "gridX": 0, "gridY": 0, "gridWidth": 12, "gridHeight": 6 }] },
{ "id": "documents", "label": "Documents",
"widgets": [{ "id": "case-files", "type": "files", "title": "Documents" }],
"layout": [{ "id": "d1", "widgetId": "case-files", "gridX": 0, "gridY": 0, "gridWidth": 12, "gridHeight": 6 }] }
]
}
}

Each view arranged per user (userLayout)​

Deprecated: layout belongs to Buildiq. Arranging a page is Buildiq's job (Ruben, 18 Oct 2026): its Indeling aanpassen edits the layout everybody sees. userLayout still works for this release and will be removed after it. While Buildiq edits the page (cnEditingBody), the grid shows the manifest layout, and a drag or resize goes into the manifest Buildiq saves, also on a page with userLayout. A user arrangement made outside an in-page edit session is saved at once, because no Done follows to save it.

With config.userLayout: true the header shows Arrange view next to the view switch. While it is on, the chosen view's grid is draggable. Done stores the arrangement for that view and user (a user preference under dashboard-layout.<page>.view.<view>, on the server and mirrored in the browser), and the next visit opens with it. Reset view returns the chosen view to its manifest layout and emits view-layout-reset with { view }; other views keep theirs. The manifest layout is never changed by a user, and the page's own body grid is not affected.

"config": { "register": "dossiq", "schema": "case", "userLayout": true, "views": [ ... ] }

Header card and header widget​

PropTypeDefaultDescription
headerCardBooleanfalseDraws the header (pills, title, actions) as a bordered card on the surface colour (manifest config.headerCard), as the board's case header. Theme hooks: --cn-detail-header-card-padding (22px 24px), --cn-detail-header-card-radius (12px), --cn-detail-header-row-gap (22px).
headerWidgetString''The id of a widget in widgets to render inside the header, on its own row under the title and the actions, without a card of its own (manifest config.headerWidget). The widget leaves the body grid and its row closes up. An id that names no widget renders nothing extra.
"config": {
"headerCard": true,
"headerWidget": "case-stages",
"breadcrumb": { "label": "All cases", "route": "Cases" }
}

Blocks such as favourites, follow and attention are placed with the layout you already have: a layout entry's gridY puts one under the tabs, and sideColumn takes its widget id.

Widgets per record: visibleWhen and visibilityContext​

A widget in widgets that carries visibleWhen is drawn only while the condition holds for the loaded record. It is the same grammar as everywhere else (field, op, value, all, any, endpoint, source). A widget without visibleWhen renders as before. While the record loads, a conditional widget stays out of the grid, so it never shows and then vanishes. In edit mode every widget stays visible.

visibilityContext (manifest config.visibilityContext) names records the page reads beside the loaded one. Each entry is { field, register, schema }, where field is the property holding the other record's id. A condition reads that record as @context.<name>.<path>, in the grid and in a tabs widget's tab conditions. A record that cannot be read is absent, so its condition fails safe.

PropTypeDefaultDescription
visibilityContextObject{}{ <name>: { field, register, schema } }: the records conditions read as @context.<name>.
"config": {
"visibilityContext": { "caseType": { "field": "caseType", "register": "dossiq", "schema": "caseType" } },
"widgets": [
{ "id": "family-plan", "type": "family-plan", "title": "Family plan",
"visibleWhen": { "field": "@context.caseType.category", "op": "in", "value": ["Sociaal domein"] } }
]
}

Side cards per record: sideColumnFrom​

sideColumnFrom (manifest config.sideColumnFrom) lets the record decide which side cards it shows and in what order. It is a field path read like a visibleWhen field, so it can read a visibilityContext record: a case page reads the list its case type keeps. When the value is a non-empty list of ids, the side column is those sideColumn entries in that order; an id that names no entry is skipped, and each card still follows its own visibleWhen. Any other value, or none, keeps sideColumn as declared, so a case type that lists nothing shows the usual column.

"config": {
"visibilityContext": { "caseType": { "field": "caseType", "register": "dossiq", "schema": "caseType" } },
"sideColumn": ["deadline", "requester", "handling", "consent", "people"],
"sideColumnFrom": "@context.caseType.sideCards"
}

A case type with "sideCards": ["consent", "people", "deadline"] shows those three cards, in that order; one without sideCards shows all five.

  • config.breadcrumb.currentField (a dotted field path, e.g. identifier) makes the current crumb that field's value instead of the display name; an empty value falls back to the display name. config.breadcrumb.separator draws that text (e.g. /) between the crumbs instead of the chevron.
  • config.breadcrumb may be a list of crumbs for a record that sits more than one level deep: [{ "label": "Settings", "href": "..." }, { "label": "Case types", "route": "CaseTypes" }] reads "Settings / Case types / Omgevingsvergunning regulier". currentField and separator may sit on any crumb of the list.
  • config.headerMetaWhen ([{ when, text }]) makes the meta line depend on the record: the first entry whose local visibleWhen condition holds replaces headerMeta, and none leaves it. PqOfferte reads "not sent yet · prices excl. VAT" on a draft ({ "when": { "field": "status", "value": "draft" }, "text": "not sent yet · prices excl. VAT" }).
  • config.headerMetaCounts ({ <name>: { register, schema, filter? } | { entitySource } }) lets headerMeta count a list as {count:<name>}, as on a list page: "een van {count:organisations} organisaties op deze omgeving" (DqTenant). While a count is missing the line is left out.
  • config.headerMetaLastChange: true reads the record's newest create or update entry from its audit trail and offers it to headerMeta as {_lastChange.userName}, {_lastChange.user|user} and {_lastChange.created|date}: "last changed {_lastChange.created|date} by {_lastChange.userName}" (DqZaaktype). A trail that cannot be read leaves the tokens empty.
  • config.recordLastChange: true reads that same entry for the widgets on the page (provided as cnRecordLastChange; headerMetaLastChange provides it too). A facts card reads it as _lastChange.userName and _lastChange.created: "Last changed on {date} by {user}" (DqContact, DqOrganisatie "Historie").
  • showWidgetActions (manifest config.showWidgetActions, default true): false drops the overflow Actions menu from the cards of the body grid and the side column, unless a widget definition sets showActions: true. A definition with showActions: false drops its menu either way. A catalog card that offers an Add action keeps the menu that holds it.
  • With headerWidget a long title now wraps beside the header actions instead of pushing them onto the next row.

Favourite and follow beside the title​

When the loaded object carries @self.favourite or @self.watching (OpenRegister's interaction markers), the header shows a star (CnFavouriteToggle) and a Follow toggle (CnFollowToggle) beside the title. Nothing renders without the markers.

Prop (manifest config.*)TypeDefaultDescription
favouriteBooleannullAutomatic when unset. false removes the star.
followBooleannullAutomatic when unset. false removes the Follow toggle, and the object read then no longer asks for @self.can.
followRowObject | nullnullThe board look's follow row (manifest config.followRow): presence: true says who else has the record open now, with their initials, before the Follow control ("Anouk Bakker is also looking at this record now", or "… and 2 others …"); count: false draws no follower count.
followNotifiesBooleantruefalse when the register sends no change notifications to followers; the Follow tooltip then says so.
extendArray[]Extra _extend[] values for the object read. @self.can is added while the Follow toggle can render, because OpenRegister returns the rights (and so manage) only on request.
permissionsBooleanfalseRead the record's rights (manifest config.permissions: true): the object read asks for @self.can, also with follow: false. While can.update is false the Edit button, the header actions with role edit or update and the inline editors of the data and map widgets are off. A record without can keeps every control. Widgets read the rights as cnRecordCan and cnRecordEdit.denied, the actions slot as can, and a visibleWhen as @self.can.<name>.

Read state: opening a record marks it read​

When the loaded object carries @self.unread: true (OpenRegister object-read-state), the page sends PUT /apps/openregister/api/objects/{register}/{schema}/{id}/read-state once per page load, after the object has rendered. Nothing is sent when the object failed to load, does not carry the marker, or markRead is false.

When the object carries @self.unread (true or false), the Actions menu offers Mark as unread, which sends DELETE .../read-state and emits marked-unread. The page stays open, unless markUnreadNavigatesBack is set.

Prop (manifest config.*)TypeDefaultDescription
markReadBooleantruefalse keeps the page from marking anything read.
markUnreadNavigatesBackBooleanfalseAfter Mark as unread, go back one step in the router history.
EventPayloadDescription
marked-unread—After the record was marked unread.

Tabs of a tabs widget show what is new on them: see CnTabsWidget.

The board look (screens-detail-page-parity)​

With look: "board" (the manifest root key, config.look, or the look prop) the detail page takes the shape of the screens, dossiq/DqZaak. Without it nothing changes.

  • Header. Two rows on the page ground: row 1 is the title as an h1 (28px) with the header buttons at its end; row 2 holds the type and status pills, the breadcrumb, a middle dot and the meta line, then the headerFields chips. The breadcrumb does not render above the header. The last breadcrumb is the record's kenmerk (breadcrumb.currentField, for example the case number) and the title when the record has none; the h1 is always the title. The header is never a card, and draws no icon or type eyebrow.
  • Buttons. Quick actions, Edit (always its own labelled button, also with inlineActions), the buildiq square, then the menu labelled "More" (actionsMenu.label renames it), as a secondary button. No primary button when the next-step card shows. The quick actions, Edit and More are the board's neutral 40px buttons (the main background, a grey border, the main text at 600, a 16px icon), also under a theme that outlines every secondary button in the primary colour.
  • Tabs. A tabs widget draws folder tabs: no coloured top edge, grey borderless count badges, no icons, no "More" overflow. The strip's tab list is named by tabsLabel, by default "<page title> parts". An activity tab (an audit-trail or timeline widget, or the activity integration) is named History and rendered last, and the activity is not also a body section.
  • Cards. Body cards take radius 12, padding 20px 22px and a 17px heading; data cards list fields in 200px columns. Side cards take a 15px muted heading and no Actions menu (showWidgetActions is false unless the manifest sets it). A banner widget in sideColumn moves to the top, the activity widget to the end, and the History card ends with the line "Identifier: <value>" read from identifierField.
PropTypeDefaultDescription
lookString''nextcloud or board. Empty takes the look the app provides.
headerMetaString''The meta line on row 2 (manifest config.headerMeta): a field template such as via {channel}. An enum field reads as its x-enum-labels label. A token can format its value as a record-list row does: date ("7 okt"), datetime, weekday ("ma 5 okt", weekday:today), longdate ("7 oktober", longdate:year), time, user (a user id's display name), group (a group id's display name), currency:EUR (or currency:<field>), relative, relativetime, days. An empty token drops itself and the separator before it ({amount|currency:EUR} · {cashier|user} · {at|longdate} {at|time} without a cashier reads "€ 96,41 · 7 oktober 11.43"); a line with no value at all is dropped.
tabsLabelString''The accessible name of the tab list (manifest config.tabsLabel).
identifierFieldString''The record field named in the last line of the History side card (manifest config.identifierField).
titleFieldString''The record field the header names the record by (manifest config.titleField, a dotted path such as number). An empty value falls back to the display name. Works in both looks.

The rules live in src/css/look-board-detail.css, scoped under .cn-look-board.

A side card that follows a selected row (follows)​

A side card can describe the row another list on the page has selected instead of the page's own record. Board DqZaaktypeVelden draws "Keuzelijst: Soort bouwwerk" beside the Velden table: the options of the selected field, with "Optie toevoegen". Those options are stored on the field's own record.

{
"sideColumn": [
{
"id": "side-choice-list",
"type": "field-list",
"title": "Choice list: {name}",
"tabs": ["fields"],
"follows": {
"widget": "case-type-fields-editor",
"register": "dossiq",
"schema": "propertyDefinition",
"when": { "field": "enumValues", "op": "notEmpty" }
},
"content": {
"field": "enumValues",
"add": { "label": "Add option", "scalar": true, "unique": true, "fields": [{ "key": "value", "label": "Option", "required": true }] }
}
}
]
}
  • The followed list is an object-list with content.rowSelection: true. It publishes the rows it shows and the row the reader clicks, and marks that row.
  • The card is hosted on that row (CnFollowingWidgetHost). Its record, id, register and schema are the row's, so a field-list saves to the row.
  • The card shows the selected row when when holds for it. While nothing is selected, it shows the first row for which when holds. Without such a row it draws nothing.
  • {field} in the title is filled from the row, after the title is translated.

CnDetailPage provides the selection store (cnWidgetSelection, from utils/widgetSelection.js). CnDetailWidgetHost provides the id of the widget it hosts, which is the key a list publishes under.