@ximatai/muyun-web-app 0.26.14 → 0.26.16

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

@@ -1,122 +1,4 @@
 import { type AssistantCapability, type AssistantSurface, type AssistantTurnRequester } from '../web-core/index';
-import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
-import type { MetadataChangeSetPreview } from './metadataModelChangeSetClient';
-export interface MetadataGovernanceAssistantModelSummary {
-    moduleAlias: string;
-    moduleTitle?: string;
-    relationCount: number;
-    selectedRelation?: {
-        relationId: string;
-        title?: string;
-        fieldCount: number;
-        fields: Array<{
-            fieldName: string;
-            title?: string;
-            fieldSpecAlias?: string;
-            propertyKind: string;
-            governance: string;
-        }>;
-        truncated: boolean;
-    };
-    draft: {
-        active: boolean;
-        dirty: boolean;
-        editorOpen: boolean;
-    };
-    fieldSpecs: Array<{
-        alias: string;
-        title?: string;
-    }>;
-}
-export interface AddMetadataFieldDraftInput {
-    title: string;
-    fieldName?: string;
-    fieldSpecAlias: string;
-    required?: boolean;
-    unique?: boolean;
-    indexed?: boolean;
-    sortable?: boolean;
-    titleField?: boolean;
-}
-export interface UpdateMetadataFieldDraftInput {
-    fieldName: string;
-    title?: string;
-    fieldSpecAlias?: string;
-    required?: boolean;
-    unique?: boolean;
-    indexed?: boolean;
-    sortable?: boolean;
-    titleField?: boolean;
-    enabled?: boolean;
-}
-export type MetadataPropertyFieldKind = 'MODULE_REFERENCE' | 'DICTIONARY';
-export interface FindMetadataFieldTargetsInput {
-    kind: MetadataPropertyFieldKind;
-    keyword?: string;
-}
-export interface AddMetadataPropertyFieldDraftInput {
-    kind: MetadataPropertyFieldKind;
-    title: string;
-    fieldName?: string;
-    target: string;
-    selectionMode?: 'SINGLE' | 'MULTIPLE';
-    required?: boolean;
-}
-export interface PreparedMetadataPropertyFieldDraft {
-    relationId: string;
-    kind: MetadataPropertyFieldKind;
-    title: string;
-    fieldName: string;
-    columnName: string;
-    fieldSpecAlias: string;
-    required: boolean;
-    reference?: {
-        targetModuleAlias: string;
-        targetMetadataId?: string;
-        targetKeyField: string;
-        targetLabelField: string;
-    };
-    dictionary?: {
-        applicationAlias: string;
-        categoryAlias: string;
-        selectionMode: 'SINGLE' | 'MULTIPLE';
-    };
-}
-export interface MetadataGovernanceAssistantAdapter {
-    summary(): MetadataGovernanceAssistantModelSummary;
-    proposal(): MetadataModelChangeSetProposal | undefined;
-    preview(proposal: MetadataModelChangeSetProposal, signal: AbortSignal): Promise<MetadataChangeSetPreview>;
-    fieldSpecAliases(): string[];
-    editableBasicFieldNames(): string[];
-    addFieldDraft?(input: AddMetadataFieldDraftInput): {
-        relationId: string;
-        fieldName: string;
-        columnName: string;
-        title: string;
-        fieldSpecAlias: string;
-    };
-    updateFieldDraft?(input: UpdateMetadataFieldDraftInput): {
-        relationId: string;
-        fieldName: string;
-        title?: string;
-        fieldSpecAlias?: string;
-    };
-    findFieldTargets?(input: FindMetadataFieldTargetsInput, signal: AbortSignal): Promise<{
-        targets: Array<{
-            target: string;
-            title?: string;
-        }>;
-        truncated: boolean;
-    }>;
-    preparePropertyFieldDraft?(input: AddMetadataPropertyFieldDraftInput, signal: AbortSignal): Promise<PreparedMetadataPropertyFieldDraft>;
-    commitPropertyFieldDraft?(prepared: PreparedMetadataPropertyFieldDraft): {
-        relationId: string;
-        kind: MetadataPropertyFieldKind;
-        fieldName: string;
-        columnName: string;
-        title: string;
-        fieldSpecAlias: string;
-        target: string;
-    };
-}
+import type { MetadataGovernanceEditor as MetadataGovernanceAssistantAdapter } from './metadataGovernanceEditor';
+export type { MetadataGovernanceSummary as MetadataGovernanceAssistantModelSummary, AddMetadataFieldDraftInput, UpdateMetadataFieldDraftInput, MetadataPropertyFieldKind, FindMetadataFieldTargetsInput, AddMetadataPropertyFieldDraftInput, PreparedMetadataPropertyFieldDraft, MetadataFieldCandidate, MetadataFieldPlanInput, MetadataGovernanceEditor as MetadataGovernanceAssistantAdapter, } from './metadataGovernanceEditor';
 export declare function createMetadataGovernanceAssistantSurface(adapter: MetadataGovernanceAssistantAdapter, requestTurn: AssistantTurnRequester, contributedCapabilities?: () => AssistantCapability[]): AssistantSurface;

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

@@ -0,0 +1,224 @@
+import { type LanguageContext } from '../web-core/index';
+import type { MetadataField } from '../web-contracts/index';
+import type { OperationProposal } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+import type { MetadataChangeSetPreview } from './metadataModelChangeSetClient';
+import type { MetadataFieldReferencePropertyConfig } from './metadataOrchestrationState';
+export interface MetadataGovernanceSummary {
+    moduleAlias: string;
+    moduleTitle?: string;
+    factsAvailable?: boolean;
+    submissionStatus?: 'idle' | 'unknown' | 'current-read';
+    committedNeedsReload?: boolean;
+    relationCount: number;
+    selectedRelation?: {
+        relationId: string;
+        title?: string;
+        fieldCount: number;
+        fieldsSource?: 'SAVED_CONFIGURATION' | 'UNSAVED_CANDIDATE';
+        fields: Array<Pick<MetadataField, 'required' | 'uniqueField' | 'indexed' | 'sortableField' | 'titleField' | 'enabled'> & {
+            fieldName: string;
+            columnName?: string;
+            title?: string;
+            fieldSpecAlias?: string;
+            defaultValue?: string | null;
+            propertyKind: string;
+            governance: string;
+            reference?: MetadataFieldReferencePropertyConfig;
+        }>;
+        capabilities?: Array<{
+            capability: string;
+            title: string;
+            enabled: boolean;
+            configurable: boolean;
+            selected: boolean;
+            reason: string;
+            fieldContributions: string[];
+            defaultDescription: string;
+        }>;
+        truncated: boolean;
+    };
+    mainCandidate?: {
+        alias: string;
+        title: string;
+        schemaName: string;
+        tableName: string;
+        storageDefaultsOnSave: Array<'schemaName' | 'tableName'>;
+        saved: false;
+        nextStep: 'REVIEW_AND_SAVE_STRUCTURE_BEFORE_FIELDS';
+    };
+    childCandidate?: {
+        alias: string;
+        title: string;
+        parentRelationId: string;
+        parentTitle?: string;
+        saved: false;
+    };
+    draft: {
+        active: boolean;
+        dirty: boolean;
+        editorOpen: boolean;
+        fieldPlanOpen?: boolean;
+        fieldPlanEditing?: boolean;
+    };
+    fieldSpecs: Array<{
+        alias: string;
+        title?: string;
+    }>;
+}
+export interface AddMetadataFieldDraftInput {
+    defaultValue?: string | null;
+    title: string;
+    fieldName?: string;
+    fieldSpecAlias: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+}
+export interface UpdateMetadataFieldDraftInput {
+    defaultValue?: string | null;
+    fieldName: string;
+    title?: string;
+    fieldSpecAlias?: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+    enabled?: boolean;
+}
+export interface UpdateMetadataReferenceDraftInput {
+    fieldName: string;
+    requireEnabled?: boolean;
+    affectMappings?: string[];
+}
+export type MetadataPropertyFieldKind = 'MODULE_REFERENCE' | 'DICTIONARY';
+export interface FindMetadataFieldTargetsInput {
+    kind: MetadataPropertyFieldKind;
+    keyword?: string;
+}
+export interface AddMetadataPropertyFieldDraftInput {
+    defaultValue?: string | null;
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName?: string;
+    target: string;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
+    affectMappings?: string[];
+    required?: boolean;
+}
+export interface PreparedMetadataPropertyFieldDraft {
+    defaultValue?: string | null;
+    relationId: string;
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName: string;
+    columnName: string;
+    fieldSpecAlias: string;
+    required: boolean;
+    reference?: {
+        targetModuleAlias: string;
+        targetMetadataId?: string;
+        targetKeyField: string;
+        targetLabelField: string;
+        affectMappings?: string[];
+    };
+    dictionary?: {
+        applicationAlias: string;
+        categoryAlias: string;
+        selectionMode: 'SINGLE' | 'MULTIPLE';
+    };
+}
+export interface MetadataFieldCandidate {
+    fieldName: string;
+    kind: string;
+    editable: boolean;
+    operation: 'ADD' | 'UPDATE';
+    saved: false;
+    expectedMetadataVersion: number;
+    changes: Array<{
+        propertyKey: string;
+        property: string;
+        before?: string | boolean;
+        after?: string | boolean;
+    }>;
+}
+export type MetadataFieldPlanInput = Array<(AddMetadataFieldDraftInput & {
+    kind: 'BASIC';
+}) | AddMetadataPropertyFieldDraftInput>;
+/** Preparation validates without changing the editor; returned callbacks commit synchronously inside applyEffect. */
+export interface MetadataGovernanceEditor {
+    readonly language?: LanguageContext;
+    prepareMainDraft?(input: {
+        title: string;
+    }): () => unknown;
+    prepareChildDraft?(input: {
+        alias: string;
+        title: string;
+    }): () => unknown;
+    discardCandidate?(): void;
+    prepareConfirmation?(signal: AbortSignal): Promise<OperationProposal>;
+    readCurrent?(signal?: AbortSignal, commit?: (accept: () => void) => void): Promise<void>;
+    prepareFieldPlan?(fields: MetadataFieldPlanInput, signal: AbortSignal): Promise<() => unknown>;
+    plan?(): unknown;
+    prepareCapabilityDraft?(input: {
+        capability: string;
+        selected: boolean;
+    }): () => unknown;
+    prepareRetainFieldDraft?(): () => unknown;
+    removableNewFieldNames?(): string[];
+    prepareRemoveNewFieldDraft?(input: {
+        fieldName: string;
+    }): () => unknown;
+    summary(): MetadataGovernanceSummary;
+    candidate?(): MetadataFieldCandidate | undefined;
+    proposal(): MetadataModelChangeSetProposal | undefined;
+    preview(proposal: MetadataModelChangeSetProposal, signal: AbortSignal): Promise<MetadataChangeSetPreview>;
+    fieldSpecAliases(): string[];
+    editableBasicFieldNames(): string[];
+    editableReferenceFieldNames?(): string[];
+    prepareReferenceUpdate?(input: UpdateMetadataReferenceDraftInput, signal: AbortSignal): Promise<() => unknown>;
+    prepareNewFieldDraft?(input: AddMetadataFieldDraftInput): () => {
+        relationId: string;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+    };
+    prepareFieldUpdate?(input: UpdateMetadataFieldDraftInput): () => {
+        relationId: string;
+        fieldName: string;
+        title?: string;
+        fieldSpecAlias?: string;
+    };
+    findFieldTargets?(input: FindMetadataFieldTargetsInput, signal: AbortSignal): Promise<{
+        targets: Array<{
+            target: string;
+            title?: string;
+        }>;
+        truncated: boolean;
+    }>;
+    referenceAffectDirectory?(target: string, signal: AbortSignal): Promise<{
+        sources: Array<{
+            fieldName: string;
+            title: string;
+        }>;
+        destinations: Array<{
+            fieldName: string;
+            title: string;
+        }>;
+    }>;
+    preparePropertyFieldDraft?(input: AddMetadataPropertyFieldDraftInput, signal: AbortSignal): Promise<PreparedMetadataPropertyFieldDraft>;
+    preparePropertyFieldCommit?(prepared: PreparedMetadataPropertyFieldDraft): () => {
+        relationId: string;
+        kind: MetadataPropertyFieldKind;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+        target: string;
+    };
+}
+export declare function metadataFieldPropertyTitles(language?: LanguageContext): Record<string, string>;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../web-core/index';
 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';
@@ -23,6 +24,7 @@ export declare function toFieldPropertyChangeSetPayload(property: MetadataFieldP
 export interface MetadataRelationChangeSetProposal {
     expectedMetadataVersion: number;
     fieldDrafts: MetadataFieldChangeSetDraft[];
+    capabilitySelections?: Record<string, boolean>;
 }
 /** Input facts are loaded for every node before a module-wide edit session begins. */
 export interface MetadataModelRelationDraftSource {
@@ -40,6 +42,7 @@ export interface MetadataModelRelationDraft {
     metadataId: string;
     relationId: string;
     expectedMetadataVersion: number;
+    capabilitySelections: Record<string, boolean>;
     fields: Record<string, MetadataField>;
     fieldProperties: Record<string, MetadataFieldPropertyDraft>;
     parentMetadataId?: string;
@@ -64,21 +67,44 @@ export interface MetadataModelChangeSetProposal {
  * 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(): {
+export declare function createMetadataModelWorkspaceEditSession(language?: LanguageContext): {
     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;
+    prepareRebase: (sources: MetadataModelRelationDraftSource[], proposal: MetadataModelChangeSetProposal, enabledCapabilities?: Readonly<Record<string, string[]>>, baseline?: Readonly<Record<string, MetadataModelRelationDraft>>) => () => void;
+    captureBaseline: () => {
+        [k: string]: {
+            capabilitySelections: {
+                [x: string]: boolean;
+            };
+            fields: Record<string, MetadataField>;
+            fieldProperties: Record<string, MetadataFieldPropertyDraft>;
+            fieldOrder: string[];
+            sortableFieldIds: string[];
+            metadataId: string;
+            relationId: string;
+            expectedMetadataVersion: number;
+            parentMetadataId?: string;
+        };
+    };
     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;
+    stageFields: (relationId: string, entries: Array<{
+        field: MetadataField;
+        property: MetadataFieldPropertyDraft;
+    }>) => void;
+    discardNewField: (relationId: string, fieldName: string) => void;
+    stageCapability: (relationId: string, capability: string, selected: boolean) => void;
     stageFieldOrder: (relationId: string, fieldIds: string[]) => void;
     stageRelationOrder: (parentMetadataId: string | undefined, relationIds: string[]) => void;
-    buildProposal: () => MetadataModelChangeSetProposal | undefined;
+    buildProposal: (currentDraft?: Record<string, MetadataModelRelationDraft> | undefined) => MetadataModelChangeSetProposal | undefined;
+    proposalWithField: (relationId: string, field: MetadataField, property: MetadataFieldPropertyDraft, replaceNewFieldKey?: string) => 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 metadataFieldGovernanceLabel(kind: MetadataFieldGovernanceKind, language?: LanguageContext): string;
 export declare function isSessionEditableMetadataField(field: MetadataField, relation: ModuleMetadataRelation | undefined, capabilityFieldNames: ReadonlySet<string>): boolean;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../web-core/index';
 import type { Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
 import type { UiTreeDropEvent, UiTreeNode } from '../vue-ui-antdv/index';
 export type MetadataModelTreeNodeKind = 'METADATA' | 'FIELD';
@@ -22,7 +23,7 @@ export interface MetadataModelTreeInput {
  * 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 buildMetadataModelTree(input: MetadataModelTreeInput, language?: LanguageContext): MetadataModelTreeNode[];
 export declare function metadataNodeKey(relationId: string): string;
 export declare function fieldNodeKey(relationId: string, fieldId: string): string;
 export declare function parseMetadataModelTreeKey(key: string): {

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

@@ -1,11 +1,20 @@
+import { type LanguageContext, type OperationErrorMessage } from '../web-core/index';
 import type { MetadataFieldPropertyKind } from './metadataOrchestrationState';
 export declare const PLATFORM_FIELD_NAME_PATTERN = "^[a-z][A-Za-z0-9]{0,62}$";
 export declare const DYNAMIC_RECORD_RESERVED_FIELD_NAMES: Set<string>;
 export declare function isPlatformFieldName(value: string): boolean;
 export declare function isDynamicRecordReservedFieldName(value: string): boolean;
 export declare function physicalNameOf(fieldName?: string): string;
+/** Match the platform record-name contract before a shared candidate is staged. */
+export declare function recordNameFieldProblemMessage(field: {
+    titleField?: boolean | null;
+    fieldName?: string | null;
+    columnName?: string | null;
+}, language?: LanguageContext): OperationErrorMessage | undefined;
+/** Compatibility display helper; editors retain the declared message instead of this rendered string. */
+export declare function recordNameFieldProblem(field: Parameters<typeof recordNameFieldProblemMessage>[0], language?: LanguageContext): string | undefined;
 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;
+export declare function generatedBusinessFieldName(title: string | undefined, kind: MetadataFieldPropertyKind, titleField?: boolean): 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,3 +1,4 @@
+import { type LanguageContext } from '../web-core/index';
 import type { FieldSpec, Metadata, MetadataField, ModuleMetadataRelation } from '../web-contracts/index';
 import type { RecordExplorerItemDescriptor } from '../platform-components/recordExplorerItemModel';
 /** Editor lifecycle of the metadata orchestration workspace. */
@@ -22,7 +23,9 @@ export interface MetadataFieldReferencePropertyConfig {
     targetLabelField?: string;
     cardinality?: 'ONE' | 'MANY';
     targetUnavailablePolicy?: 'PRESERVE_HISTORY' | 'RESTRICT' | 'CASCADE_DELETE';
+    requireEnabled?: boolean;
     projectionMappings?: string[];
+    affectMappings?: string[];
 }
 export interface MetadataFieldDictionaryPropertyConfig {
     dictionaryApplicationAlias?: string;
@@ -40,9 +43,17 @@ export interface MetadataFieldPropertyDraft {
     expectedBindingVersion?: number;
     referenceConfig?: MetadataFieldReferencePropertyConfig;
     dictionaryConfig?: MetadataFieldDictionaryPropertyConfig;
+    fixedDefault?: {
+        value: string | null;
+        expectedConfigVersion?: number;
+    };
 }
 /** Relation-scoped property facts supplied by the module-governance read model. */
 export interface MetadataFieldPropertySummary extends MetadataFieldPropertyDraft {
+    fixedDefault?: NonNullable<MetadataFieldPropertyDraft['fixedDefault']> & {
+        configVersion?: number;
+        editable?: boolean;
+    };
     fieldId?: string;
     fieldName?: string;
     fieldSpecAlias?: string;
@@ -60,7 +71,7 @@ export interface FieldSpecOption {
     value: string;
     label: string;
 }
-export declare function createMetadataOrchestrationState(): {
+export declare function createMetadataOrchestrationState(language?: LanguageContext): {
     relations: import("vue").Ref<{
         moduleAlias?: string | undefined;
         metadataId?: string | undefined;
@@ -338,13 +349,19 @@ export declare function createMetadataOrchestrationState(): {
             targetLabelField?: string | undefined;
             cardinality?: "ONE" | "MANY" | undefined;
             targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            requireEnabled?: boolean | undefined;
             projectionMappings?: string[] | undefined;
+            affectMappings?: string[] | undefined;
         } | undefined;
         dictionaryConfig?: {
             dictionaryApplicationAlias?: string | undefined;
             dictionaryCategoryAlias?: string | undefined;
             selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
         } | undefined;
+        fixedDefault?: {
+            value: string | null;
+            expectedConfigVersion?: number | undefined;
+        } | undefined;
     }, MetadataFieldPropertyDraft | {
         kind: MetadataFieldPropertyKind;
         expectedBindingVersion?: number | undefined;
@@ -355,13 +372,19 @@ export declare function createMetadataOrchestrationState(): {
             targetLabelField?: string | undefined;
             cardinality?: "ONE" | "MANY" | undefined;
             targetUnavailablePolicy?: "PRESERVE_HISTORY" | "RESTRICT" | "CASCADE_DELETE" | undefined;
+            requireEnabled?: boolean | undefined;
             projectionMappings?: string[] | undefined;
+            affectMappings?: string[] | undefined;
         } | undefined;
         dictionaryConfig?: {
             dictionaryApplicationAlias?: string | undefined;
             dictionaryCategoryAlias?: string | undefined;
             selectionMode?: "SINGLE" | "MULTIPLE" | undefined;
         } | undefined;
+        fixedDefault?: {
+            value: string | null;
+            expectedConfigVersion?: number | undefined;
+        } | undefined;
     }>;
     selectedRelation: import("vue").ComputedRef<{
         moduleAlias?: string | undefined;
@@ -414,20 +437,20 @@ 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;
+export declare function metadataFieldPropertyLabel(kind: MetadataFieldPropertyKind, language?: LanguageContext): string;
+export declare function metadataFieldPropertySummary(property: MetadataFieldPropertyDraft, language?: LanguageContext): 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[];
+export declare function fieldSpecOptionListOf(specs: FieldSpec[], language?: LanguageContext): FieldSpecOption[];
 /** Filters a populated entity to the source specification's server-declared safe targets. */
-export declare function dataSafeFieldSpecOptions(specs: FieldSpec[], currentAlias?: string): FieldSpecOption[];
+export declare function dataSafeFieldSpecOptions(specs: FieldSpec[], currentAlias?: string, language?: LanguageContext): 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;
+export declare function fieldSpecDisplayLabel(fieldSpecAlias: string | undefined, specs: FieldSpec[], language?: LanguageContext): string;
+export declare function entityTitleOf(relation: ModuleMetadataRelation, metadata: Metadata | undefined, language?: LanguageContext): string;
+export declare function relationRoleTag(role: ModuleMetadataRelation['relationRole'], language?: LanguageContext): 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 entityExplorerItem(relation: ModuleMetadataRelation, metadata: Metadata | undefined, language?: LanguageContext): RecordExplorerItemDescriptor;
 export declare function metadataSubtitleOf(metadata: Metadata | undefined): string | undefined;

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

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