@ximatai/muyun-web-app 0.26.11 → 0.26.13

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

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: 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/ModuleExperienceProfileOverview.vue.d.ts

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: 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/ModuleGovernanceView.vue.d.ts

@@ -0,0 +1,9 @@
+import { type ModuleGovernanceTab } from './moduleGovernanceWorkspaceView';
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: string;
+    governanceTab?: ModuleGovernanceTab;
+};
+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/PageCompositionDescriptorPreview.vue.d.ts

@@ -0,0 +1,54 @@
+import type { ModuleRuntimeAction } from '../web-core/index';
+import type { ResolvedModuleUiDescriptor } from '../web-contracts/index';
+import { type CompositionPlacementSource, type CompositionPlacementTarget, type PageCompositionStructure } from './pageCompositionPlacement';
+import { type PageQuerySummary } from './pageCompositionDraftState';
+import { type PageCompositionActionPlacement } from './pageCompositionMode';
+type PreviewMode = 'list' | 'query' | 'detail' | 'edit';
+type PreviewSlot = 'list' | 'form';
+type __VLS_Props = {
+    descriptor: ResolvedModuleUiDescriptor;
+    moduleAlias: string;
+    mode: PreviewMode;
+    selectedFieldName?: string;
+    /** Allows the active preview surface to receive a compatible metadata payload. */
+    acceptExternalDrop?: boolean;
+    structure?: PageCompositionStructure;
+    placementDisabled?: boolean;
+    /** A failed async descriptor refresh must not leave its pre-drop layout on screen. */
+    placementCommitFailed?: boolean;
+    actionPlacements?: PageCompositionActionPlacement[];
+    actionFormMode?: 'create' | 'edit';
+    moduleActions?: ModuleRuntimeAction[];
+    querySummaries?: PageQuerySummary[];
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    selectField: (slot: PreviewSlot, fieldName: string) => any;
+    configureField: (slot: PreviewSlot, fieldName: string) => any;
+    configureRelationField: (relationCode: string, fieldName: string) => any;
+    configureAction: (anchor: "page" | "form" | "detail", actionCode: string) => any;
+    configureSummaries: () => any;
+    "placement-drop": (source: CompositionPlacementSource, target: CompositionPlacementTarget) => any;
+    "action-drop": (source: {
+        actionCode: string;
+        sourceAnchor?: "page" | "detail" | "form";
+    }, target: {
+        anchor: "page" | "detail" | "form";
+        index: number;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelectField?: ((slot: PreviewSlot, fieldName: string) => any) | undefined;
+    onConfigureField?: ((slot: PreviewSlot, fieldName: string) => any) | undefined;
+    onConfigureRelationField?: ((relationCode: string, fieldName: string) => any) | undefined;
+    onConfigureAction?: ((anchor: "page" | "form" | "detail", actionCode: string) => any) | undefined;
+    onConfigureSummaries?: (() => any) | undefined;
+    "onPlacement-drop"?: ((source: CompositionPlacementSource, target: CompositionPlacementTarget) => any) | undefined;
+    "onAction-drop"?: ((source: {
+        actionCode: string;
+        sourceAnchor?: "page" | "detail" | "form";
+    }, target: {
+        anchor: "page" | "detail" | "form";
+        index: number;
+    }) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,103 @@
+import { type CompositionSkeleton, type PageCompositionActionPlacement } from './pageCompositionMode';
+import { type PageComposerFormItem, type PageComposerField, type PageComposerGroup, type PageComposerRelation, type PageQuerySummary } from './pageCompositionDraftState';
+import { type PageCompositionDragPayload } from './pageCompositionDragPayload';
+type __VLS_Props = {
+    skeleton?: CompositionSkeleton;
+    explorerTitle?: string;
+    searchableFieldIds?: string[];
+    quickSearchFields?: {
+        fieldName: string;
+        title: string;
+    }[];
+    querySummaries?: PageQuerySummary[];
+    summariesSupported?: boolean;
+    summaryDescriptions?: Record<string, string>;
+    summaryIssues?: Record<string, string>;
+    explorerSecondary?: string;
+    actionPlacements?: PageCompositionActionPlacement[];
+    moduleActions?: {
+        actionCode: string;
+        title?: string;
+        bindingPending?: boolean;
+        category?: string;
+        executorType?: string;
+        actionLevel?: 'LIST' | 'RECORD' | 'BATCH' | 'ANY' | 'DEFAULT';
+    }[];
+    editorMode?: 'fields' | 'actions';
+    listFields: PageComposerField[];
+    formFields: PageComposerField[];
+    formGroups: PageComposerGroup[];
+    formOrder?: PageComposerFormItem[];
+    formRelations: PageComposerRelation[];
+    selectedKey?: string;
+    disabled?: boolean;
+};
+type ComposerNodeAction = 'configure' | 'remove' | 'add-group' | 'toggle-visibility';
+export type ComposerDropTarget = ({
+    kind: 'explorer-title' | 'explorer-secondary' | 'quick-search';
+} | {
+    kind: 'list';
+} | {
+    kind: 'form';
+} | {
+    kind: 'group';
+    groupId: string;
+} | {
+    kind: 'relation';
+    relationId: string;
+} | {
+    kind: 'action-anchor';
+    anchor: PageCompositionActionPlacement['anchor'];
+}) & {
+    index?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (key: string) => any;
+    "double-click": (key: string) => any;
+    "action-drop": (source: {
+        actionCode: string;
+        sourceAnchor?: PageCompositionActionPlacement["anchor"];
+    }, target: {
+        anchor: PageCompositionActionPlacement["anchor"];
+        index: number;
+    }) => any;
+    "node-action": (action: ComposerNodeAction, key: string) => any;
+    "reorder-list-field": (fieldId: string, targetIndex: number) => any;
+    "reorder-form-field": (fieldId: string, targetIndex: number) => any;
+    "move-form-field-to-group": (fieldId: string, groupId: string, targetIndex: number) => any;
+    "move-group-field-to-form": (groupId: string, fieldId: string, targetIndex: number) => any;
+    "reorder-group-field": (groupId: string, fieldId: string, targetIndex: number) => any;
+    "move-group-field-to-group": (sourceGroupId: string, fieldId: string, targetGroupId: string, targetIndex: number) => any;
+    "reorder-group": (groupId: string, targetIndex: number) => any;
+    "reorder-relation-field": (relationId: string, fieldId: string, targetIndex: number) => any;
+    "reorder-query-summary": (summaryKey: string, targetIndex: number) => any;
+    "source-drop": (target: ComposerDropTarget, payload: PageCompositionDragPayload) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string) => any) | undefined;
+    "onDouble-click"?: ((key: string) => any) | undefined;
+    "onAction-drop"?: ((source: {
+        actionCode: string;
+        sourceAnchor?: PageCompositionActionPlacement["anchor"];
+    }, target: {
+        anchor: PageCompositionActionPlacement["anchor"];
+        index: number;
+    }) => any) | undefined;
+    "onNode-action"?: ((action: ComposerNodeAction, key: string) => any) | undefined;
+    "onReorder-list-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
+    "onReorder-form-field"?: ((fieldId: string, targetIndex: number) => any) | undefined;
+    "onMove-form-field-to-group"?: ((fieldId: string, groupId: string, targetIndex: number) => any) | undefined;
+    "onMove-group-field-to-form"?: ((groupId: string, fieldId: string, targetIndex: number) => any) | undefined;
+    "onReorder-group-field"?: ((groupId: string, fieldId: string, targetIndex: number) => any) | undefined;
+    "onMove-group-field-to-group"?: ((sourceGroupId: string, fieldId: string, targetGroupId: string, targetIndex: number) => any) | undefined;
+    "onReorder-group"?: ((groupId: string, targetIndex: number) => any) | undefined;
+    "onReorder-relation-field"?: ((relationId: string, fieldId: string, targetIndex: number) => any) | undefined;
+    "onReorder-query-summary"?: ((summaryKey: string, targetIndex: number) => any) | undefined;
+    "onSource-drop"?: ((target: ComposerDropTarget, payload: PageCompositionDragPayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    selectedKey: string;
+    editorMode: "fields" | "actions";
+    formOrder: PageComposerFormItem[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,7 @@
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: 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/PageQuerySummaryEditor.vue.d.ts

@@ -0,0 +1,48 @@
+import type { PageQuerySummary, PageQuerySummarySource } from './pageCompositionDraftState';
+export interface PageQuerySummaryEditorIssues {
+    source?: string;
+    fieldName?: string;
+    contributorKey?: string;
+    groupByField?: string;
+    label?: string;
+}
+type __VLS_Props = {
+    summaries: PageQuerySummary[];
+    catalog?: {
+        fields?: Array<{
+            fieldName: string;
+            title: string;
+        }>;
+        contributors?: Array<{
+            contributorKey: string;
+            title: string;
+        }>;
+        groupFields?: Array<{
+            fieldName: string;
+            title: string;
+            kind: 'OPTION' | 'REFERENCE';
+        }>;
+    };
+    loading?: boolean;
+    error?: string;
+    disabled?: boolean;
+    selectedKey?: string;
+    focusRequest?: number;
+    issues?: Record<string, PageQuerySummaryEditorIssues>;
+    descriptions?: Record<string, string>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    move: (index: number, offset: number) => any;
+    add: (source: PageQuerySummarySource) => any;
+    remove: (index: number) => any;
+    update: (index: number, patch: Partial<PageQuerySummary>) => any;
+    retry: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onMove?: ((index: number, offset: number) => any) | undefined;
+    onAdd?: ((source: PageQuerySummarySource) => any) | undefined;
+    onRemove?: ((index: number) => any) | undefined;
+    onUpdate?: ((index: number, patch: Partial<PageQuerySummary>) => any) | undefined;
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, 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,85 @@
+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;
+    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/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/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/metadataModelEditSession.d.ts

@@ -0,0 +1,84 @@
+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;
+}
+/**
+ * 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;
+    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;