@dforge-core/metadata 0.0.12 → 0.0.13

package/dist/index.d.ts

@@ -1,31 +1,1224 @@
-export type { AlignType, BaseDatatypeCd, ColumnTypeCd, ColumnTypeDef, FieldDef, FieldLink, FieldOption, FieldTypeCd, FieldTypeDef, FlagCd, NamedKind, TraitDef, } from "./types";
-export { AggType, AGG_TYPE_LIST } from "./aggregation";
-export { fieldTypes, fieldTypeCds, isFieldTypeCd, getFieldType, fieldTypesByColumnType } from "./field-types";
-export { baseDatatypes, baseToDbDatatype } from "./base-datatypes";
-export { columnTypes, getColumnType } from "./column-types";
-export { traits, getTrait, expandTrait, expandTraits } from "./traits";
-export { deriveDbDatatype, deriveBaseDatatype, defaultParams, NUMERIC_TOTAL, type DeriveOptions, } from "./derive";
-export type { Filter, FilterCondition, FilterGroup, SortClause } from "./filter";
-export type { EntityDef, EntityReference, NumberSequenceDef, PeriodConfig, AccumulationConfig, SignConfig, LedgerRegistryEntry, TraitCd, } from "./entity";
-export { getLinks, getIdentityKeys, getPrimaryKeys } from "./entity-meta";
-export { dataViewKinds, type DataViewsFile, type DataViewDef, type DataSource, type ViewColumn, type ViewType, type KanbanViewConfig, type CalendarViewConfig, type TreeGridViewConfig, type ListViewConfig, type ListLevelConfig, type DiagramViewConfig, } from "./data-views";
-export { vizTypes, chartTypes, type ReportsFile, type ReportDef, type ReportLayout, type ReportPanel, type Dataset, type ReportQuery, type ColumnDef, type ParamDef, type VizType, } from "./reports";
-export type { ManifestDef, ManifestAuthor, ModuleDependency } from "./manifest";
-export type { DepsFile, DepEntity, DepColumn, DepColumnType, DepColumnMode, DepProvenance, DepProvenanceKind } from "./deps";
-export { DEP_COLUMN_TYPES } from "./deps";
-export type { DomainsFile, DomainDef } from "./domains";
-export type { MenusFile, MenuDef, MenuItemDef, MenuItemType } from "./menus";
-export type { FoldersFile, FolderDef, FolderEntityBinding } from "./folders";
-export type { RolesFile, RoleDef } from "./roles";
-export type { SettingsFile, SettingDef, SettingBaseDatatype } from "./settings";
-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 { SeedDataFile } from "./seed-data";
-export type { ActionsFile, ActionDef, ActionExecutionMode } from "./actions";
-export declare const flagDefs: readonly {
+/** A `{ cd, name }` pair for friendly pickers (view kinds, viz types, …). */
+interface NamedKind {
+    cd: string;
+    name: string;
+}
+/** Horizontal alignment for a column's display (authored via `params.align`). */
+type AlignType = "left" | "right" | "center";
+/** Column kind letter as stored in entity JSON / the `column` metadata table. */
+type ColumnTypeCd = "D" | "R" | "S" | "F" | "A" | "L" | "G";
+/** Abstract data type code from the `base_datatype` table. */
+type BaseDatatypeCd = "binary" | "bool" | "culture" | "cuid" | "date" | "guid" | "json" | "link" | "number" | "project" | "ref" | "set" | "string" | "time" | "timestamp" | "xml";
+/** Display flags string characters. V=Visible I=Identity E=Editable M=Mandatory H=Hidden. */
+type FlagCd = "V" | "I" | "E" | "M" | "H";
+/** Known field type codes from the field_type seed. */
+type FieldTypeCd = "text" | "email" | "phone" | "url" | "textarea" | "number" | "currency" | "percent" | "checkbox" | "date" | "datetime" | "time" | "dropdown" | "flags" | "json" | "hidden" | "color" | "image" | "file" | "markdown" | "richtext" | "avatar" | "lookup" | "user" | "grid" | "list" | "tags" | "entitylink" | "code";
+/**
+ * A UI field type from the `field_type` table. The author picks one of these;
+ * the physical `dbDatatype` and `baseDatatypeCd` are derived from it.
+ */
+interface FieldTypeDef {
+    /** Stable code stored as `fieldTypeCd` on a field. */
+    cd: FieldTypeCd;
+    /** Human label for pickers. */
+    name: string;
+    /** Default column kind this field type implies (D / R / S). */
+    columnType: ColumnTypeCd;
+    /** Abstract datatype used for platform semantics. */
+    baseDatatypeCd: BaseDatatypeCd;
+    /** Aggregations this type supports: S=sum C=count A=avg M=min/max (letters). */
+    supportedAgg: string | null;
+    /** Default maximum length for string-backed types (e.g. color = 20). */
+    maxLen: number | null;
+    /** Default numeric scale for number-backed types (e.g. currency = 2). */
+    precision: number | null;
+    /** Whether the value participates in text filters. */
+    useStringInFilter: boolean;
+    /** Default field-type params merged into `params` when the field is created. */
+    defParams?: Record<string, unknown>;
+}
+/** Relationship link for Reference (R) and Set (S) columns. */
+interface FieldLink {
+    /** Target entity code (the entity being referenced or collected). */
+    entity: string;
+    /** Column(s) in this entity (comma-separated for compound keys). */
+    thisKey: string;
+    /** Column(s) in the target entity (comma-separated for compound keys). */
+    otherKey: string;
+}
+/** A dropdown/flags option in `params.options` (rich form). */
+interface FieldOption {
+    value: string;
+    label: string;
+    icon?: string;
+    color?: string;
+}
+/**
+ * A field/column definition as it appears under an entity's `fields` map.
+ * Mirrors the `field` $def in entity.schema.json. Trait fields are a subset of
+ * this shape, so the same type covers both. The open index signature keeps it
+ * tolerant of forward-compatible / type-specific extras (e.g. A/L register
+ * config under `params`).
+ */
+interface FieldDef {
+    /** PostgreSQL data type (e.g. uuid, varchar, int4, numeric, timestamptz). */
+    dbDatatype?: string;
+    /** Abstract base datatype; required on Formula (F) columns. */
+    baseDatatypeCd?: BaseDatatypeCd;
+    /** UI field type code. */
+    fieldTypeCd?: FieldTypeCd;
+    /** Column kind (defaults to D when omitted). */
+    columnType?: ColumnTypeCd;
+    /** Display flags string (subset of V/I/E/M/H). */
+    flags?: string;
+    isPk?: boolean;
+    isNullable?: boolean;
+    isIdentity?: boolean;
+    /** Formula expression (F/G columns) or SQL default value. */
+    formula?: string;
+    orderNum?: number;
+    description?: string;
+    maxLen?: number;
+    precision?: number;
+    /** Input mask pattern for editing. */
+    editMask?: string;
+    /** Display format pattern. */
+    displayFmt?: string;
+    /** Relationship link for R and S columns. */
+    link?: FieldLink;
+    /**
+     * On a self-referencing R column, set true to ALLOW parent/child cycles.
+     * Absent ⇒ treated as an acyclic hierarchy guarded at the DB level.
+     */
+    cyclic?: boolean;
+    /**
+     * Reference to a reusable column domain, qualified as `module_cd.domain_cd`
+     * (unqualified resolves within the current module first, then tenant-created
+     * domains). Supplies `baseDatatypeCd`, `dbDatatype`, `fieldTypeCd`, `maxLen`,
+     * `precision` and `params`; declaring any of those alongside `domain` fails install.
+     */
+    domain?: string;
+    /** Filter criteria for reference lookups. */
+    refFilter?: unknown;
+    /** Field-type-specific configuration (dropdown options, register config, …). */
+    params?: {
+        options?: (string | FieldOption)[];
+    } & Record<string, unknown>;
+    [key: string]: unknown;
+}
+/** A reusable trait that expands into a set of fields (and optional references). */
+interface TraitDef {
+    cd: string;
+    description: string;
+    /** Other traits this one includes (expanded first). */
+    includes?: string[];
+    /** Fields injected, keyed by column code. `{entity}` / `{Entity}` are templated. */
+    fields: Record<string, FieldDef>;
+    /** Foreign-key references injected (legacy `references` block). */
+    references?: Record<string, unknown>;
+}
+/** Description of a column kind for friendly pickers. */
+interface ColumnTypeDef {
+    cd: ColumnTypeCd;
+    /** Author-facing label. */
+    name: string;
+    /** One-line explanation. */
+    description: string;
+}
+
+declare const AggType: {
+    readonly Sum: "sum";
+    readonly Count: "count";
+    readonly Avg: "avg";
+    readonly Min: "min";
+    readonly Max: "max";
+    readonly Group: "group";
+};
+/** One of the aggregation codes ("sum" | "count" | …). */
+type AggType = (typeof AggType)[keyof typeof AggType];
+/** All aggregation types as an array (useful for iteration). */
+declare const AGG_TYPE_LIST: readonly AggType[];
+
+declare const fieldTypes: readonly [{
+    readonly cd: "text";
+    readonly name: "Text";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "avatar";
+    readonly name: "Avatar Name";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "email";
+    readonly name: "Email";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "phone";
+    readonly name: "Phone";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "url";
+    readonly name: "URL";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "textarea";
+    readonly name: "Multiline Text";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "number";
+    readonly name: "Number";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "number";
+    readonly supportedAgg: "SCAM";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+    readonly defParams: {
+        readonly min: 0;
+        readonly max: 10000;
+    };
+}, {
+    readonly cd: "currency";
+    readonly name: "Currency";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "number";
+    readonly supportedAgg: "SCAM";
+    readonly maxLen: null;
+    readonly precision: 2;
+    readonly useStringInFilter: false;
+    readonly defParams: {
+        readonly min: 0;
+        readonly max: 1000000;
+    };
+}, {
+    readonly cd: "percent";
+    readonly name: "Percent";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "number";
+    readonly supportedAgg: "CAM";
+    readonly maxLen: null;
+    readonly precision: 2;
+    readonly useStringInFilter: false;
+    readonly defParams: {
+        readonly min: 0;
+        readonly max: 100;
+    };
+}, {
+    readonly cd: "checkbox";
+    readonly name: "Checkbox";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "bool";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "date";
+    readonly name: "Date";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "date";
+    readonly supportedAgg: "CM";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "datetime";
+    readonly name: "Date & Time";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "timestamp";
+    readonly supportedAgg: "CM";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "time";
+    readonly name: "Time";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "time";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "dropdown";
+    readonly name: "Dropdown";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "flags";
+    readonly name: "Flags";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+    readonly defParams: {
+        readonly style: "buttons";
+    };
+}, {
+    readonly cd: "json";
+    readonly name: "JSON Editor";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "json";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "hidden";
+    readonly name: "Hidden";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "color";
+    readonly name: "Color Picker";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: 20;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "image";
+    readonly name: "Image";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "binary";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "file";
+    readonly name: "File";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "binary";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "markdown";
+    readonly name: "Markdown";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "richtext";
+    readonly name: "Rich Text Editor";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: null;
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "lookup";
+    readonly name: "Lookup";
+    readonly columnType: "R";
+    readonly baseDatatypeCd: "guid";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "user";
+    readonly name: "User Picker";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "cuid";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "grid";
+    readonly name: "Detail Grid";
+    readonly columnType: "S";
+    readonly baseDatatypeCd: "set";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "list";
+    readonly name: "Detail List";
+    readonly columnType: "S";
+    readonly baseDatatypeCd: "set";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "tags";
+    readonly name: "Tags";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: true;
+}, {
+    readonly cd: "entitylink";
+    readonly name: "Entity Link";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "json";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}, {
+    readonly cd: "code";
+    readonly name: "Code Editor";
+    readonly columnType: "D";
+    readonly baseDatatypeCd: "string";
+    readonly supportedAgg: "C";
+    readonly maxLen: null;
+    readonly precision: null;
+    readonly useStringInFilter: false;
+}];
+/** Set of all known field type codes, for membership checks. */
+declare const fieldTypeCds: ReadonlySet<string>;
+/** Type guard: is `cd` one of the known field type codes? */
+declare function isFieldTypeCd(cd: string | undefined): cd is FieldTypeCd;
+/** Look up a field type by code, or `undefined` if unknown. */
+declare function getFieldType(cd: string): FieldTypeDef | undefined;
+/** Field types whose default column kind is `columnType` (e.g. "D" value types). */
+declare function fieldTypesByColumnType(columnType: string): readonly FieldTypeDef[];
+
+declare const baseDatatypes: readonly BaseDatatypeCd[];
+/** Default PostgreSQL type for a base datatype, or `null` if non-physical. */
+declare function baseToDbDatatype(base: string): string | null;
+
+declare const columnTypes: readonly ColumnTypeDef[];
+/** Look up a column type by letter. */
+declare function getColumnType(cd: string): ColumnTypeDef | undefined;
+
+declare const traits: readonly TraitDef[];
+/** Look up a trait by code. */
+declare function getTrait(cd: string): TraitDef | undefined;
+/**
+ * Expand a trait (and any traits it includes) into the concrete fields it adds
+ * for `entityName`, with `{entity}` / `{Entity}` tokens resolved. Returns an
+ * empty object for unknown or marker traits. Field order follows include-depth
+ * first, then declaration order; later definitions win on key collisions.
+ */
+declare function expandTrait(traitCd: string, entityName: string): Record<string, FieldDef>;
+/** Expand several traits in order into one merged field map. */
+declare function expandTraits(traitCds: readonly string[], entityName: string): Record<string, FieldDef>;
+
+/** Total digits used when building a `numeric(total, scale)` type. */
+declare const NUMERIC_TOTAL = 18;
+interface DeriveOptions {
+    /** Author-specified max length; overrides the field type's default. */
+    maxLen?: number | null;
+    /** Author-specified numeric scale; overrides the field type's default. */
+    precision?: number | null;
+}
+/**
+ * Derive the PostgreSQL `dbDatatype` for a field type. Returns `null` for
+ * field types backed by relationships/sets (lookup, grid) that have no physical
+ * column of their own. Unknown field types fall back to `varchar`.
+ */
+declare function deriveDbDatatype(fieldTypeCd: string, options?: DeriveOptions): string | null;
+/** Default `params` to seed a new field of this type with (or `undefined`). */
+declare function defaultParams(fieldTypeCd: string): Record<string, unknown> | undefined;
+/** The base datatype code a field type maps to (for `baseDatatypeCd` on F columns). */
+declare function deriveBaseDatatype(fieldTypeCd: string): string | undefined;
+
+/**
+ * Every operator the server's FilterBuilder translates — the closed set the
+ * `o` enum in the data_views / reports / folders schemas mirrors, and the set
+ * the installer validates a package's filters against.
+ *
+ * Symbolic forms and their word aliases are equivalent (`=`/`eq`, `!=`/`notEq`,
+ * `>`/`gr`, …); a leading `!` negates, with `n`-prefixed spellings as the alias
+ * (`!in`/`nIn`). Note the two spellings authors most often get wrong: null
+ * checks are `null` / `!null` (not `isNull` / `isNotNull`) and substring
+ * matching is `contains` (not `like`).
+ */
+declare const FILTER_OPERATORS: readonly ["=", "eq", "!=", "notEq", ">", "gr", ">=", "grEq", "<", "less", "<=", "lessEq", "eqRef", "contains", "!contains", "nContain", "start", "!start", "nStart", "end", "!end", "nEnd", "mask", "!mask", "nMask", "null", "empty", "!null", "nEmpty", "in", "!in", "nIn", "between", "btw", "!between", "nBetween", "f", "func"];
+type FilterOperator = (typeof FILTER_OPERATORS)[number];
+/** Every group combinator the server recognizes. `!`/`n` forms negate the group. */
+declare const FILTER_GROUP_OPERATORS: readonly ["and", "or", "!and", "nAnd", "!or", "nOr"];
+type FilterGroupOperator = (typeof FILTER_GROUP_OPERATORS)[number];
+/** A single filter condition. */
+interface FilterCondition {
+    /** Column code (supports dot navigation: 'customer.name'). */
+    c: string;
+    /** Operator — see {@link FILTER_OPERATORS}. */
+    o: FilterOperator;
+    /** Comparison value: scalar, array (in/nIn) or a `@param_code` reference. */
+    v?: unknown;
+}
+/** A boolean group of nested conditions/sub-groups. */
+interface FilterGroup {
+    /** Group combinator. */
+    g: FilterGroupOperator;
+    /** Group items: nested conditions or sub-groups. */
+    i: Filter[];
+}
+/** A filter is either a single condition or a group. */
+type Filter = FilterCondition | FilterGroup;
+/** A sort clause `{ c, d }` as used by reports / per-source order. */
+interface SortClause {
+    /** Column code. */
+    c: string;
+    /** Sort direction (default: asc). */
+    d?: "asc" | "desc";
+}
+
+/** Trait codes valid in an entity's `traits` array (entity.schema.json enum). */
+type TraitCd = "identity" | "audit" | "audit-full" | "soft-delete" | "sorting" | "postable" | "accumulation" | "ledger" | "period" | "file-library";
+/** Referential action for a FK's ON DELETE / ON UPDATE clause (omitted = noAction). */
+type ReferentialAction = "cascade" | "setNull" | "restrict" | "noAction";
+/** Foreign-key reference (legacy `references` block — prefer `link` on a field). */
+interface EntityReference {
+    from: {
+        field: string;
+    };
+    to: {
+        entity: string;
+        field: string;
+    };
+    /** ON DELETE rule; `setNull` requires a nullable FK column. */
+    onDelete?: ReferentialAction;
+    /** ON UPDATE rule; a no-op for immutable `cuid` PKs. */
+    onUpdate?: ReferentialAction;
+}
+/** Automatic document numbering config (entity `numberSequence`). */
+interface NumberSequenceDef {
+    /** Column code that receives the auto-generated number. */
+    column: string;
+    /** Module setting code to resolve the prefix from (folder-scoped). */
+    prefixSettingCd?: string;
+    /** Fallback prefix when no setting is configured. */
+    defaultPrefix: string;
+    /** Format pattern. Placeholders: {prefix}, {yyyy}, {yy}, {mm}, {dd}, {seq:N}. */
+    pattern?: string;
+    /** Counter reset period (default: year). */
+    resetPeriod?: "year" | "month" | "day" | "never";
+}
+/** Period-entity config (`period` block; requires the `period` trait). */
+interface PeriodConfig {
+    /** Format for the period key. Placeholders: {yyyy}, {yy}, {MM}, {dd}, {q}. */
+    keyFormat: string;
+}
+/** Dynamic sign determination based on a field value. */
+interface SignConfig {
+    /** Field code that determines direction. */
+    field: string;
+    /** Values that mean increase. */
+    positive: string[];
+    /** Values that mean decrease. */
+    negative: string[];
+}
+/** Accumulation-registry config (`accumulation` block; requires the trait). */
+interface AccumulationConfig {
+    /** Balance entity code (e.g. 'stock'). */
+    balanceEntity: string;
+    /** Balance lookup dimensions: field-name array or balance→document field map. */
+    dimensions: string[] | Record<string, string>;
+    /** Document field → balance field resource mappings. */
+    resources: Record<string, {
+        balanceField: string;
+    }>;
+    /** Fixed posting direction for all postings. */
+    direction?: "increase" | "decrease";
+    /** Dynamic sign (alternative to `direction`). */
+    sign?: SignConfig;
+    autoCreateBalance?: boolean;
+    allowNegative?: boolean;
+    /** Document fields locked once posted. */
+    lockedFields?: string[];
+}
+/** One registry target within an L-column's `registries` array. */
+interface LedgerRegistryEntry {
+    /** Movement entity code (e.g. 'posting_record'). */
+    movementEntity: string;
+    /** Line field → movement field mapping. */
+    movementMapping: Record<string, string>;
+    /** Balance entity code (e.g. 'balance_register'). */
+    balanceEntity: string;
+    balanceMapping: {
+        /** Balance row dimension columns. */
+        dimensions: string[];
+        /** Balance column for debit turnover. */
+        debitResource: string;
+        /** Balance column for credit turnover. */
+        creditResource: string;
+    };
+}
+/** A single entity definition (`entities/<code>.json`). */
+interface EntityDef {
+    /** Qualified entity code to extend (e.g. 'fin.invoice') — turns this into an extension. */
+    extends?: string;
+    description?: string;
+    /** Database schema name override (defaults to module schema). */
+    schema?: string;
+    /** Database table/view name (defaults to entity code). */
+    dbObject?: string;
+    /** When true, maps to a SQL view (read-only, no DDL). */
+    isView?: boolean;
+    /** SELECT statement for view-backed entities (`isView=true`). */
+    viewSql?: string;
+    /** Display pattern using column placeholders, e.g. "{first_name} {last_name}". */
+    toString?: string;
+    /** Traits expanded at install time. */
+    traits?: TraitCd[];
+    /** Column definitions keyed by column code. Optional when a trait (e.g. `period`) supplies all columns. */
+    fields?: Record<string, FieldDef>;
+    /** Database constraints (unique, check, …); free-form per the schema. */
+    constraints?: Record<string, unknown>;
+    /** FK references (legacy format; prefer `link` on a field). */
+    references?: Record<string, EntityReference>;
+    /** Database index definitions; free-form per the schema. */
+    indexes?: Record<string, unknown>;
+    numberSequence?: NumberSequenceDef;
+    period?: PeriodConfig;
+    accumulation?: AccumulationConfig;
+    /** Entity-level platform behavior flags. */
+    params?: {
+        restricted?: boolean;
+    } & Record<string, unknown>;
+}
+
+/** `{ field, target }` for each Reference (R) column that declares a link. */
+declare function getLinks(entity: EntityDef): Array<{
+    field: string;
+    target: string;
+}>;
+/**
+ * Identity-trait primary-key column codes for `entityCode` (e.g. `invoice_id`),
+ * excluding any the author already declared explicitly. Empty unless the entity
+ * carries the `identity` trait.
+ */
+declare function getIdentityKeys(entity: EntityDef, entityCode: string): string[];
+/**
+ * All primary-key column codes: fields flagged `isPk`, plus identity-trait keys.
+ * Order is explicit-first, then identity keys; duplicates removed.
+ */
+declare function getPrimaryKeys(entity: EntityDef, entityCode: string): string[];
+
+/** `viewType` values for `ui/data_views.json`. Source: data_views.schema.json. */
+type ViewType = "grid" | "list" | "kanban" | "calendar" | "gallery" | "tree-grid" | "diagram" | "master-detail" | "library" | "matrix";
+/** Friendly picker list of the view kinds. */
+declare const dataViewKinds: readonly NamedKind[];
+/** A column in a data source: shorthand string code or a configured object. */
+type ViewColumn = string | {
+    /** Column code. */
+    column_cd: string;
+    /** Column width in pixels. */
+    width?: number;
+    /** Whether the column is visible (default true). */
+    visible?: boolean;
+    /** Pin column to an edge. */
+    pinned?: "left" | "right";
+};
+/** One data source within a view. */
+interface DataSource {
+    /** Entity code to query. */
+    entityCode: string;
+    /** Nesting level (0 = root, 1+ = detail). */
+    level?: number;
+    /** Human-readable label (used in master-detail tabs). */
+    label?: string;
+    /** Column configuration. */
+    columns?: ViewColumn[];
+    /** Set field on the parent entity linking to this detail level. */
+    parentSetField?: string;
+    /** Per-source filter; overrides the view-level filter for this source. */
+    filter?: Filter;
+    /** Per-source sort order (array of `{ c, d }` entries). */
+    order?: unknown;
+}
+interface KanbanViewConfig {
+    /** Dropdown/flags/reference column to group cards by. */
+    groupByField: string;
+}
+interface CalendarViewConfig {
+    /** Date/timestamp column used to place events. */
+    dateField: string;
+    /** Column shown as event title (defaults to the entity toString). */
+    titleField?: string;
+    /** Column whose value drives the event pill color. */
+    colorField?: string;
+}
+interface TreeGridViewConfig {
+    /** Self-referencing FK column (parent record). */
+    parentField: string;
+    /** Node label field (defaults to entity toString). */
+    labelField?: string;
+    /** Field containing a Bootstrap icon class per node. */
+    iconField?: string;
+}
+interface ListLevelConfig {
+    /** Entity code for this child level. */
+    entityCode: string;
+    /** FK column in the child entity linking back to the parent. */
+    foreignKey: string;
+    /** Columns to display inline for each child row. */
+    columns?: string[];
+}
+interface ListViewConfig {
+    titleField?: string;
+    subtitleField?: string;
+    /** Hierarchical child levels for expandable list rows. */
+    levels?: ListLevelConfig[];
+}
+interface DiagramViewConfig {
+    /** Column to group diagram nodes by. */
+    groupByField?: string;
+    /** Group values hidden by default. */
+    defaultHiddenGroups?: string[];
+}
+/** A single data view (value in the `ui/data_views.json` map). */
+interface DataViewDef {
+    viewType: ViewType;
+    /** Human-readable view name. */
+    label?: string;
+    /** Bootstrap icon class (e.g. 'bi-bounding-box'). */
+    icon?: string;
+    description?: string;
+    /** Data sources (at least one; master-detail needs two). */
+    dataSources: DataSource[];
+    /** Default filter applied to all sources unless one declares its own. */
+    filter?: Filter;
+    /** Default sort order. */
+    order?: unknown;
+    /** View-type-specific configuration. */
+    viewConfig?: KanbanViewConfig | CalendarViewConfig | TreeGridViewConfig | ListViewConfig | DiagramViewConfig | Record<string, unknown>;
+}
+/** A `ui/data_views.json` file: data view code → definition. */
+type DataViewsFile = Record<string, DataViewDef>;
+
+/** Report visualization types. Source: reports.schema.json (`vizType`). */
+type VizType = "table" | "chart" | "metric" | "pivot";
+/** Friendly picker list of report visualization types. */
+declare const vizTypes: readonly NamedKind[];
+/** Chart kinds used by report `config.chartType` (curated; rendered via Chart.js). */
+declare const chartTypes: readonly NamedKind[];
+/** A report parameter definition (report- or dataset-level). */
+interface ParamDef {
+    /** Field type code (see settings for the common list). */
+    fieldTypeCd: string;
+    label?: string;
+    /** Display order in the parameter form (falls back to declaration order). */
+    orderNum?: number;
+    /** Whether the user must provide a value. */
+    required?: boolean;
+    /** Alternate spelling of `required` used by some modules. Prefer `required`. */
+    isRequired?: boolean;
+    /** Default value applied when the user doesn't provide one. */
+    default?: unknown;
+    /** Entity link for lookup-type params. */
+    link?: {
+        entity: string;
+        otherKey?: string;
+    };
+    /** Field-type-specific params. */
+    params?: Record<string, unknown>;
+}
+/** SQL/entity query for a `datasetType: 'Q'` dataset. */
+interface ReportQuery {
+    /** Source entity code. */
+    entityCd: string;
+    /** Column codes to select (supports dot navigation: 'customer.name'). */
+    columns?: string[];
+    filter?: Filter;
+    sort?: SortClause[];
+}
+/** Per-column metadata override on a dataset. */
+interface ColumnDef {
+    label?: string;
+    visible?: boolean;
+    width?: number;
+}
+/** A report dataset (value in the report's `datasets` map). */
+interface Dataset {
+    /** Display label (used in panel headings if no `title`). */
+    caption?: string;
+    /** Q = SQL/entity query, S = stored procedure. */
+    datasetType: "Q" | "S";
+    /** Used when `datasetType` is 'Q'. */
+    query?: ReportQuery;
+    /** Used when `datasetType` is 'S'. */
+    procedureName?: string;
+    /** Optional column metadata overrides: field code → override. */
+    columnsDef?: Record<string, ColumnDef>;
+    /** Dataset-level parameters (alternative to report-level `parameters`). */
+    params?: Record<string, ParamDef>;
+}
+/** A single visualization panel within the report layout. */
+interface ReportPanel {
+    vizType: VizType;
+    /** Dataset code (key in the report's `datasets` map). */
+    datasetCd: string;
+    title?: string;
+    /** Viz-type-specific config (chart → { chartType, categoryCol, … }). */
+    config?: Record<string, unknown>;
+}
+interface ReportLayout {
+    panels: ReportPanel[];
+}
+/** A single report (value in the `ui/reports.json` map). */
+interface ReportDef {
+    /** Human-readable report title. */
+    description: string;
+    layout: ReportLayout;
+    /** Dataset code → dataset definition. */
+    datasets: Record<string, Dataset>;
+    /** Report-level parameters (alternative to per-dataset `params`). */
+    parameters?: Record<string, ParamDef>;
+}
+/** A `ui/reports.json` file: report code → definition. */
+type ReportsFile = Record<string, ReportDef>;
+
+/** Author block on a manifest. */
+interface ManifestAuthor {
+    name: string;
+    url?: string;
+}
+/** A dependency value: a semver range, or a partial-dep object. */
+type ModuleDependency = string | {
+    version: string;
+    entities?: string[];
+};
+/** A module package manifest (`manifest.json`). */
+interface ManifestDef {
+    /** Package format version (currently 1). */
+    packageFormat: number;
+    /** Globally unique module UUID. */
+    moduleId: string;
+    /** Human-readable module code (becomes the schema name and `module_cd`). */
+    code: string;
+    /** 'module' (default) or 'pack' (a dependency bundle owning no entities). */
+    kind?: "module" | "pack";
+    /** Module version (semver). */
+    version: string;
+    /** Database schema version (semver). */
+    dbSchemaVersion: string;
+    displayName: string;
+    description?: string;
+    /** Schema name override (defaults to `code`; system modules use 'dForge'). */
+    schemaName?: string;
+    /** System module flag (cannot be uninstalled, admin-only). Omit for regular modules. */
+    system?: boolean;
+    author?: ManifestAuthor;
+    /** License identifier (e.g. 'proprietary', 'MIT'). */
+    license?: string;
+    /** Module code → semver range or partial-dep object. */
+    dependencies?: Record<string, ModuleDependency>;
+    /** Default audit history mode for this module's entities. */
+    auditHistory?: "none" | "minimal" | "full";
+    /** Entity code → relative path of its JSON file (dotted keys = extensions). */
+    entities?: Record<string, string>;
+    /** Module category for display (e.g. 'Integration', 'Finance'). */
+    category?: string;
+    /** Free-form tags for search/discovery. */
+    tags?: string[];
+    /** Bootstrap icon class (e.g. 'bi-link-45deg'). */
+    icon?: string;
+    /** Non-English locales the package promises to translate. */
+    supportedLocales?: string[];
+    /** Initial creation date (YYYY-MM-DD). Informational. */
+    created?: string;
+    /** Last manifest edit date (YYYY-MM-DD). Informational. */
+    updated?: string;
+}
+
+/**
+ * Allowed storage-class tokens for a consumed column — Postgres type names with
+ * length/scale stripped. Closed allowlist, kept in lockstep with the `type` enum in
+ * `deps.schema.json` (and `DependencyContractValidator.ValidColumnTypes` on the C#
+ * side); the `schemas.test.ts` parity guard fails if this drifts from the schema.
+ * Extend all three together if a provider column legitimately uses a type not here.
+ */
+declare const DEP_COLUMN_TYPES: readonly ["int2", "int4", "int8", "smallint", "integer", "bigint", "numeric", "decimal", "float4", "float8", "real", "money", "varchar", "text", "char", "bpchar", "bool", "boolean", "date", "time", "timetz", "timestamp", "timestamptz", "uuid", "json", "jsonb", "bytea"];
+/**
+ * Storage class pinned for a consumed column — the provider's physical Postgres type
+ * with length/scale stripped (e.g. `int8`, `numeric`, `varchar`). dForge's `cuid`
+ * Snowflake PK normalizes to `int8`. Pinning the storage class (not a coarse base
+ * type) keeps FK/lookup compatibility meaningful — an `int8` key needs `int8`, not
+ * any number. One of {@link DEP_COLUMN_TYPES}.
+ */
+type DepColumnType = (typeof DEP_COLUMN_TYPES)[number];
+/** Whether the consumer reads or writes a column. Default `read`. */
+type DepColumnMode = "read" | "write";
+/** Kinds of cross-module usage a provenance token can name. */
+type DepProvenanceKind = "ref" | "extends" | "formula" | "action" | "view" | "report" | "print" | "role";
+/**
+ * A usage token of the form `<kind>:<symbol>` — e.g. `ref:invoice.customer`,
+ * `extends:party`, `action:check_credit`, `role:fin.admin`. Names the consuming
+ * symbol so the completeness lint can reconcile declared vs actual usage. Note:
+ * `display` is intentionally not a kind — the label is the provider's concern.
+ */
+type DepProvenance = `${DepProvenanceKind}:${string}`;
+/** A single consumed provider column. */
+interface DepColumn {
+    /** Storage class — the provider column's physical Postgres type, params stripped (`int8`, `varchar`, `numeric`, …). */
+    type: DepColumnType;
+    /** Per-column provenance: which symbols read/write/join on this column. */
+    use: DepProvenance[];
+    /** `write` implies an insert/update right + settable column. Default `read`; omit for reads. */
+    mode?: DepColumnMode;
+}
+/** What the consumer needs from one provider entity. */
+interface DepEntity {
+    /** The provider entity's PK column — the anchor every reference joins on. No label/display. */
+    pk: string;
+    /** Entity-level provenance: why this entity is consumed (ref/extends/role/view/report/print/action). */
+    use: DepProvenance[];
+    /** Provider columns actually read/written/joined. Omit for extension-only targets. */
+    columns?: Record<string, DepColumn>;
+}
+/** A `deps/<provider>.json` file: the consumer's contract against one dependency. */
+interface DepsFile {
+    /** Code of the dependency (provider) module this contract is against (e.g. `parties`). */
+    module: string;
+    /** Semver range the consumer requires of the provider (e.g. `>=0.1.0`). */
+    version: string;
+    /** Consumed provider entities, keyed by entity code. */
+    entities: Record<string, DepEntity>;
+}
+
+/** A single reusable column domain. */
+interface DomainDef {
+    /** Human-readable label. Localizable via `translations/<locale>.json` → `domains.<code>.label`. */
+    description?: string;
+    /**
+     * Base datatype the domain stands for. Required — it is what a consuming column's
+     * DDL is generated from.
+     */
+    baseDatatypeCd: BaseDatatypeCd;
+    /** Physical Postgres type for consuming columns; omit to infer from `fieldTypeCd`. */
+    dbDatatype?: string;
+    /** Control used to render/edit consuming columns (e.g. `dropdown`, `text`, `number`). */
+    fieldTypeCd?: FieldTypeCd;
+    /** Max length for string-backed domains. */
+    maxLen?: number;
+    /** Decimal precision for numeric domains. */
+    precision?: number;
+    /**
+     * Field-type config shared by every consuming column — most importantly the option
+     * list for `dropdown`/`radio`/`flags`. Never copied onto columns: it resolves from
+     * the domain at load time, which is what lets its labels be translated once for all
+     * consumers. Per-locale label/icon/color overrides live in `translations/<locale>.json`
+     * under `domains.<code>.options.<value>`.
+     */
+    params?: {
+        options?: (string | FieldOption)[];
+    } & Record<string, unknown>;
+}
+/** A `domains.json` file: reusable column domains keyed by domain code. */
+type DomainsFile = Record<string, DomainDef>;
+
+/** Menu item type: V=Data View, D=Document, R=Report, null=folder/section. */
+type MenuItemType = "V" | "D" | "R" | null;
+/** A menu item; folder/section nodes nest children and omit `itemType`. */
+interface MenuItemDef {
+    itemType?: MenuItemType;
+    /** Data view code (when `itemType` is 'V'). */
+    dataViewCode?: string;
+    /** Document code (when `itemType` is 'D'). */
+    documentCode?: string;
+    /** Report code (when `itemType` is 'R'). */
+    reportCode?: string;
+    orderNum?: number;
+    /** Display text. */
+    label: string;
+    description?: string;
+    /** Bootstrap icon name. */
+    icon?: string;
+    /** Child items keyed by item code (folder/section nodes). */
+    children?: Record<string, MenuItemDef>;
+}
+/** A menu (value in the `ui/menus.json` map). */
+interface MenuDef {
+    label: string;
+    description?: string;
+    /** Folder codes where this menu is available. */
+    folders?: string[];
+    /** Menu items keyed by item code. */
+    items: Record<string, MenuItemDef>;
+}
+/** A `ui/menus.json` file: menu code → definition. */
+type MenusFile = Record<string, MenuDef>;
+
+/** Per-entity binding within a folder. */
+interface FolderEntityBinding {
+    /** Data view code to use in this folder (commonly 'default'). */
+    viewName?: string;
+    /** Enable the quick-add (+) button for this entity here. */
+    quickAdd?: boolean;
+    /** Row-level filter: a SQL expression string or a canonical filter object. */
+    rowFilter?: string | Filter;
+}
+/** A folder node (the folders.json root, and each entry under `children`). */
+interface FolderDef {
+    label?: string;
+    description?: string;
+    /** Parent folder code (only used by sparse-tree imports; usually omitted). */
+    parentCode?: string | null;
+    /** URL-friendly folder path override. */
+    folderPath?: string;
+    /** Accent color (hex, e.g. '#2196F3'). */
+    color?: string;
+    /** Bootstrap icon class (e.g. 'bi-folder'). */
+    icon?: string;
+    /** Inherit security rights from the parent folder (default true). */
+    inheritSecurity?: boolean;
+    /** Entity code → folder-entity binding. */
+    entities?: Record<string, FolderEntityBinding>;
+    /** Nested folders keyed by sub-folder code (recursive). */
+    children?: Record<string, FolderDef>;
+}
+/** A `folders.json` file: the root folder itself. */
+type FoldersFile = FolderDef;
+
+/** A role with its entity rights (value in the roles map). */
+interface RoleDef {
+    /** Role display name. */
+    description: string;
+    /** Entity code → rights string. Rights: S/I/U/D/C/E (pattern ^[SIUDCE]*$). */
+    rights: Record<string, string>;
+}
+/** A `roles.json` file: role code → definition. */
+type RolesFile = Record<string, RoleDef>;
+
+/** Underlying primitive datatype for a setting. */
+type SettingBaseDatatype = "string" | "number" | "bool" | "date" | "dateTime" | "time" | "json";
+/** A single setting definition (value in the settings map). */
+interface SettingDef {
+    /** Field type code (must match a `dforge.field_type` code). */
+    fieldTypeCd: string;
+    /** Underlying primitive datatype (older settings declare this explicitly). */
+    baseDatatypeCd?: SettingBaseDatatype;
+    /** Display label (preferred for new settings). */
+    label?: string;
+    /** Display label (older style). Prefer `label`. */
+    description?: string;
+    /** Alternative older label key. Prefer `label`. */
+    desc?: string;
+    /** Default value before the user sets one. */
+    defaultValue?: unknown;
+    /** Formula to evaluate the default (alternative to `defaultValue`). */
+    formula?: string;
+    /** If true, must be set somewhere in the folder chain for install to proceed. */
+    required?: boolean;
+    /** Field-type-specific parameters (dropdown options, min/max, lookup link, …). */
+    params?: Record<string, unknown>;
+}
+/** A `settings.json` file: setting code → definition. */
+type SettingsFile = Record<string, SettingDef>;
+
+/** A single scheduled-job declaration. */
+interface JobDef {
+    /** Unique identifier within the module. */
+    code: string;
+    description?: string;
+    /** Action code in this module the scheduler fires. */
+    action: string;
+    /** Five-field cron expression (minute granularity). */
+    schedule: string;
+    /** Static parameters passed to the action as `__params`. */
+    params?: Record<string, unknown>;
+    /** Hard timeout in seconds (1–3600; > 300 requires class 'long_running'). */
+    timeout: number;
+    /** Max parallel runs (1–5; default 1). */
+    concurrency?: number;
+    /** Idempotency key template, e.g. '{job_cd}:{run.month}'. */
+    idempotencyKey?: string;
+    /** Routing class ('long_running' required for any timeout > 300s). */
+    class?: "standard" | "long_running";
+    /** IANA tz name overriding the tenant default. */
+    timeZone?: string;
+    /** Master switch (default true). */
+    enabled?: boolean;
+    /** Soft pause; admin 'trigger now' still works (default false). */
+    paused?: boolean;
+}
+/** A `logic/jobs.json` file. */
+interface JobsFile {
+    /** At most 50 jobs per module. */
+    jobs: JobDef[];
+}
+
+/** DB event a trigger or webhook watches. */
+type EntityEvent = "insert" | "update" | "delete" | "status_change" | "any";
+/** A single trigger declaration. */
+interface TriggerDef {
+    /** Trigger code, unique within the module. */
+    code: string;
+    description?: string;
+    /** Entity whose events this watches (cross-module via 'module.entity'). */
+    entity: string;
+    event: EntityEvent;
+    /** Optional `[field]`-syntax formula; trigger fires only when true. */
+    condition?: string;
+    /** Action code to invoke (cross-module form 'module.action' supported). */
+    action: string;
+    /** Static parameters passed to the action, merged with the injected record id. */
+    params?: Record<string, unknown>;
+    /**
+     * true: run in the background after the triggering tx commits (failures logged, not surfaced).
+     * false (default): run synchronously in the same tx — a failure rolls the mutation back and
+     * returns the error to the caller. Keep async:false actions fast.
+     */
+    async?: boolean;
+}
+/** A `logic/triggers.json` file. */
+interface TriggersFile {
+    triggers: TriggerDef[];
+}
+
+/** Outbound payload shaping for a webhook subscription. */
+interface WebhookPayload {
+    /** Field codes to include. If omitted, all visible fields are included. */
+    include?: string[];
+    /** Include previous field values on update/status_change events. */
+    includeOld?: boolean;
+}
+/** A single webhook subscription. */
+interface WebhookSubscription {
+    /** Unique identifier within the module. */
+    code: string;
+    description: string;
+    /** Entity code that triggers this webhook. */
+    entity: string;
+    event: EntityEvent;
+    /** Formula evaluated against the record; webhook fires only if true. */
+    condition?: string;
+    /** Default endpoint URL (admin can override). */
+    endpointUrl?: string;
+    /** Secret code for the API key (from `dforge.secret`). */
+    secretCd?: string;
+    payload?: WebhookPayload;
+    /** Enabled (default true). */
+    enabled?: boolean;
+}
+/** A `webhooks.json` file. */
+interface WebhooksFile {
+    subscriptions: WebhookSubscription[];
+}
+
+/** Page margins (CSS lengths, e.g. '15mm'). */
+interface PrintMargins {
+    top?: string;
+    right?: string;
+    bottom?: string;
+    left?: string;
+}
+/** Default page geometry applied when printing from the UI. */
+interface PrintPageSettings {
+    size?: "A4" | "letter" | "legal";
+    orientation?: "portrait" | "landscape";
+    margins?: PrintMargins;
+}
+/**
+ * A print template or snippet (value in the print_templates map).
+ * `type: 'template'` (default) is entity-bound; `type: 'snippet'` is a
+ * module-scoped Liquid partial included via {% include 'module.snippet' %}.
+ * Either `file` or `template` must be set (`file` wins when both are present).
+ */
+interface PrintTemplateDef {
+    type?: "template" | "snippet";
+    /** Entity code rendered. Required for templates; ignored for snippets. */
+    entityCd?: string;
+    /** Human-readable label shown in the print menu. */
+    description?: string;
+    /** Inline Liquid HTML. */
+    template?: string;
+    /** Relative path under the module's `print_templates/` directory. */
+    file?: string;
+    /** Inline CSS, or a `.css` filename resolved relative to `print_templates/`. */
+    css?: string;
+    pageSettings?: PrintPageSettings;
+}
+/** A `ui/print_templates.json` file: template_cd → definition. */
+type PrintTemplatesFile = Record<string, PrintTemplateDef>;
+
+/** A seed-data file: records to insert into one entity. */
+interface SeedDataFile {
+    /** Target entity code. */
+    entityCode: string;
+    /** Records to insert; each is a `column_code → value` map. */
+    records: Record<string, unknown>[];
+}
+
+/**
+ * Execution mode. 'single' (default) and 'each' run the DSL per selected record;
+ * 'batch' runs once with all records exposed as `__records`.
+ */
+type ActionExecutionMode = "single" | "each" | "batch";
+/** A single action declaration (value in the `ui/actions.json` map). */
+interface ActionDef {
+    /** Human-readable description. */
+    description: string;
+    /** Button label. */
+    label: string;
+    /** Bootstrap icon class (e.g. 'bi-telephone-check'). */
+    icon: string;
+    /** Entity code this action targets. */
+    entityCode: string;
+    /** Per-record vs. batch execution. */
+    executionMode: ActionExecutionMode;
+    /** DSL script name (file under `logic/actions/<script>.dsl`). */
+    script: string;
+    /** Run inside a transaction (failures roll back). */
+    isTransacted?: boolean;
+    /** Display order. */
+    orderNum?: number;
+    /** Run in the background (newer `async`; some modules use `isAsync`). */
+    async?: boolean;
+    /** Alternate spelling of `async` used by some modules. Prefer `async`. */
+    isAsync?: boolean;
+}
+/** A `ui/actions.json` file: action code → definition. */
+type ActionsFile = Record<string, ActionDef>;
+
+declare const flagDefs: readonly {
     value: "V" | "I" | "E" | "M" | "H";
     label: string;
 }[];
-//# sourceMappingURL=index.d.ts.map
+
+export { AGG_TYPE_LIST, type AccumulationConfig, type ActionDef, type ActionExecutionMode, type ActionsFile, AggType, type AlignType, type BaseDatatypeCd, type CalendarViewConfig, type ColumnDef, type ColumnTypeCd, type ColumnTypeDef, DEP_COLUMN_TYPES, type DataSource, type DataViewDef, type DataViewsFile, type Dataset, type DepColumn, type DepColumnMode, type DepColumnType, type DepEntity, type DepProvenance, type DepProvenanceKind, type DepsFile, type DeriveOptions, type DiagramViewConfig, type DomainDef, type DomainsFile, type EntityDef, type EntityEvent, type EntityReference, FILTER_GROUP_OPERATORS, FILTER_OPERATORS, type FieldDef, type FieldLink, type FieldOption, type FieldTypeCd, type FieldTypeDef, type Filter, type FilterCondition, type FilterGroup, type FilterGroupOperator, type FilterOperator, type FlagCd, type FolderDef, type FolderEntityBinding, type FoldersFile, type JobDef, type JobsFile, type KanbanViewConfig, type LedgerRegistryEntry, type ListLevelConfig, type ListViewConfig, type ManifestAuthor, type ManifestDef, type MenuDef, type MenuItemDef, type MenuItemType, type MenusFile, type ModuleDependency, NUMERIC_TOTAL, type NamedKind, type NumberSequenceDef, type ParamDef, type PeriodConfig, type PrintMargins, type PrintPageSettings, type PrintTemplateDef, type PrintTemplatesFile, type ReportDef, type ReportLayout, type ReportPanel, type ReportQuery, type ReportsFile, type RoleDef, type RolesFile, type SeedDataFile, type SettingBaseDatatype, type SettingDef, type SettingsFile, type SignConfig, type SortClause, type TraitCd, type TraitDef, type TreeGridViewConfig, type TriggerDef, type TriggersFile, type ViewColumn, type ViewType, type VizType, type WebhookPayload, type WebhookSubscription, type WebhooksFile, baseDatatypes, baseToDbDatatype, chartTypes, columnTypes, dataViewKinds, defaultParams, deriveBaseDatatype, deriveDbDatatype, expandTrait, expandTraits, fieldTypeCds, fieldTypes, fieldTypesByColumnType, flagDefs, getColumnType, getFieldType, getIdentityKeys, getLinks, getPrimaryKeys, getTrait, isFieldTypeCd, traits, vizTypes };