@ximatai/muyun-web-app 0.26.12 → 0.26.14

package/dist/types/platform-components/userPickerModel.d.ts

@@ -0,0 +1,45 @@
+import type { IdentityPickerCandidate, IdentityPickerResolver } from './identityPickerModel';
+/** A user selection always persists an IAM user account ID, never an employee ID. */
+export type UserAccountId = string;
+/** An authorized user-account projection returned by the selection provider. */
+export interface UserPickerCandidate extends IdentityPickerCandidate<UserAccountId> {
+    /** Account snapshot or current account, as defined by the source. */
+    account?: string;
+    employeeName?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface UserPickerNavigationScope {
+    tenantId?: string;
+    organizationId?: string;
+    departmentId?: string;
+}
+/** A source-provided progressive browse axis. IDs remain source-owned and are never inferred by the picker. */
+export interface UserPickerNavigationItem {
+    id: string;
+    title: string;
+    tenantId?: string;
+    /** Parent organization for a department item, when the source has that hierarchy. */
+    organizationId?: string;
+}
+export interface UserPickerNavigation {
+    showTenantNavigation: boolean;
+    tenants: UserPickerNavigationItem[];
+    organizations: UserPickerNavigationItem[];
+    departments: UserPickerNavigationItem[];
+}
+export interface UserPickerPage {
+    records: UserPickerCandidate[];
+    total: number;
+    navigation?: UserPickerNavigation;
+}
+export interface UserPickerPageRequest {
+    keyword: string;
+    pageNum: number;
+    pageSize: number;
+    scope?: UserPickerNavigationScope;
+}
+export type UserPickerPageSearch = (request: UserPickerPageRequest) => Promise<UserPickerPage>;
+export type UserPickerResolver = IdentityPickerResolver<UserAccountId>;

package/dist/types/platform-components/userReferencePicker.d.ts

@@ -0,0 +1,17 @@
+import type { ReferencePickerCandidate, ReferencePickerColumn, ReferencePickerProvider, ReferencePickerSourceIdentity } from './referencePickerModel';
+import type { UserPickerCandidate, UserPickerPageSearch, UserPickerResolver } from './userPickerModel';
+/** Identity-specific presentation stays here; the common picker only consumes projections. */
+export declare const userReferencePickerColumns: readonly ReferencePickerColumn[];
+export interface UserReferencePickerConfig {
+    sourceIdentity: ReferencePickerSourceIdentity;
+    searchPage: UserPickerPageSearch;
+    resolveUsers: UserPickerResolver;
+}
+/**
+ * Maps the authorized IAM delivery into the source-neutral picker contract.
+ * It does not infer any tenant/organization/department relationship: old
+ * source-owned IDs are simply returned to the same source as typed axes.
+ */
+export declare function createUserReferencePickerProvider(config: UserReferencePickerConfig): ReferencePickerProvider;
+export declare function toReferenceCandidate(candidate: UserPickerCandidate): ReferencePickerCandidate;
+export declare function toUserPickerCandidate(candidate: ReferencePickerCandidate): UserPickerCandidate;

package/dist/types/platform-workbench/AssistantMarkdownContent.vue.d.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    content: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-workbench/AssistantSelectionCard.vue.d.ts

@@ -0,0 +1,15 @@
+import type { AssistantSelectionInteraction, AssistantSelectionOption } from '../web-contracts/index';
+type __VLS_Props = {
+    selection: AssistantSelectionInteraction;
+    state: 'open' | 'submitting' | 'answered' | 'superseded';
+    selectedOptionId?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (option: AssistantSelectionOption) => any;
+    abandon: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((option: AssistantSelectionOption) => any) | undefined;
+    onAbandon?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-workbench/Workbench.vue.d.ts

@@ -1,4 +1,5 @@
 import type { MenuNavigationTarget, MenuRecord, MenuTab, PageDescriptor, WorkbenchStartupState } from '../web-contracts/index';
+import { type AssistantTurnRequester } from '../web-core/index';
 import type { WorkbenchRealtimeStatus } from './realtimeStatus';
 type __VLS_Props = {
     startup?: WorkbenchStartupState;
@@ -8,14 +9,16 @@ type __VLS_Props = {
     lockedTabKeys?: string[];
     realtimeStatus?: WorkbenchRealtimeStatus;
     themeAppearance?: 'light' | 'dark';
+    assistantRequestTurn?: AssistantTurnRequester;
+    assistantWaitForPageReady?: () => Promise<string>;
 };
-declare var __VLS_82: {
+declare var __VLS_90: {
     activeTab: MenuTab;
     target: MenuNavigationTarget | undefined;
     pageDescriptor: PageDescriptor | undefined;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_82) => any;
+    default?: (props: typeof __VLS_90) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     closeTabs: (keys: string[]) => any;
@@ -47,6 +50,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     activeTabKey: string;
     lockedTabKeys: string[];
     themeAppearance: "light" | "dark";
+    assistantRequestTurn: AssistantTurnRequester;
+    assistantWaitForPageReady: () => Promise<string>;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/types/platform-workbench/WorkbenchAssistantPanel.vue.d.ts

@@ -0,0 +1,12 @@
+import { type AssistantSurfaceRegistry } from '../web-core/index';
+type __VLS_Props = {
+    open: boolean;
+    registry: AssistantSurfaceRegistry;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-workbench/assistantMarkdown.d.ts

@@ -0,0 +1 @@
+export declare function renderAssistantMarkdown(content: string): string;

package/dist/types/platform-workbench/index.d.ts

@@ -1,4 +1,5 @@
 export { default as Workbench } from './Workbench.vue';
+export { default as WorkbenchAssistantPanel } from './WorkbenchAssistantPanel.vue';
 export { default as WorkbenchMenu } from './WorkbenchMenu.vue';
 export { default as WorkbenchOutlet } from './WorkbenchOutlet.vue';
 export { default as WorkspaceViewOutlet } from './WorkspaceViewOutlet.vue';

package/dist/types/platform-workbench/useWorkspaceViewUnsavedState.d.ts

@@ -2,4 +2,4 @@
  * Lets a workspace panel declare unsaved local state without exposing or
  * duplicating its draft in the workbench shell.
  */
-export declare function useWorkspaceViewUnsavedState(source: string, isDirty: () => boolean): void;
+export declare function useWorkspaceViewUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): void;

package/dist/types/platform-workbench/workbenchAssistantCapabilities.d.ts

@@ -0,0 +1,3 @@
+import type { MenuRecord, MenuTreeNode } from '../web-contracts/index';
+import type { AssistantCapability, AssistantInvocationToken } from '../web-core/index';
+export declare function createWorkbenchAssistantCapabilities(menus: () => MenuTreeNode[], openMenu: (menu: MenuRecord) => boolean, settleNavigation?: (signal?: AbortSignal) => Promise<void | AssistantInvocationToken>): AssistantCapability[];

package/dist/types/platform-workbench/workspaceViewHost.d.ts

@@ -6,7 +6,7 @@ export interface WorkspaceViewHost {
     /** Replaces URL-restorable state without creating another workbench tab. */
     replaceQuery(query: Record<string, RouteQueryValue | undefined>): void;
     /** Registers a local draft signal used only when the owning workbench tab closes. */
-    registerUnsavedState(source: string, isDirty: () => boolean): () => void;
+    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
     dismiss(): void;
     /** Closes the current independent workbench view. */
     close(): void;

package/dist/types/platform-workbench/workspaceViewUnsavedState.d.ts

@@ -1,3 +1,5 @@
-export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean): () => void;
+export declare function registerWorkspaceViewUnsavedState(pageKey: string, source: string, isDirty: () => boolean, isBusy?: () => boolean): () => void;
 export declare function workspaceViewUnsavedStateSources(pageKey: string): string[];
+/** Sources with an in-flight mutation cannot be destroyed until their work completes. */
+export declare function workspaceViewBusyStateSources(pageKey: string): string[];
 export declare function clearWorkspaceViewUnsavedState(pageKey: string): void;

package/dist/types/views/BusinessActivityLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/BusinessLogListDrawer.vue.d.ts

@@ -0,0 +1,9 @@
+import { type BusinessLogSurface } from './businessLogClient';
+type __VLS_Props = {
+    surface: BusinessLogSurface;
+    moduleAlias: string;
+    title: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/BusinessLogRetentionControl.vue.d.ts

@@ -0,0 +1,7 @@
+import { type BusinessLogEventType } from './businessLogRetentionClient';
+type __VLS_Props = {
+    eventTypes: BusinessLogEventType[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/LoginAuditLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/RequestErrorLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/views/RuntimeLogView.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,88 @@
+import type { HttpClient } from '../web-core/index';
+import type { WebQueryRequest } from '../web-contracts/index';
+export type BusinessLogSurface = 'activity' | 'request-error' | 'login';
+export interface BusinessLogOperatorIdentity {
+    employeeName?: string;
+    username?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface BusinessLogEventView {
+    eventId: string;
+    eventType: string;
+    occurredAt?: string;
+    capturedAt?: string;
+    traceId?: string;
+    tenantId?: string;
+    operatorId?: string;
+    operatorOrganizationId?: string;
+    operatorIdentity?: BusinessLogOperatorIdentity;
+    moduleAlias?: string;
+    actionCode?: string;
+    entityAlias?: string;
+    recordId?: string;
+    mutationSource?: string;
+    outcome?: string;
+    /** The authentication account, independent from the event's authenticated operator identity. */
+    loginAccount?: string;
+    summary?: string;
+    details?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface BusinessLogStatisticItem {
+    key: string;
+    title: string;
+    count: number;
+    [key: string]: unknown;
+}
+export interface BusinessLogStatistics {
+    items: BusinessLogStatisticItem[];
+    complete?: boolean;
+}
+export interface BusinessLogOperatorCandidate {
+    id: string;
+    title: string;
+    account?: string;
+    employeeName?: string;
+    organizationId?: string;
+    organizationName?: string;
+    departmentId?: string;
+    departmentName?: string;
+}
+export interface BusinessLogOperatorNavigationItem {
+    id: string;
+    title: string;
+    tenantId?: string;
+    organizationId?: string;
+}
+export interface BusinessLogOperatorNavigation {
+    showTenantNavigation: boolean;
+    tenants: BusinessLogOperatorNavigationItem[];
+    organizations: BusinessLogOperatorNavigationItem[];
+    departments: BusinessLogOperatorNavigationItem[];
+}
+export interface BusinessLogOperatorCandidateQuery {
+    keyword?: string;
+    pageNum?: number;
+    pageSize?: number;
+    selectedIds?: string[];
+    tenantId?: string;
+    organizationId?: string;
+    departmentId?: string;
+}
+export interface BusinessLogOperatorCandidatePage {
+    records: BusinessLogOperatorCandidate[];
+    selectedRecords: BusinessLogOperatorCandidate[];
+    total: number;
+    navigation?: BusinessLogOperatorNavigation;
+}
+export interface BusinessLogClient {
+    detail(eventId: string): Promise<BusinessLogEventView>;
+    operatorCandidates(input: BusinessLogOperatorCandidateQuery): Promise<BusinessLogOperatorCandidatePage>;
+    actionStatistics?(request: WebQueryRequest): Promise<BusinessLogStatistics>;
+    pageAccessStatistics?(request: WebQueryRequest): Promise<BusinessLogStatistics>;
+    diagnostic?(eventId: string): Promise<Record<string, unknown>>;
+}
+export declare function createBusinessLogClient(http: HttpClient, surface: BusinessLogSurface): BusinessLogClient;

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

@@ -0,0 +1,25 @@
+import type { HttpClient } from '../web-core/index';
+export type BusinessLogEventType = 'LOGIN' | 'ACTION' | 'REQUEST_ERROR' | 'PAGE_ACCESS';
+export interface BusinessLogRetentionPolicy {
+    eventType: BusinessLogEventType;
+    automaticCleanupEnabled: boolean;
+    retentionDays: number;
+    version: number;
+    updatedAt?: string;
+    updatedBy?: string;
+}
+export interface BusinessLogRetentionRunResult {
+    eventType: BusinessLogEventType;
+    retentionDays: number;
+    result: {
+        occurredBefore: string;
+        deletedCount: number;
+        executedBatches: number;
+        status: 'COMPLETE' | 'BATCH_LIMIT_REACHED' | 'ALREADY_RUNNING';
+    };
+}
+export declare function createBusinessLogRetentionClient(http: HttpClient): {
+    policies(): Promise<BusinessLogRetentionPolicy[]>;
+    update(policy: BusinessLogRetentionPolicy): Promise<BusinessLogRetentionPolicy>;
+    purge(eventType: BusinessLogEventType, retentionDays: number): Promise<BusinessLogRetentionRunResult>;
+};

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

@@ -0,0 +1,18 @@
+/** Facts loaded from the dictionary candidate endpoint for radio presentation preflight. */
+export interface DictionaryRadioCandidateFacts {
+    enabledCandidateCount: number;
+    hasHierarchy: boolean;
+}
+export interface DictionaryRadioEligibilityInput {
+    optionSourceType?: string;
+    optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
+    facts?: DictionaryRadioCandidateFacts;
+    loadError?: string;
+    maxOptions: number;
+}
+/**
+ * Radio is a presentation choice over a single, flat and small dictionary. Keep this decision
+ * independent from the composer view so selected-field hints, preview guards and publish guards
+ * all enforce the same rule.
+ */
+export declare function dictionaryRadioEligibilityIssue(input: DictionaryRadioEligibilityInput): string | undefined;

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

@@ -0,0 +1,10 @@
+/**
+ * Guards asynchronous candidate reads while a kept-alive composer reloads its metadata directory.
+ * A field name is stable across a dictionary rebind, so the directory generation—not the name—is
+ * the authority for whether an in-flight response may still update radio eligibility.
+ */
+export declare function createDictionaryRadioFactRequestEpoch(): {
+    invalidate(): void;
+    capture(): number;
+    isCurrent(capturedGeneration: number): boolean;
+};

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

@@ -0,0 +1,122 @@
+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;
+    };
+}
+export declare function createMetadataGovernanceAssistantSurface(adapter: MetadataGovernanceAssistantAdapter, requestTurn: AssistantTurnRequester, contributedCapabilities?: () => AssistantCapability[]): AssistantSurface;

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

@@ -0,0 +1,36 @@
+import type { HttpClient } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+export type MetadataChangeSetIssue = {
+    severity: 'WARNING' | 'ERROR' | string;
+    code: string;
+    subject: string;
+    message: string;
+};
+export type MetadataChangeSetPreview = {
+    proposalFingerprint: string;
+    fieldImpacts: Array<{
+        operation: string;
+        fieldName: string;
+        columnName: string;
+        platformManaged: boolean;
+        description: string;
+    }>;
+    schemaImpacts: Array<{
+        operation: string;
+        schemaName: string;
+        tableName: string;
+        columnName: string;
+        description: string;
+    }>;
+    orderImpacts: Array<{
+        operation: string;
+        relationId?: string;
+        parentMetadataId?: string;
+        orderedIds: string[];
+        description: string;
+    }>;
+    warnings: MetadataChangeSetIssue[];
+    errors: MetadataChangeSetIssue[];
+};
+export declare function previewMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, signal?: AbortSignal): Promise<MetadataChangeSetPreview>;
+export declare function applyMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, proposalFingerprint: string): Promise<unknown>;

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

@@ -9,7 +9,16 @@ export interface MetadataFieldChangeSetDraft {
     /** JSON-facing command contract; projection mappings remain an ordered string array. */
     property?: MetadataFieldPropertyChangeSetPayload;
 }
-export type MetadataFieldPropertyChangeSetPayload = MetadataFieldPropertyDraft;
+/**
+ * The editor uses stable upper-case cardinality labels, while the public HTTP contract for
+ * CodeTitleEnum writes their lower-case codes. Keep that translation at the change-set boundary
+ * rather than leaking transport values into the editor and form renderer.
+ */
+export type MetadataFieldPropertyChangeSetPayload = Omit<MetadataFieldPropertyDraft, 'dictionaryConfig'> & {
+    dictionaryConfig?: Omit<NonNullable<MetadataFieldPropertyDraft['dictionaryConfig']>, 'selectionMode'> & {
+        selectionMode?: 'single' | 'multiple';
+    };
+};
 export declare function toFieldPropertyChangeSetPayload(property: MetadataFieldPropertyDraft): MetadataFieldPropertyChangeSetPayload;
 export interface MetadataRelationChangeSetProposal {
     expectedMetadataVersion: number;

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

@@ -1,4 +1,8 @@
 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;
 export declare function generatedFieldName(title?: string): string;
 /** Default names for newly created business fields; runtime semantics remain metadata-driven. */