@ximatai/muyun-web-app 0.26.11 → 0.26.12

package/dist/types/views/businessRuleGovernance.d.ts

@@ -0,0 +1,201 @@
+export type BusinessRuleKind = 'CALCULATION' | 'VALIDATION' | 'UI_CONTROL';
+export interface BusinessRuleEditableField {
+    fieldName: string;
+    title: string;
+    fieldSpecAlias: string;
+    valueType: string;
+    /** Direct child fields declare the aggregate functions that can consume them. */
+    aggregateFunctions?: string[];
+}
+/**
+ * The page-reference-fields response is deliberately a small, UI-neutral catalogue.  Formula
+ * governance consumes it as a source directory; it does not treat it as a save-time authority.
+ */
+export interface BusinessRuleReferenceField {
+    id: string;
+    name: string;
+    label?: string;
+    valueType: string;
+    referenceModuleAlias?: string;
+    referenceCardinality?: string;
+    expandable?: boolean;
+    readOnly?: boolean;
+    systemManaged?: boolean;
+    value?: unknown;
+    /** Additive catalogue metadata; absent means use the stable conservative fallback below. */
+    formulaReadable?: boolean;
+    formulaDisabledReason?: string;
+    /** Direct child fields declare the aggregate functions that can consume them. */
+    aggregateFunctions?: string[];
+}
+export interface BusinessRuleFormulaParameter {
+    name: string;
+    description: string;
+}
+/** A portable formula capability. A server catalogue can replace this list without changing the surface. */
+export interface BusinessRuleFormulaCapability {
+    id: string;
+    label: string;
+    purpose: string;
+    /** Explains the business problem the formula solves before showing its example. */
+    description: string;
+    category: string;
+    signature: string;
+    parameters: BusinessRuleFormulaParameter[];
+    returnType: string;
+    example: string;
+    insertion: string;
+    firstParameterSelection: {
+        start: number;
+        end: number;
+    };
+}
+/** The additive backend catalogue shape. UI-only insertion details remain derived from the portable name. */
+export interface BusinessRuleFormulaCatalogEntry {
+    name: string;
+    category?: string;
+    title?: string;
+    description?: string;
+    parameters?: BusinessRuleFormulaParameter[];
+    returnType?: string;
+    example?: string;
+}
+export declare const portableFormulaCapabilities: readonly BusinessRuleFormulaCapability[];
+export declare function normalizeFormulaCapabilities(entries: readonly (BusinessRuleFormulaCapability | BusinessRuleFormulaCatalogEntry)[] | undefined): BusinessRuleFormulaCapability[];
+export declare function searchableFormulaCapabilities(capabilities: readonly BusinessRuleFormulaCapability[], keyword: string): BusinessRuleFormulaCapability[];
+/** Root fields that cannot safely become scalar formula input have a visible, deterministic reason. */
+export declare function formulaFieldUnusableReason(field: BusinessRuleReferenceField): string | undefined;
+/**
+ * Prevents a child field from being inserted as a scalar or into an aggregate whose value type
+ * cannot consume it. The server remains authoritative; this only keeps authoring feedback close
+ * to the attempted insertion.
+ */
+export declare function aggregateFieldInsertionReason(field: BusinessRuleReferenceField, expression: string, selectionStart: number): string | undefined;
+export interface UiControlTarget {
+    elementKey: string;
+    hide: boolean;
+    readOnly: boolean;
+}
+export interface UiControlForm {
+    key: string;
+    title: string;
+    elements: Array<{
+        key: string;
+        label: string;
+    }>;
+}
+export interface UiControlSnapshot {
+    baselineFingerprint: string;
+    rules: Array<{
+        code: string;
+        formKey: string;
+        expression: string;
+        enabled: boolean;
+        targets: UiControlTarget[];
+    }>;
+    forms: UiControlForm[];
+}
+export interface BusinessRuleSnapshotRule {
+    formKey?: string;
+    targets?: UiControlTarget[];
+    code: string;
+    kind: BusinessRuleKind | string;
+    phase: string;
+    targetField?: string;
+    expression: string;
+    enabled: boolean;
+    severity?: string;
+    messageTemplate?: string;
+    stopOnError?: boolean;
+    editable: boolean;
+    readOnlyReason?: string;
+}
+export interface BusinessRuleSnapshot {
+    moduleAlias: string;
+    baselineFingerprint: string;
+    editableFields: BusinessRuleEditableField[];
+    /** Already authorised referenced paths used by the persisted snapshot. These are read-only trial facts. */
+    referenceFields?: Array<{
+        path: string;
+        title: string;
+        valueType: string;
+    }>;
+    /** Direct child fields, which may only appear within a child aggregation function. */
+    aggregateFields?: BusinessRuleEditableField[];
+    /** Additive portable function directory emitted by the server. */
+    functions?: BusinessRuleFormulaCatalogEntry[];
+    rules: BusinessRuleSnapshotRule[];
+}
+export interface BusinessRuleProposal {
+    formKey?: string;
+    targets?: UiControlTarget[];
+    code: string;
+    kind: BusinessRuleKind;
+    targetField?: string;
+    expression: string;
+    enabled: boolean;
+    messageTemplate?: string;
+}
+export interface BusinessRuleIssue {
+    code: string;
+    ruleCode?: string;
+    field?: string;
+    message: string;
+}
+export interface BusinessRulePreview {
+    snapshot: BusinessRuleSnapshot;
+    proposalFingerprint: string;
+    executionOrder: string[];
+    errors: BusinessRuleIssue[];
+}
+export interface BusinessRuleTrialResult {
+    preview: BusinessRulePreview;
+    values: Record<string, unknown>;
+    changedFields: string[];
+    errors: BusinessRuleIssue[];
+}
+export interface BusinessRuleApplyResult {
+    snapshot: BusinessRuleSnapshot;
+    preview: BusinessRulePreview;
+    activatedModules: string[];
+}
+export interface FormulaInsertion {
+    value: string;
+    selectionStart: number;
+    selectionEnd: number;
+}
+export interface BusinessRuleChangeImpact {
+    added: BusinessRuleProposal[];
+    modified: BusinessRuleProposal[];
+    deleted: BusinessRuleProposal[];
+}
+export interface BusinessRuleFormulaTemplate {
+    id: string;
+    label: string;
+    expression: string;
+    help: string;
+}
+export declare function editableProposals(snapshot: BusinessRuleSnapshot): BusinessRuleProposal[];
+export declare function readonlyRules(snapshot: BusinessRuleSnapshot): BusinessRuleSnapshotRule[];
+export declare function toProposal(rule: Pick<BusinessRuleSnapshotRule, keyof BusinessRuleProposal>): BusinessRuleProposal;
+export declare function newBusinessRule(kind: BusinessRuleKind, existingRules: readonly Pick<BusinessRuleProposal, 'code'>[]): BusinessRuleProposal;
+export declare function isBusinessRuleKind(value: string): value is BusinessRuleKind;
+export declare function proposalFingerprintOf(proposals: readonly BusinessRuleProposal[]): string;
+export declare function typedSampleValue(value: string, valueType: string): unknown;
+/**
+ * Inserts formula text at the active selection. The returned selection keeps the editor focused
+ * immediately after the inserted text, including when a selected range was replaced.
+ */
+export declare function insertFormulaText(expression: string, selectionStart: number | undefined, selectionEnd: number | undefined, text: string): FormulaInsertion;
+/** Reads only real field tokens; references inside string literals are formula text, not dependencies. */
+export declare function referencedFormulaFields(expression: string): string[];
+/** Replaces only executable field tokens with their business names for read-only UI summaries. */
+export declare function presentableFormulaExpression(expression: string, fields: readonly BusinessRuleEditableField[]): string;
+/**
+ * Trial inputs are the real external dependencies of all enabled rules. Targets produced by an
+ * enabled calculation are intentionally omitted, including targets referenced by a later rule.
+ */
+export declare function externalTrialInputFields(fields: readonly BusinessRuleEditableField[], rules: readonly BusinessRuleProposal[]): BusinessRuleEditableField[];
+export declare function filterBusinessRuleFields(fields: readonly BusinessRuleEditableField[], keyword: string): BusinessRuleEditableField[];
+export declare function formulaTemplates(kind: BusinessRuleKind, fields: readonly BusinessRuleEditableField[], targetField?: string): BusinessRuleFormulaTemplate[];
+export declare function businessRuleChangeImpact(snapshot: BusinessRuleSnapshot, proposals: readonly BusinessRuleProposal[]): BusinessRuleChangeImpact;

package/dist/types/views/metadataModelEditSession.d.ts

@@ -0,0 +1,75 @@
+import type { MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
+import { type MetadataFieldPropertyDraft, type MetadataFieldPropertySummary } from './metadataOrchestrationState';
+export type MetadataFieldGovernanceKind = 'BUSINESS' | 'CAPABILITY_DERIVED' | 'PLATFORM_SYSTEM' | 'RELATION_FOREIGN_KEY';
+export interface MetadataFieldChangeSetDraft {
+    operation: 'ADD' | 'UPDATE' | 'DELETE';
+    fieldId?: string;
+    expectedFieldVersion?: number;
+    field?: MetadataField;
+    /** JSON-facing command contract; projection mappings remain an ordered string array. */
+    property?: MetadataFieldPropertyChangeSetPayload;
+}
+export type MetadataFieldPropertyChangeSetPayload = MetadataFieldPropertyDraft;
+export declare function toFieldPropertyChangeSetPayload(property: MetadataFieldPropertyDraft): MetadataFieldPropertyChangeSetPayload;
+export interface MetadataRelationChangeSetProposal {
+    expectedMetadataVersion: number;
+    fieldDrafts: MetadataFieldChangeSetDraft[];
+}
+/** Input facts are loaded for every node before a module-wide edit session begins. */
+export interface MetadataModelRelationDraftSource {
+    relationId: string;
+    metadataId: string;
+    parentMetadataId?: string;
+    sortOrder?: number;
+    expectedMetadataVersion: number;
+    fields: MetadataField[];
+    /** The server's sortable set; definition protection does not restrict display ordering. */
+    sortableFieldIds?: string[];
+    fieldProperties?: MetadataFieldPropertySummary[];
+}
+export interface MetadataModelRelationDraft {
+    metadataId: string;
+    relationId: string;
+    expectedMetadataVersion: number;
+    fields: Record<string, MetadataField>;
+    fieldProperties: Record<string, MetadataFieldPropertyDraft>;
+    parentMetadataId?: string;
+    fieldOrder: string[];
+    sortableFieldIds: string[];
+}
+export interface MetadataModelChangeSetProposal {
+    relationDrafts: Array<MetadataRelationChangeSetProposal & {
+        relationId: string;
+    }>;
+    relationOrders: Array<{
+        parentMetadataId?: string;
+        relationIds: string[];
+    }>;
+    fieldOrders: Array<{
+        relationId: string;
+        fieldIds: string[];
+    }>;
+}
+/**
+ * A single local session for the entire visible metadata model.  It deliberately reuses the
+ * relation-level field proposal shape: the module façade owns atomic validation/persistence while
+ * this class keeps every tree action local until the user chooses one publish operation.
+ */
+export declare function createMetadataModelWorkspaceEditSession(): {
+    draft: import("vue").Ref<Record<string, MetadataModelRelationDraft> | undefined, Record<string, MetadataModelRelationDraft> | undefined>;
+    relationOrder: import("vue").Ref<Record<string, string[]>, Record<string, string[]>>;
+    editing: import("vue").ComputedRef<boolean>;
+    isDirty: import("vue").ComputedRef<boolean>;
+    begin: (sources: MetadataModelRelationDraftSource[]) => void;
+    cancel: () => void;
+    relation: (relationId: string) => MetadataModelRelationDraft | undefined;
+    fieldsForDisplay: (relationId: string, fallback: MetadataField[]) => MetadataField[];
+    propertyForField: (relationId: string, field: MetadataField) => MetadataFieldPropertyDraft;
+    stageField: (relationId: string, field: MetadataField, property?: MetadataFieldPropertyDraft, replaceNewFieldKey?: string) => void;
+    stageFieldOrder: (relationId: string, fieldIds: string[]) => void;
+    stageRelationOrder: (parentMetadataId: string | undefined, relationIds: string[]) => void;
+    buildProposal: () => MetadataModelChangeSetProposal | undefined;
+};
+export declare function metadataFieldGovernanceKind(field: MetadataField, relation: ModuleMetadataRelation | undefined, capabilityFieldNames: ReadonlySet<string>): MetadataFieldGovernanceKind;
+export declare function metadataFieldGovernanceLabel(kind: MetadataFieldGovernanceKind): string;
+export declare function isSessionEditableMetadataField(field: MetadataField, relation: ModuleMetadataRelation | undefined, capabilityFieldNames: ReadonlySet<string>): boolean;

package/dist/types/views/metadataModelTree.d.ts

@@ -0,0 +1,40 @@
+import type { Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
+import type { UiTreeDropEvent, UiTreeNode } from '../vue-ui-antdv/index';
+export type MetadataModelTreeNodeKind = 'METADATA' | 'FIELD';
+export interface MetadataModelTreeNode extends UiTreeNode {
+    modelKind: MetadataModelTreeNodeKind;
+    relationId?: string;
+    fieldId?: string;
+    /** Parent relation, not the visual root. It makes the reorder boundary explicit. */
+    parentRelationId?: string;
+    /** Locked nodes are intentionally visible but never draggable. */
+    draggable?: boolean;
+}
+export interface MetadataModelTreeInput {
+    relations: ModuleMetadataRelation[];
+    metadataById: Record<string, Metadata>;
+    fieldsByRelation: Record<string, MetadataField[]>;
+    fieldLocked: (relation: ModuleMetadataRelation, field: MetadataField) => boolean;
+}
+/**
+ * The governance tree is a projection of the model, not a second persistence shape. Metadata
+ * branches and field leaves retain their relation/field identities so the page can route to
+ * strongly typed cards. The explorer title already states "元数据", so entity nodes are roots
+ * rather than being wrapped in a redundant virtual node.
+ */
+export declare function buildMetadataModelTree(input: MetadataModelTreeInput): MetadataModelTreeNode[];
+export declare function metadataNodeKey(relationId: string): string;
+export declare function fieldNodeKey(relationId: string, fieldId: string): string;
+export declare function parseMetadataModelTreeKey(key: string): {
+    kind: 'METADATA';
+    relationId: string;
+} | {
+    kind: 'FIELD';
+    relationId: string;
+    fieldId: string;
+} | undefined;
+/** Only same-parent gap drops are legal. Dropping "on" a node would imply changing model structure. */
+export declare function canReorderMetadataModelTree(event: UiTreeDropEvent): boolean;
+export declare function reorderedIds<T extends {
+    id?: string;
+}>(items: T[], sourceId: string, targetId: string, place: -1 | 1): string[];

package/dist/types/views/metadataNaming.d.ts

@@ -0,0 +1,7 @@
+import type { MetadataFieldPropertyKind } from './metadataOrchestrationState';
+export declare function physicalNameOf(fieldName?: string): string;
+export declare function generatedFieldName(title?: string): string;
+/** Default names for newly created business fields; runtime semantics remain metadata-driven. */
+export declare function generatedBusinessFieldName(title: string | undefined, kind: MetadataFieldPropertyKind): string;
+/** Metadata identifiers use lower snake case; they are stable after explicit editing. */
+export declare function generatedMetadataAlias(title: string, maxLength?: number): string;

package/dist/types/views/metadataOrchestrationState.d.ts

@@ -1,7 +1,7 @@
 import type { FieldSpec, Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
 import type { RecordExplorerItemDescriptor } from '../platform-components/recordExplorerItemModel';
 /** Editor lifecycle of the metadata orchestration workspace. */
-export type MetadataOrchestrationMode = 'view' | 'create-main' | 'create-field' | 'edit-field';
+export type MetadataOrchestrationMode = 'view' | 'create-main' | 'create-field' | 'create-reference-field' | 'create-dictionary-field' | 'edit-field';
 export interface MainMetadataDraft {
     alias: string;
     title: string;
@@ -10,6 +10,52 @@ export interface MainMetadataDraft {
     dataScopeEnabled: boolean;
 }
 export type MetadataFieldDraft = Partial<MetadataField>;
+/**
+ * A field's business property is distinct from its physical field specification.  For example,
+ * a reference can still use a short-text column to store a target key.
+ */
+export type MetadataFieldPropertyKind = 'BASIC' | 'MODULE_REFERENCE' | 'DICTIONARY' | 'LEGACY_LOCKED';
+export interface MetadataFieldReferencePropertyConfig {
+    targetModuleAlias?: string;
+    targetMetadataId?: string;
+    targetKeyField?: string;
+    targetLabelField?: string;
+    cardinality?: 'ONE' | 'MANY';
+    targetUnavailablePolicy?: 'PRESERVE_HISTORY' | 'RESTRICT' | 'CASCADE_DELETE';
+    projectionMappings?: string[];
+}
+export interface MetadataFieldDictionaryPropertyConfig {
+    dictionaryApplicationAlias?: string;
+    dictionaryCategoryAlias?: string;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
+}
+/**
+ * The platform field-spec catalog owns these stable storage shapes.  A property editor must
+ * select a legal shape rather than exposing every scalar type as a possible reference/dictionary
+ * backing store.
+ */
+export declare function storageFieldSpecAliasOf(kind: MetadataFieldPropertyKind, selectionMode?: MetadataFieldDictionaryPropertyConfig['selectionMode']): string | undefined;
+export interface MetadataFieldPropertyDraft {
+    kind: MetadataFieldPropertyKind;
+    expectedBindingVersion?: number;
+    referenceConfig?: MetadataFieldReferencePropertyConfig;
+    dictionaryConfig?: MetadataFieldDictionaryPropertyConfig;
+}
+/** Relation-scoped property facts supplied by the module-governance read model. */
+export interface MetadataFieldPropertySummary extends MetadataFieldPropertyDraft {
+    fieldId?: string;
+    fieldName?: string;
+    fieldSpecAlias?: string;
+    bindingVersion?: number;
+    legacyReason?: string;
+    /** Transport shape of the relation-scoped property summary. */
+    reference?: MetadataFieldReferencePropertyConfig;
+    dictionary?: {
+        applicationAlias?: string;
+        categoryAlias?: string;
+        selectionMode?: 'SINGLE' | 'MULTIPLE';
+    };
+}
 export interface FieldSpecOption {
     value: string;
     label: string;
@@ -19,7 +65,7 @@ export declare function createMetadataOrchestrationState(): {
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -38,7 +84,7 @@ export declare function createMetadataOrchestrationState(): {
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -111,6 +157,61 @@ export declare function createMetadataOrchestrationState(): {
         updatedBy?: string | undefined;
         updatedAt?: string | undefined;
     }[]>;
+    allFields: import("vue").Ref<{
+        metadataId?: string | undefined;
+        fieldName?: string | undefined;
+        columnName?: string | undefined;
+        fieldSpecAlias?: string | undefined;
+        fieldOwnership?: string | undefined;
+        fieldForm?: string | undefined;
+        ownerFieldId?: string | undefined;
+        fieldRole?: string | undefined;
+        systemManaged?: boolean | undefined;
+        required?: boolean | undefined;
+        uniqueField?: boolean | undefined;
+        indexed?: boolean | undefined;
+        sortableField?: boolean | undefined;
+        titleField?: boolean | undefined;
+        enabled?: boolean | undefined;
+        sortOrder?: number | undefined;
+        title?: string | undefined;
+        id?: string | undefined;
+        tenantId?: string | undefined;
+        version?: number | undefined;
+        deleted?: boolean | undefined;
+        deletedAt?: string | undefined;
+        createdBy?: string | undefined;
+        createdAt?: string | undefined;
+        updatedBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }[], MetadataField[] | {
+        metadataId?: string | undefined;
+        fieldName?: string | undefined;
+        columnName?: string | undefined;
+        fieldSpecAlias?: string | undefined;
+        fieldOwnership?: string | undefined;
+        fieldForm?: string | undefined;
+        ownerFieldId?: string | undefined;
+        fieldRole?: string | undefined;
+        systemManaged?: boolean | undefined;
+        required?: boolean | undefined;
+        uniqueField?: boolean | undefined;
+        indexed?: boolean | undefined;
+        sortableField?: boolean | undefined;
+        titleField?: boolean | undefined;
+        enabled?: boolean | undefined;
+        sortOrder?: number | undefined;
+        title?: string | undefined;
+        id?: string | undefined;
+        tenantId?: string | undefined;
+        version?: number | undefined;
+        deleted?: boolean | undefined;
+        deletedAt?: string | undefined;
+        createdBy?: string | undefined;
+        createdAt?: string | undefined;
+        updatedBy?: string | undefined;
+        updatedAt?: string | undefined;
+    }[]>;
     fieldSpecs: import("vue").Ref<{
         alias?: string | undefined;
         fieldType?: string | undefined;
@@ -121,6 +222,7 @@ export declare function createMetadataOrchestrationState(): {
         queryOperators?: string[] | undefined;
         defaultUiControlAlias?: string | undefined;
         uiControlAliases?: string[] | undefined;
+        safeTargetFieldSpecAliases?: string[] | undefined;
         enabled?: boolean | undefined;
         sortOrder?: number | undefined;
         title?: string | undefined;
@@ -143,6 +245,7 @@ export declare function createMetadataOrchestrationState(): {
         queryOperators?: string[] | undefined;
         defaultUiControlAlias?: string | undefined;
         uiControlAliases?: string[] | undefined;
+        safeTargetFieldSpecAliases?: string[] | undefined;
         enabled?: boolean | undefined;
         sortOrder?: number | undefined;
         title?: string | undefined;
@@ -225,11 +328,46 @@ export declare function createMetadataOrchestrationState(): {
         updatedBy?: string | undefined;
         updatedAt?: string | undefined;
     }>;
+    fieldPropertyDraft: import("vue").Ref<{
+        kind: MetadataFieldPropertyKind;
+        expectedBindingVersion?: number | undefined;
+        referenceConfig?: {
+            targetModuleAlias?: string | undefined;
+            targetMetadataId?: string | undefined;
+            targetKeyField?: string | undefined;
+            targetLabelField?: string | undefined;
+            cardinality?: "ONE" | "MANY" | undefined;
+            targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            projectionMappings?: string[] | undefined;
+        } | undefined;
+        dictionaryConfig?: {
+            dictionaryApplicationAlias?: string | undefined;
+            dictionaryCategoryAlias?: string | undefined;
+            selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
+        } | undefined;
+    }, MetadataFieldPropertyDraft | {
+        kind: MetadataFieldPropertyKind;
+        expectedBindingVersion?: number | undefined;
+        referenceConfig?: {
+            targetModuleAlias?: string | undefined;
+            targetMetadataId?: string | undefined;
+            targetKeyField?: string | undefined;
+            targetLabelField?: string | undefined;
+            cardinality?: "ONE" | "MANY" | undefined;
+            targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            projectionMappings?: string[] | undefined;
+        } | undefined;
+        dictionaryConfig?: {
+            dictionaryApplicationAlias?: string | undefined;
+            dictionaryCategoryAlias?: string | undefined;
+            selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
+        } | undefined;
+    }>;
     selectedRelation: import("vue").ComputedRef<{
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
         relationAlias?: string | undefined;
-        relationRole?: "MAIN" | "CHILD" | undefined;
+        relationRole?: "main" | "child" | "MAIN" | "CHILD" | undefined;
         parentMetadataId?: string | undefined;
         foreignKey?: string | undefined;
         autoPopulate?: boolean | undefined;
@@ -257,8 +395,9 @@ export declare function createMetadataOrchestrationState(): {
     selectRelation: (relation: ModuleMetadataRelation) => boolean;
     focusRelation: (relationId: string | undefined) => void;
     startCreateMain: () => void;
-    startCreateField: () => void;
-    startEditField: (field: MetadataField) => void;
+    startCreateField: (kind?: MetadataFieldPropertyKind) => void;
+    startEditField: (field: MetadataField, property?: MetadataFieldPropertyDraft) => void;
+    startConfigureFieldProperty: (field: MetadataField, kind: Exclude<MetadataFieldPropertyKind, "BASIC" | "LEGACY_LOCKED">) => void;
     cancelEditor: () => void;
 };
 export type MetadataOrchestrationState = ReturnType<typeof createMetadataOrchestrationState>;
@@ -266,13 +405,29 @@ export declare function emptyMainMetadataDraft(): MainMetadataDraft;
 export declare function normalizeMainMetadataDraft(draft: MainMetadataDraft): MainMetadataDraft;
 export declare function isValidMainMetadataDraft(draft: MainMetadataDraft): boolean;
 export declare function emptyFieldDraft(): MetadataFieldDraft;
+export declare function emptyFieldPropertyDraft(kind: MetadataFieldPropertyKind): MetadataFieldPropertyDraft;
+export declare function copyFieldPropertyDraft(property: MetadataFieldPropertyDraft): MetadataFieldPropertyDraft;
+/** Converts the read-model's concise bindings into the draft contract accepted by change sets. */
+export declare function propertyDraftFromSummary(summary: MetadataFieldPropertySummary): MetadataFieldPropertyDraft;
 export declare function copyMetadataField(field: MetadataField): MetadataFieldDraft;
 export declare function isValidFieldDraft(draft: MetadataFieldDraft): boolean;
 export declare function normalizeFieldDraft(draft: MetadataFieldDraft): MetadataFieldDraft;
+export declare function normalizeFieldPropertyDraft(property: MetadataFieldPropertyDraft): MetadataFieldPropertyDraft;
+export declare function isValidFieldPropertyDraft(property: MetadataFieldPropertyDraft): boolean;
+export declare function metadataFieldPropertyLabel(kind: MetadataFieldPropertyKind): string;
+export declare function metadataFieldPropertySummary(property: MetadataFieldPropertyDraft): string;
 /** Only business-owned physical fields are orchestrated; platform-managed fields stay hidden. */
 export declare function orchestratableFields(fields: MetadataField[]): MetadataField[];
+/** Only these field facts may be changed through the metadata field editor. */
+export declare function isOrchestratableField(field: MetadataField): boolean;
 export declare function fieldSpecOptionListOf(specs: FieldSpec[]): FieldSpecOption[];
+/** Filters a populated entity to the source specification's server-declared safe targets. */
+export declare function dataSafeFieldSpecOptions(specs: FieldSpec[], currentAlias?: string): FieldSpecOption[];
+/** Use the catalog title for human-facing metadata surfaces; aliases remain stable machine identities. */
+export declare function fieldSpecDisplayLabel(fieldSpecAlias: string | undefined, specs: FieldSpec[]): string;
 export declare function entityTitleOf(relation: ModuleMetadataRelation, metadata: Metadata | undefined): string;
 export declare function relationRoleTag(role: ModuleMetadataRelation['relationRole']): string | undefined;
+/** Java code enums are serialized by their stable lower-case code in runtime responses. */
+export declare function isMainRelation(role: ModuleMetadataRelation['relationRole'] | undefined): boolean;
 export declare function entityExplorerItem(relation: ModuleMetadataRelation, metadata: Metadata | undefined): RecordExplorerItemDescriptor;
 export declare function metadataSubtitleOf(metadata: Metadata | undefined): string | undefined;

package/dist/types/views/metadataSourceTree.d.ts

@@ -0,0 +1,10 @@
+import type { UiTreeNode } from '../vue-ui-antdv/index';
+/** Shared metadata presentation; consumers supply actions and capability restrictions. */
+export declare function metadataSourceFieldNode(field: {
+    title: string;
+    fieldName: string;
+    platformReadOnly?: boolean;
+    referenceModuleAlias?: string;
+    expandable?: boolean;
+}, options: Pick<UiTreeNode, 'key'> & Partial<UiTreeNode>): UiTreeNode;
+export declare function metadataSourceRoot(title: string, children: UiTreeNode[]): UiTreeNode;

package/dist/types/views/moduleGovernanceWorkspaceView.d.ts

@@ -0,0 +1,9 @@
+export declare const moduleGovernanceTabs: readonly ["overview", "metadata", "actions", "rules", "ui", "preview"];
+export type ModuleGovernanceTab = (typeof moduleGovernanceTabs)[number];
+export interface ModuleGovernanceWorkspaceViewInput {
+    moduleAlias: string;
+    moduleTitle?: string;
+    governanceTab?: ModuleGovernanceTab;
+}
+/** The module-scoped home for configuration governance surfaces. */
+export declare const moduleGovernanceWorkspaceView: import("../platform-workbench/workspaceViewContract.ts").WorkspaceViewDefinition<ModuleGovernanceWorkspaceViewInput>;