@dforge-core/metadata 0.0.26 → 0.0.29

package/schemas/entity.schema.json

@@ -38,6 +38,10 @@
 		"toString": {
 			"description": "Display pattern using column placeholders, e.g. \"{first_name} {last_name}\". Optional in extension entities (with `extends`). No `type` constraint here because `toString` collides with Object.prototype.toString in JSON validators — they read the inherited function and reject it, even when the property is absent from the JSON."
 		},
+		"comments": {
+			"type": "boolean",
+			"description": "Records of this entity accept comments \u2014 the composer and thread appear on the record card, beside the audit history. Opt-in per entity; `comments` in the manifest sets a module-wide default that this overrides in both directions."
+		},
 		"traits": {
 			"type": "array",
 			"description": "Entity traits expanded during module install (authoring shortcut). Trait definitions loaded from DB (seeded by metadata module).",
@@ -221,9 +225,48 @@
 			},
 			"additionalProperties": false
 		},
+		"registryColumnParams": {
+			"type": "object",
+			"description": "params of an accumulation (A) or ledger (L) registry column. The lock lists are what BOTH generated guards freeze — the posted-document guard while the document is posted, the period guard while its period is closed — and they are required: install refuses a registry column that omits or empties them. The header's periodDateField and the state column are watched in addition, whatever the list says.",
+			"required": ["lockedFields"],
+			"properties": {
+				"lockedFields": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "type": "string", "minLength": 1 },
+					"description": "Header fields frozen while the document is posted and while its period is closed. Required. [\"*\"] freezes the whole row."
+				},
+				"lockedLineFields": {
+					"type": "array",
+					"minItems": 1,
+					"items": { "type": "string", "minLength": 1 },
+					"description": "Line fields frozen under a posted or period-closed header. Required when lineEntity is declared, rejected when it is not. [\"*\"] freezes the whole row; the line's foreign key to the header is watched in addition."
+				},
+				"lineEntity": { "type": "string", "description": "The line entity, defined in this module. Declare together with lineField and lockedLineFields, or none of the three for a document without lines." },
+				"lineField": { "type": "string", "description": "The line's foreign-key column(s) to the header, comma-separated in the header's key order for a composite key." },
+				"stateField": { "type": "string", "description": "The bool column that records the posted state, when it is not the registry column itself. Written only by the register engine." },
+				"periodEntity": { "type": "string", "description": "Period entity this registry closes against — one of this module's, or 'module.entity' from a dependency." },
+				"periodDateField": { "type": "string", "description": "Header date column that resolves the period." },
+				"periodKeyField": { "type": "string", "default": "period_key" },
+				"periodClosedField": { "type": "string", "default": "closed" }
+			},
+			"dependencies": {
+				"lineEntity": ["lineField", "lockedLineFields"],
+				"lineField": ["lineEntity"],
+				"lockedLineFields": ["lineEntity"],
+				"periodEntity": ["periodDateField"]
+			},
+			"additionalProperties": true
+		},
 		"field": {
 			"type": "object",
 			"description": "Entity column/field definition",
+			"allOf": [
+				{
+					"if": { "required": ["columnType"], "properties": { "columnType": { "enum": ["A", "L"] } } },
+					"then": { "required": ["params"], "properties": { "params": { "$ref": "#/$defs/registryColumnParams" } } }
+				}
+			],
 			"properties": {
 				"dbDatatype": {
 					"type": "string",
@@ -320,6 +363,15 @@
 						},
 						"serverDefault": {
 							"$ref": "#/$defs/serverDefault"
+						},
+						"pattern": {
+							"type": "string",
+							"description": "Format rule for this column, as an ECMAScript regex source. Overrides the field type's own pattern (field_type.def_params.pattern, which is what makes email/phone/url reject a malformed value). Enforced in the browser and again on data.insert / data.update, so keep to constructs both engines read alike: [0-9] and \\d are the same there, \\s is normalized to JavaScript's set, and a pattern that will not compile is skipped by both rather than enforced by one."
+						},
+						"patternFlags": {
+							"type": "string",
+							"description": "Flags for 'pattern', as a JavaScript regex literal would carry them; 'i' and 'm' are the two honoured, each at most once — the RegExp constructor rejects a repeated flag, and a rule the browser cannot compile is skipped there and would then be enforced by the API alone. JavaScript has no inline (?i), so case-insensitivity has to be stated here.",
+							"pattern": "^(i|m|im|mi)?$"
 						}
 					}
 				},
@@ -526,7 +578,7 @@
 		"accumulationConfig": {
 			"type": "object",
 			"description": "Configuration for simple accumulation (document without lines, e.g. receipt → stock).",
-			"required": ["balanceEntity", "dimensions", "resources"],
+			"required": ["balanceEntity", "dimensions", "resources", "lockedFields"],
 			"properties": {
 				"balanceEntity": { "type": "string", "description": "Balance entity code (e.g. 'stock')" },
 				"dimensions": {
@@ -551,7 +603,7 @@
 				"sign": { "$ref": "#/$defs/signConfig", "description": "Dynamic sign based on a field value (alternative to direction)" },
 				"autoCreateBalance": { "type": "boolean", "default": true },
 				"allowNegative": { "type": "boolean", "default": true },
-				"lockedFields": { "type": "array", "items": { "type": "string" }, "description": "Document fields locked when posted" }
+				"lockedFields": { "type": "array", "minItems": 1, "items": { "type": "string", "minLength": 1 }, "description": "Document fields locked when posted. Required; [\"*\"] freezes the whole row." }
 			},
 			"additionalProperties": false
 		},

package/schemas/manifest.schema.json

@@ -107,6 +107,10 @@
 			"enum": ["none", "minimal", "full"],
 			"description": "Default audit history mode for entities in this module ('full' captures every field change; 'minimal' captures only inserts/deletes; 'none' disables). Individual entities can override."
 		},
+		"comments": {
+			"type": "boolean",
+			"description": "Default for `comments` on every entity in this module. Individual entities override it, including overriding true with false."
+		},
 		"entities": {
 			"type": "object",
 			"description": "Entity definitions and extensions: entity code → relative path to entity JSON file. Dotted keys (e.g. 'fin.invoice') indicate extensions of other modules' entities (the entity file must have an 'extends' property).",

package/schemas/reports.schema.json

@@ -249,9 +249,9 @@
 					"$ref": "#/$defs/query",
 					"description": "Used when datasetType is 'Q'"
 				},
-				"procedureName": {
+				"spCd": {
 					"type": "string",
-					"description": "Used when datasetType is 'S'"
+					"description": "Used when datasetType is 'S': the stored-procedure code, as `logic/stored_procedures.json` keys it — NOT the PostgreSQL function name and never schema-qualified. `module.spCd` binds a dependency's procedure. Resolved to `report_ds.sp_id` at install. A role granting `report:<code>` must also grant `sp:<spCd>`, which no admin UI can add afterwards."
 				},
 				"columnsDef": {
 					"type": "object",

package/schemas/stored_procedures.schema.json

@@ -0,0 +1,125 @@
+{
+	"$schema": "https://json-schema.org/draft/2020-12/schema",
+	"title": "dForge Module Stored Procedures",
+	"description": "Stored-procedure declarations for a dForge module package (logic/stored_procedures.json). Each entry registers one PostgreSQL function as a procedure a report dataset can bind with `datasetType: \"S\"` and `spCd`. The SQL that creates the function ships separately, as a CREATE OR REPLACE FUNCTION script under logic/reports/; this file does not name the script, it names the function the script creates. See docs/business-logic/stored-procedures.md.",
+	"type": "object",
+	"additionalProperties": {
+		"type": "object",
+		"required": ["functionName"],
+		"description": "Keyed by stored-procedure code (sp_cd) — module-internal, referenced from a dataset's `spCd` and a role's `sp:` right. It may not contain a dot: a dot is the module qualifier in both of those key spaces.",
+		"properties": {
+			"description": {
+				"type": "string",
+				"description": "Label for the procedure, shown in the report editor's procedure picker. Defaults to the code."
+			},
+			"schemaName": {
+				"type": "string",
+				"pattern": "^[a-zA-Z_][a-zA-Z0-9_\\-]*$",
+				"description": "PostgreSQL schema holding the function. Defaults to the module's own schema, which is what a module-shipped function normally uses."
+			},
+			"functionName": {
+				"type": "string",
+				"pattern": "^[a-zA-Z_][a-zA-Z0-9_\\-]*$",
+				"description": "The PostgreSQL function's own name, unqualified — `report.run` calls SELECT * FROM \"schemaName\".\"functionName\"(...). Required: it is the one fact this file exists to record, and install fails naming it when absent."
+			},
+			"returnsTable": {
+				"type": "boolean",
+				"default": true,
+				"description": "The function is set-returning (RETURNS TABLE / SETOF). The only shape report.run projects."
+			},
+			"params": {
+				"type": "array",
+				"description": "The call signature, in order: report.run passes exactly one positional argument per entry and NOTHING else — no folder, no user. A function taking p_folder_uid / p_user_id can never be called, and install rejects the arity mismatch. Omit the block for a function taking no arguments.",
+				"items": { "$ref": "#/$defs/param" }
+			},
+			"columns": {
+				"type": "array",
+				"description": "Result columns, stored in dForge.sp_column and used to project the dataset. Omit the block and the registrar derives them from the function's own RETURNS TABLE / OUT column names. Declare it to set labels, widths, a currency/percent control or a refEntityCd link — a declared list is used as written and never merged with the signature. A function returning an unnamed SETOF composite or a bare scalar declares no column names, so it must list them here.",
+				"items": { "$ref": "#/$defs/column" }
+			}
+		},
+		"additionalProperties": false
+	},
+
+	"$defs": {
+		"param": {
+			"type": "object",
+			"required": ["paramCd"],
+			"properties": {
+				"paramCd": {
+					"type": "string",
+					"maxLength": 50,
+					"description": "Parameter code. Conventionally the function's own argument name (p_customer_id), though the call is positional."
+				},
+				"pgType": {
+					"type": "string",
+					"default": "bigint",
+					"description": "PostgreSQL type of the argument — this is what binds the value, and it is carried even when the value is null so an omitted optional argument arrives as a TYPED null. Defaults to `bigint`, so declare it for every argument that is not one. One of: bigint, integer, smallint, numeric, real, double precision, text, boolean, uuid, date, timestamp, timestamptz, time — or any alias PostgreSQL treats as the same type (int8, int4, int, int2, decimal, float8, float4, varchar, character varying, char, bpchar, bool, timestamp without time zone, timestamp with time zone, time without time zone). Case does not matter and a type modifier is ignored, so `numeric(18,2)` may be pasted straight from the signature. jsonb, arrays, enums and citext cannot be bound and are rejected at install. Enforced by SpParamTypes, which is where this list lives — left out of an enum here so the spellings install accepts are not flagged by an editor.",
+					"examples": ["bigint", "text", "date", "numeric(18,2)", "timestamptz", "uuid", "boolean"]
+				},
+				"fieldTypeCd": {
+					"type": "string",
+					"description": "Control the report editor copies into the report param when the procedure is bound there. Optional — derived from pgType when omitted."
+				},
+				"label": {
+					"type": "string",
+					"description": "Parameter label for that same copy."
+				},
+				"required": {
+					"type": "boolean",
+					"default": true,
+					"description": "Whether the parameter must have a value. Give every optional one DEFAULT NULL in the function signature."
+				}
+			},
+			"additionalProperties": false
+		},
+
+		"column": {
+			"type": "object",
+			"required": ["columnCd"],
+			"properties": {
+				"columnCd": {
+					"type": "string",
+					"maxLength": 100,
+					"description": "Result column name as the function returns it. Unique within the procedure."
+				},
+				"label": {
+					"type": "string",
+					"description": "Column header. Defaults to the code."
+				},
+				"fieldTypeCd": {
+					"type": "string",
+					"default": "text",
+					"description": "Control that renders the value (number, currency, date, dropdown, flags, ...)."
+				},
+				"baseDatatypeCd": {
+					"type": "string",
+					"default": "string",
+					"description": "Underlying datatype the value is read as."
+				},
+				"orderNum": {
+					"type": "integer",
+					"description": "Display order. Defaults to declaration order in steps of 10."
+				},
+				"refEntityCd": {
+					"type": "string",
+					"description": "Entity this column links to, making the value clickable. Resolved within this module and its dependencies."
+				},
+				"refColumnCd": {
+					"type": "string",
+					"description": "Column in the result holding the FK value for that link, when it is not this column."
+				},
+				"width": {
+					"type": "integer",
+					"description": "Column width in pixels."
+				},
+				"params": {
+					"type": "object",
+					"description": "Control parameters, the same shape an entity column's `params` takes — `options` for a dropdown or flags, `currency`, `align`, and so on.",
+					"additionalProperties": true
+				}
+			},
+			"additionalProperties": false
+		}
+	}
+}

package/src/card-layouts.ts

@@ -0,0 +1,103 @@
+// Card layouts — authoring shape of `ui/card_layouts.json`.
+// Mirror of card_layouts.schema.json, and of the runtime CardLayout in
+// @dforge/data's layouts.ts — the installer stores the body verbatim, so the
+// two must not drift.
+
+/** A field in a card section — either a bare column code or pixel sizing with it. */
+export type CardFieldEntry = string | CardFieldDef;
+
+export interface CardFieldDef {
+	column_cd: string;
+	/** Field width in px. */
+	width?: number;
+	/** Field height in px — for multiline/textarea fields. */
+	height?: number;
+}
+
+/** A group of fields laid out in 1, 2 or 3 columns. */
+export interface ColumnGroupSection {
+	type: "columnGroup";
+	code: string;
+	/** Section heading, in the module's authoring language. The installer gives it an
+	 *  `entity_column_group` row keyed on this section's `code`, so
+	 *  `translations/<locale>.json` localizes it under
+	 *  `entities.<entity>.columnGroups.<code>.label` and the card renders that instead. */
+	label?: string;
+	columns: CardFieldEntry[];
+	/** Field columns across the group (1-3). Defaults to the card's own setting. */
+	cols?: number;
+}
+
+/**
+ * An embedded detail grid for a 1:N set column — the master/detail building
+ * block. The label comes from the set column's own metadata.
+ */
+export interface SetSection {
+	type: "set";
+	code: string;
+	/** Set column code on this entity (columnType 'S'). */
+	setField: string;
+}
+
+/** Reference to a tab item: a columnGroup section's code, or a set column's code. */
+export interface CardTabRef {
+	type: "section" | "set";
+	code: string;
+}
+
+/** A tab bar whose tabs are other sections — several detail grids without one long form. */
+export interface TabGroupSection {
+	type: "tabGroup";
+	code: string;
+	tabs: CardTabRef[];
+}
+
+export type CardSection = ColumnGroupSection | SetSection | TabGroupSection;
+
+/** Per-set-field renderer choice, keyed by the set column code. */
+export interface CardSetConfig {
+	viewType?: "grid" | "list";
+	/** Opaque per-renderer options, passed verbatim to the set registration. */
+	options?: Record<string, unknown>;
+}
+
+/** The layout body, stored verbatim into `dForge.entity_view_layout.layout`. */
+export interface CardLayout {
+	sections: CardSection[];
+	sets?: Record<string, CardSetConfig>;
+}
+
+/**
+ * A module-shipped card layout (value in the card_layouts map; the key is the
+ * layout name).
+ *
+ * Rows written from here carry `module_id`, so the installer recreates them on
+ * every install and removes them on uninstall. A layout the tenant drew in the
+ * card editor has `module_id` NULL and is never touched.
+ */
+export interface CardLayoutDef {
+	/**
+	 * Entity code the layout belongs to. Unqualified means this module owns the
+	 * entity; `module.entity` targets another module's (the bridge case).
+	 */
+	entity: string;
+	/**
+	 * Entity view the layout hangs off. Defaults to `"default"` — the same
+	 * fallback the runtime uses for an entity with no folder binding of its own.
+	 * Matched against the entity's declared views case-insensitively, and filed
+	 * under their spelling.
+	 */
+	view?: string;
+	/**
+	 * Whether this layout opens by default. Honoured on FIRST install only, and
+	 * only when the view has no default yet: once a tenant has chosen their own,
+	 * an upgrade does not take it back.
+	 */
+	isDefault?: boolean;
+	/** Human-readable note for the package author. Not stored. */
+	description?: string;
+	layout: CardLayout;
+}
+
+/** `ui/card_layouts.json` — layout name → definition. */
+export type CardLayoutsFile = Record<string, CardLayoutDef>;

package/src/data-views.ts

@@ -17,7 +17,6 @@ export type ViewType =
 	| "gallery"
 	| "tree-grid"
 	| "diagram"
-	| "master-detail"
 	| "library"
 	| "matrix";
 
@@ -30,7 +29,6 @@ export const dataViewKinds: readonly NamedKind[] = [
 	{ cd: "gallery", name: "Gallery" },
 	{ cd: "tree-grid", name: "Tree Grid" },
 	{ cd: "diagram", name: "Diagram" },
-	{ cd: "master-detail", name: "Master / Detail" },
 	{ cd: "library", name: "Library" },
 	{ cd: "matrix", name: "Matrix" },
 ] as const;
@@ -55,7 +53,7 @@ export interface DataSource {
 	entityCode: string;
 	/** Nesting level (0 = root, 1+ = detail). */
 	level?: number;
-	/** Human-readable label (used in master-detail tabs). */
+	/** Human-readable label for this data source. */
 	label?: string;
 	/** Column configuration. */
 	columns?: ViewColumn[];
@@ -121,7 +119,7 @@ export interface DataViewDef {
 	/** Bootstrap icon class (e.g. 'bi-bounding-box'). */
 	icon?: string;
 	description?: string;
-	/** Data sources (at least one; master-detail needs two). */
+	/** Data sources (at least one). Only the first is rendered today. */
 	dataSources: DataSource[];
 	/** Default filter applied to all sources unless one declares its own. */
 	filter?: Filter;

package/src/entity.ts

@@ -130,8 +130,8 @@ export interface AccumulationConfig {
 	sign?: SignConfig;
 	autoCreateBalance?: boolean;
 	allowNegative?: boolean;
-	/** Document fields locked once posted. */
-	lockedFields?: string[];
+	/** Document fields locked once posted. Required; `["*"]` freezes the whole row. */
+	lockedFields: string[];
 }
 
 /** One registry target within an L-column's `registries` array. */
@@ -167,6 +167,8 @@ export interface EntityDef {
 	viewSql?: string;
 	/** Display pattern using column placeholders, e.g. "{first_name} {last_name}". */
 	toString?: string;
+	/** Records of this entity accept comments (composer + thread on the card). */
+	comments?: boolean;
 	/** Traits expanded at install time. */
 	traits?: TraitCd[];
 	/** Column definitions keyed by column code. Optional when a trait (e.g. `period`) supplies all columns. */

package/src/index.ts

@@ -5,9 +5,9 @@
 //     kinds, report viz/chart types, plus helpers that derive physical metadata
 //     from a friendly field-type choice;
 //   • structural types — the authoring shape of every module-package file
-//     (manifest, entities, data views, reports, menus, folders, roles, settings,
-//     jobs, triggers, webhooks, print templates, seed data, actions), mirrored
-//     from the JSON schemas under docs/schemas/.
+//     (manifest, entities, data views, reports, stored procedures, menus, folders,
+//     roles, settings, jobs, triggers, webhooks, print templates, seed data,
+//     actions), mirrored from the JSON schemas under docs/schemas/.
 //
 // No runtime dependencies; safe to import from editors, the web app, the CLI,
 // the MCP server and the VS Code extension.
@@ -105,6 +105,13 @@ export {
 	type VizType,
 } from "./reports";
 
+export type {
+	StoredProceduresFile,
+	StoredProcedureDef,
+	SpParamDef,
+	SpColumnDef,
+} from "./stored-procedures";
+
 export type { ManifestDef, ManifestAuthor, ModuleDependency, ModuleFeature } from "./manifest";
 export type { DepsFile, DepEntity, DepColumn, DepColumnType, DepColumnMode, DepProvenance, DepProvenanceKind } from "./deps";
 export { DEP_COLUMN_TYPES } from "./deps";
@@ -117,6 +124,19 @@ export type { JobsFile, JobDef } from "./jobs";
 export type { TriggersFile, TriggerDef, EntityEvent } from "./triggers";
 export type { WebhooksFile, WebhookSubscription, WebhookPayload } from "./webhooks";
 export type { PrintTemplatesFile, PrintTemplateDef, PrintPageSettings, PrintMargins } from "./print-templates";
+export type {
+	CardLayoutsFile,
+	CardLayoutDef,
+	CardLayout,
+	CardSection,
+	CardSetConfig,
+	CardTabRef,
+	CardFieldEntry,
+	CardFieldDef,
+	ColumnGroupSection,
+	SetSection,
+	TabGroupSection,
+} from "./card-layouts";
 export type { SeedDataFile } from "./seed-data";
 export type { ActionsFile, ActionDef, ActionExecutionMode } from "./actions";
 

package/src/manifest.ts

@@ -44,6 +44,8 @@ export interface ManifestDef {
 	dependencies?: Record<string, ModuleDependency>;
 	/** Default audit history mode for this module's entities. */
 	auditHistory?: "none" | "minimal" | "full";
+	/** Default for `comments` on this module's entities; each entity may override. */
+	comments?: boolean;
 	/** Entity code → relative path of its JSON file (dotted keys = extensions). */
 	entities?: Record<string, string>;
 	/** Module category for display (e.g. 'Integration', 'Finance'). */

package/src/reports.ts

@@ -128,8 +128,12 @@ export interface Dataset {
 	datasetType: "Q" | "S";
 	/** Used when `datasetType` is 'Q'. */
 	query?: ReportQuery;
-	/** Used when `datasetType` is 'S'. */
-	procedureName?: string;
+	/**
+	 * Used when `datasetType` is 'S': the stored-procedure code, as
+	 * `logic/stored_procedures.json` keys it — not the PostgreSQL function name,
+	 * and never schema-qualified. `module.spCd` binds a dependency's procedure.
+	 */
+	spCd?: string;
 	/** Optional column metadata overrides: field code → override. */
 	columnsDef?: Record<string, ColumnDef>;
 	/**

package/src/stored-procedures.ts

@@ -0,0 +1,75 @@
+// Stored procedures — authoring shape of `logic/stored_procedures.json`.
+// Mirror of stored_procedures.schema.json.
+//
+// Each entry registers one PostgreSQL function as a procedure a report dataset
+// binds through `datasetType: "S"` and `spCd`. The SQL creating the function
+// ships separately, under `logic/reports/*.sql`; this file names the function
+// that script creates, never the script.
+
+/** `logic/stored_procedures.json` — keyed by stored-procedure code (`sp_cd`). */
+export type StoredProceduresFile = Record<string, StoredProcedureDef>;
+
+/** One stored-procedure declaration. */
+export interface StoredProcedureDef {
+	/** Label in the report editor's procedure picker. Defaults to the code. */
+	description?: string;
+	/** Schema holding the function. Defaults to the module's own schema. */
+	schemaName?: string;
+	/**
+	 * The function's own name, unqualified — `report.run` calls
+	 * `SELECT * FROM "schemaName"."functionName"(...)`. Required: it is the one
+	 * fact this file exists to record, and install fails naming it when absent.
+	 */
+	functionName: string;
+	/** The function is set-returning — the only shape `report.run` projects. */
+	returnsTable?: boolean;
+	/**
+	 * The call signature, in order. `report.run` passes exactly one positional
+	 * argument per entry and nothing else — no folder, no user — so a function
+	 * taking `p_folder_uid` / `p_user_id` can never be called.
+	 */
+	params?: SpParamDef[];
+	/**
+	 * Result columns. Omit the block and install derives them from the function's
+	 * own `RETURNS TABLE` / OUT column names; a declared list is used as written
+	 * and never merged with the signature.
+	 */
+	columns?: SpColumnDef[];
+}
+
+/** One declared argument of the procedure. */
+export interface SpParamDef {
+	/** Parameter code, conventionally the function's own argument name. */
+	paramCd: string;
+	/**
+	 * PostgreSQL type of the argument — what binds the value, carried even when
+	 * the value is null so an omitted optional argument arrives as a typed null.
+	 * Case-insensitive, and a type modifier is ignored (`numeric(18,2)`).
+	 * Defaults to `bigint`, so declare it for every argument that is not one.
+	 */
+	pgType?: string;
+	/** Control copied into the report param on bind. Derived from `pgType` when omitted. */
+	fieldTypeCd?: string;
+	label?: string;
+	/** Default true. Give every optional one `DEFAULT NULL` in the signature. */
+	required?: boolean;
+}
+
+/** One declared result column of the procedure. */
+export interface SpColumnDef {
+	/** Result column name as the function returns it. Unique within the procedure. */
+	columnCd: string;
+	/** Column header. Defaults to the code. */
+	label?: string;
+	fieldTypeCd?: string;
+	baseDatatypeCd?: string;
+	/** Display order. Defaults to declaration order in steps of 10. */
+	orderNum?: number;
+	/** Entity this column links to, making the value clickable. */
+	refEntityCd?: string;
+	/** Column holding the FK value for that link, when it is not this one. */
+	refColumnCd?: string;
+	width?: number;
+	/** Control parameters, the same shape an entity column's `params` takes. */
+	params?: Record<string, unknown>;
+}