@ximatai/muyun-web-app 0.26.11 → 0.26.13

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

@@ -3,6 +3,8 @@ import type { ModuleContext } from '../web-core/index';
 import type { PickerConstraint, RecordPickerRecord } from './recordPickerConstraints';
 import type { WebTreeNode } from '../web-contracts/index';
 import type { RecordPickerMode } from './recordPickerModel';
+import type { ScopedTreePickerProvider } from './scopedTreePickerModel';
+import type { ReferencePickerColumn, ReferencePickerProvider } from './referencePickerModel';
 export type RecordFormFieldDescriptor = (ViewFieldDefinition | ResolvedViewFieldDescriptor) & {
     /** Optional during the protocol migration; resolved descriptors take precedence over legacy uiType. */
     fieldControl?: ResolvedFieldControlDescriptor;
@@ -36,7 +38,9 @@ export type JsonValue = null | boolean | number | string | JsonValue[] | {
 };
 /** A business boolean does not inherit the lifecycle field's implicit enabled default. */
 export type RecordBooleanStatusValue = boolean | undefined;
-export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+export type RecordFormFieldControlType = 'input' | 'numberInput' | 'dateInput' | 'dateTimeInput' | 'textarea' | 'colorPicker' | 'select' | 'enabledStatus' | 'booleanStatus' | 'switch' | 'recordPicker' | 'recordMultiPicker' | 'dictionaryPicker' | 'dictionaryRadioGroup' | 'fileTransfer' | 'imageFileTransfer' | 'unsupported';
+/** The only source-field reference presentations implemented by the common picker. */
+export type RecordFormReferencePickerPresentation = 'dropdown' | 'dialog';
 export interface RecordFieldRenderer {
     rendererType: string;
     controlType: Exclude<RecordFormFieldControlType, 'unsupported'>;
@@ -60,10 +64,14 @@ export interface RecordFormFieldFallback {
 }
 export interface RecordFormFieldPickerConfig {
     context: ModuleContext<RecordPickerRecord>;
+    /** Source-authorized, paged reference delivery for the common picker. */
+    provider?: ReferencePickerProvider;
+    /** Candidate columns are presentation only; identity and authorization stay with the provider. */
+    columns?: readonly ReferencePickerColumn[];
     loadOptions?: (keyword: string) => Promise<RecordPickerRecord[]>;
     loadTree?: () => Promise<WebTreeNode<RecordPickerRecord>[]>;
     resolveOptions?: (values: string[]) => Promise<RecordPickerRecord[]>;
-    reloadKey?: number;
+    reloadKey?: string | number;
     mode?: RecordPickerMode;
     placeholder?: string;
     allowClear?: boolean;
@@ -71,6 +79,17 @@ export interface RecordFormFieldPickerConfig {
     titleOf?: (record: RecordPickerRecord) => string;
     descriptionOf?: (record: RecordPickerRecord) => string | undefined;
     filterOption?: (record: RecordPickerRecord, keyword: string) => boolean;
+    /**
+     * Optional expanded tree navigation for a reference that keeps its ordinary compact picker.
+     * The host owns whether its declared effective scope is ready; this generic form model does
+     * not infer tenant or organization rules from field names.
+     */
+    scopedTree?: {
+        title?: string;
+        disabled?: boolean;
+        unavailableMessage?: string;
+        provider: ScopedTreePickerProvider;
+    };
 }
 export interface RecordFormFieldState {
     fieldName: string;
@@ -93,6 +112,13 @@ export interface RecordFormFieldState {
     optionTitleField?: string;
     optionItems?: import('../web-contracts/index').OptionItemDescriptor[];
     referenceTitleField?: string;
+    /** The compiled reference contract remains available to read-only detail and list renderers. */
+    reference?: ResolvedReferenceFieldDescriptor;
+    /**
+     * Source-neutral presentation resolved from the field control. It is intentionally separate
+     * from the provider: the descriptor chooses presentation while the host owns transport.
+     */
+    referencePickerPresentation?: RecordFormReferencePickerPresentation;
     /** Title for the standard TreeAbility root sentinel when this field is a tree parent reference. */
     treeRootTitle?: string;
     fileReference?: ResolvedFileReferenceFieldDescriptor;

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

@@ -0,0 +1,44 @@
+import type { OptionItemDescriptor, QuerySchemaField, ResolvedViewDescriptor, ResolvedViewFieldDescriptor, ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
+import type { Component } from 'vue';
+export type QueryListRecord = Record<string, unknown> & {
+    id?: string;
+    enabled?: boolean;
+};
+export type RecordQueryListMode = 'normal' | 'recycleBin';
+export type StandardCrudRowActionKey = 'view' | 'edit' | 'delete';
+/**
+ * Source-neutral list-column projection consumed by the standard table shell.
+ * It deliberately carries presentation facts only; cell rendering remains the table's responsibility.
+ */
+export interface RecordQueryListColumn {
+    key: string;
+    title: string;
+    type?: 'text' | 'enabledStatus' | 'booleanStatus' | 'tagList' | 'datetime' | 'fileSize' | 'colorPicker';
+    booleanStatus?: ResolvedViewFieldDescriptor['booleanStatus'];
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    titleField?: string;
+    /** Compiled reference facts for pure read-side title/summary rendering. */
+    reference?: ResolvedReferenceFieldDescriptor;
+    /** Only descriptor-declared option fields load a runtime option catalog. */
+    optionBinding?: boolean;
+    /** Dynamic child entity whose declared option binding owns this field. */
+    optionEntityAlias?: string;
+    /** Runtime dictionary/reference options used when the response has no title companion. */
+    optionItems?: OptionItemDescriptor[];
+    /** Maximum visible lines for text cells. Defaults to one line. */
+    maxDisplayLines?: number;
+    render?: (record: QueryListRecord) => string;
+}
+export interface RecordQueryListCellComponent {
+    key: string;
+    component: Component;
+}
+/**
+ * Compiles the source-neutral resolved list descriptor into the standard table's presentation model.
+ *
+ * `queryFields` is optional because descriptors normally carry their own value and option facts. It
+ * preserves the runtime list's compatibility fallback for older descriptors that still rely on the
+ * query schema for timestamp and option-title information.
+ */
+export declare function resolveRecordQueryListColumns(view: ResolvedViewDescriptor | undefined, queryFields?: readonly QuerySchemaField[]): RecordQueryListColumn[];

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

@@ -0,0 +1,103 @@
+/**
+ * Source-neutral candidate contract for records selected through an authorized
+ * reference source. IDs are the only persisted value; projections are display
+ * data and affectPatch remains an explicit, host-owned extension.
+ */
+export type ReferencePickerId = string;
+/** Whether the compact entry still represents the persisted reference selection. */
+export interface ReferencePickerValidity {
+    valid: boolean;
+    status: 'ready' | 'editing' | 'resolving' | 'unmatched' | 'error';
+    message?: string;
+}
+export interface ReferencePickerSourceIdentity {
+    targetModuleAlias: string;
+    source: {
+        kind: 'sourceField' | 'businessPurpose' | 'targetReference';
+        id: string;
+    };
+    /** A source-controlled authorization/range revision when it is available. */
+    authorizationScope?: string;
+}
+export interface ReferencePickerCandidate {
+    id: ReferencePickerId;
+    title: string;
+    subtitle?: string;
+    disabled?: boolean;
+    unavailable?: boolean;
+    projections?: Readonly<Record<string, unknown>>;
+    affectPatch?: Readonly<Record<string, unknown>>;
+}
+export interface ReferencePickerAxisSelection {
+    axisId: string;
+    itemId: string;
+}
+export interface ReferencePickerBrowseScope {
+    selections: readonly ReferencePickerAxisSelection[];
+}
+export interface ReferencePickerNavigationItem {
+    id: string;
+    title: string;
+    disabled?: boolean;
+}
+/** A declared browse axis. The picker clears dependent selections on an upstream change. */
+export interface ReferencePickerNavigationAxis {
+    id: string;
+    title: string;
+    dependsOn?: readonly string[];
+    items: readonly ReferencePickerNavigationItem[];
+}
+export interface ReferencePickerPageRequest {
+    keyword: string;
+    pageNum: number;
+    pageSize: number;
+    scope: ReferencePickerBrowseScope;
+}
+export interface ReferencePickerPage<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    records: TCandidate[];
+    total: number;
+    navigation?: readonly ReferencePickerNavigationAxis[];
+}
+/** A complete, source-authorized browse tree. It is never synthesized from paged query results. */
+export interface ReferencePickerTreeNode<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    record: TCandidate;
+    children?: ReferencePickerTreeNode<TCandidate>[];
+}
+export interface ReferencePickerProvider<TCandidate extends ReferencePickerCandidate = ReferencePickerCandidate> {
+    identity: ReferencePickerSourceIdentity;
+    searchPage(request: ReferencePickerPageRequest): Promise<ReferencePickerPage<TCandidate>>;
+    /**
+     * Reads the complete tree under the source's authorization scope. Dialog browse uses this only
+     * without a keyword; keyword search remains server-paged through searchPage.
+     */
+    loadTree?: (request: {
+        scope: ReferencePickerBrowseScope;
+    }) => Promise<ReferencePickerTreeNode<TCandidate>[]>;
+    /** Resolves persisted IDs under the source's authorized historical-display scope. */
+    resolve(ids: ReferencePickerId[]): Promise<TCandidate[]>;
+}
+export interface ReferencePickerColumn {
+    key: string;
+    title: string;
+    width?: number;
+}
+/** Compiled page/query configuration for a standard reference interaction. */
+export interface ReferencePickerConfig {
+    provider: ReferencePickerProvider;
+    mode?: 'dialog' | 'dropdown';
+    columns?: readonly ReferencePickerColumn[];
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    maxSelection?: number;
+    reloadKey?: string | number;
+}
+export interface ReferencePickerSelectionSummary {
+    id: ReferencePickerId;
+    title: string;
+    subtitle?: string;
+    unavailable?: boolean;
+}
+export declare function normalizeReferencePickerIds(value: ReferencePickerId | readonly ReferencePickerId[] | undefined, multiple: boolean): ReferencePickerId[];
+export declare function referencePickerValue(ids: readonly ReferencePickerId[], multiple: boolean): ReferencePickerId | ReferencePickerId[] | undefined;
+export declare function referencePickerSummary(candidate: ReferencePickerCandidate): ReferencePickerSelectionSummary;

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

@@ -0,0 +1,24 @@
+import { AppError } from '../web-core/index';
+export type ReferencePickerReadErrorKind = 'accessDenied' | 'missingDependencies' | 'unsupportedConfiguration' | 'temporaryFailure';
+/**
+ * The picker only classifies facts carried by AppError or facts its source can
+ * prove locally. It deliberately never derives a category from an error message.
+ */
+export declare class ReferencePickerReadError extends AppError {
+    readonly kind: ReferencePickerReadErrorKind;
+    readonly retryable: boolean;
+    readonly missingDependencyFields: readonly string[];
+    readonly original: AppError;
+    constructor(kind: ReferencePickerReadErrorKind, message: string, options: {
+        retryable: boolean;
+        missingDependencyFields?: readonly string[];
+        original?: AppError;
+    });
+}
+/**
+ * Returns undefined for 401 so the request client's authentication lifecycle
+ * remains the sole owner of login recovery and redirect behavior.
+ */
+export declare function referencePickerReadErrorOf(cause: unknown, fallbackMessage: string): ReferencePickerReadError | undefined;
+export declare function missingReferencePickerDependencies(sourceFields: readonly string[]): ReferencePickerReadError;
+export declare function unsupportedReferencePickerConfiguration(message: string): ReferencePickerReadError;

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

@@ -0,0 +1,48 @@
+import { type InjectionKey } from 'vue';
+import { type HttpClient, type ModuleContext } from '../web-core/index';
+import type { QueryListRecord } from './recordQueryListColumnModel';
+import { type RecordFormFieldDescriptor } from './recordFormFieldModel';
+export type ActiveReferenceRecord = {
+    targetModuleAlias: string;
+    recordId: string;
+    record?: QueryListRecord;
+    loading: boolean;
+    /** A record-only editor owns an in-flight target mutation. */
+    busy?: boolean;
+    failed: boolean;
+    failureKind?: 'notFound' | 'temporary';
+};
+export type ReferenceRecordDetailMutation = {
+    targetModuleAlias: string;
+    recordId: string;
+    type: 'saved' | 'deleted' | 'unavailable';
+    record?: QueryListRecord;
+};
+export interface ReferenceRecordDetailBrowser {
+    revision: {
+        value: number;
+    };
+    active: {
+        value: ActiveReferenceRecord | undefined;
+    };
+    activeContext: {
+        value: ModuleContext<QueryListRecord> | undefined;
+    };
+    fields: {
+        value: Map<string, RecordFormFieldDescriptor>;
+    };
+    title: {
+        value: string;
+    };
+    canBrowse(targetModuleAlias: string, recordId: string): boolean;
+    open(targetModuleAlias: string, recordId: string): void;
+    setBusy(targetModuleAlias: string, recordId: string, busy: boolean): void;
+    reportMutation(mutation: ReferenceRecordDetailMutation): void;
+    close(): void;
+    /** Component teardown bypasses the user-facing busy close gate. */
+    dispose(): void;
+}
+export declare const referenceRecordDetailBrowserKey: InjectionKey<ReferenceRecordDetailBrowser | undefined>;
+export declare function createReferenceRecordDetailBrowser(http: HttpClient): ReferenceRecordDetailBrowser;
+export declare function provideReferenceRecordDetailBrowser(browser: ReferenceRecordDetailBrowser): void;
+export declare function useReferenceRecordDetailBrowser(): ReferenceRecordDetailBrowser | undefined;

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

@@ -0,0 +1,46 @@
+/**
+ * An authorized, source-owned record projection for a lazily loaded tree selector.
+ * The component deliberately does not infer a parent, tenant, or module from this shape.
+ */
+export interface ScopedTreePickerCandidate {
+    id: string;
+    title: string;
+    /** A provider may return a path, code, or scope summary to disambiguate equal titles. */
+    subtitle?: string;
+    /** False keeps the item expandable and asks the provider for children when it is expanded. */
+    isLeaf?: boolean;
+    disabled?: boolean;
+    unavailable?: boolean;
+}
+export interface ScopedTreePickerRootRequest {
+    /** Provider-defined search text. An empty string requests the current scope roots. */
+    keyword: string;
+    signal: AbortSignal;
+}
+export interface ScopedTreePickerChildrenRequest extends ScopedTreePickerRootRequest {
+    parent: ScopedTreePickerCandidate;
+    /** Opaque continuation supplied by an earlier child response when the provider supports paging. */
+    cursor?: string;
+}
+export interface ScopedTreePickerPage {
+    records: ScopedTreePickerCandidate[];
+    hasMore?: boolean;
+    nextCursor?: string;
+}
+/**
+ * A source-owned delivery boundary. The caller may use a static reference resolver, a dedicated
+ * candidate endpoint, or another authorized source; this component has no module-path knowledge.
+ */
+export interface ScopedTreePickerProvider {
+    loadRoot: (request: ScopedTreePickerRootRequest) => Promise<ScopedTreePickerPage>;
+    loadChildren: (request: ScopedTreePickerChildrenRequest) => Promise<ScopedTreePickerPage>;
+    /** Resolves persisted IDs through the same authorization and effective-scope rule. */
+    resolve: (ids: string[]) => Promise<ScopedTreePickerCandidate[]>;
+}
+export interface ScopedTreePickerConfig {
+    title?: string;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    provider: ScopedTreePickerProvider;
+}
+export declare function scopedTreePickerValue(value: string | undefined): string | undefined;

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

@@ -0,0 +1,9 @@
+/**
+ * Reconciles a controlled selection with a freshly loaded collection.
+ *
+ * Platform components never infer a business fallback; callers supply it when their domain has
+ * one.  The shared rule is simply that a still-present stable key keeps focus after refresh.
+ */
+export declare function reconcileSelectedKey<Key>(previous: Key | undefined, available: Iterable<Key>, fallback?: Key): Key | undefined;
+/** Keeps only selected keys that are still present in the refreshed result set. */
+export declare function reconcileSelectedKeys<Key>(previous: Iterable<Key>, available: Iterable<Key>): Key[];

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

@@ -0,0 +1,5 @@
+/**
+ * Encodes partition values without collapsing distinct persisted values such as null and "".
+ * JSON is used instead of a delimiter so values cannot collide through delimiter characters.
+ */
+export declare function sortPartitionKey(values: readonly unknown[]): string;

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

@@ -0,0 +1,26 @@
+import type { ResolvedReferenceFieldDescriptor } from '../web-contracts/index';
+import type { ReferenceResolveClient } from '../web-core/index';
+import type { ReferencePickerProvider } from './referencePickerModel';
+export interface SourceReferencePickerProviderOptions {
+    sourceModuleAlias: string;
+    fieldName: string;
+    reference: ResolvedReferenceFieldDescriptor;
+    /** Obtained at request time so a retained provider does not capture a replaced module context. */
+    resolver: () => ReferenceResolveClient;
+    /** Read at request time so a stable provider always uses the current draft. */
+    formValues: () => Record<string, unknown>;
+    source: () => {
+        recordId: string;
+    } | undefined;
+}
+/**
+ * Adapts the source-field resolver to the neutral picker contract.  It deliberately carries no
+ * target-module query fallback: the declaring source field remains the authority for candidate
+ * eligibility, projections and patches.
+ */
+export declare function createSourceReferencePickerProvider({ sourceModuleAlias, fieldName, reference, resolver, formValues, source, }: SourceReferencePickerProviderOptions): ReferencePickerProvider;
+/**
+ * Only source identity, persisted record scope and declared candidate dependencies invalidate a
+ * picker.  This avoids resetting pagination or re-querying for unrelated form edits.
+ */
+export declare function sourceReferencePickerReloadKey(sourceModuleAlias: string, fieldName: string, reference: ResolvedReferenceFieldDescriptor, record: Record<string, unknown> | undefined): string;

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

@@ -1,3 +1,4 @@
+import { type Ref } from 'vue';
 import { type ModuleContext } from '../web-core/index';
 import type { UiConfirmOptions } from '../vue-ui-antdv/index';
 import { type PlatformActionResultReactionHandler } from './platformActionResultFeedback';
@@ -41,12 +42,12 @@ export interface StaticCrudManagementOptions<TRecord extends StaticCrudRecord> {
     actionResultReactionHandlers?: Record<string, PlatformActionResultReactionHandler | undefined>;
 }
 export declare function useFlatCrudManagementState<TRecord extends StaticCrudRecord>(options: StaticCrudManagementOptions<TRecord>): {
-    selected: import("vue").Ref<TRecord | undefined, TRecord | undefined>;
-    draft: [TRecord] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TRecord, import("vue").Ref<TRecord, TRecord>, TRecord> : import("vue").Ref<import("vue").UnwrapRef<TRecord>, TRecord | import("vue").UnwrapRef<TRecord>>;
-    mode: import("vue").Ref<StaticCrudCardMode, StaticCrudCardMode>;
-    reloadKey: import("vue").Ref<number, number>;
-    saving: import("vue").Ref<boolean, boolean>;
-    actionError: import("vue").Ref<string | undefined, string | undefined>;
+    selected: Ref<TRecord | undefined, TRecord | undefined>;
+    draft: Ref<TRecord, TRecord>;
+    mode: Ref<StaticCrudCardMode, StaticCrudCardMode>;
+    reloadKey: Ref<number, number>;
+    saving: Ref<boolean, boolean>;
+    actionError: Ref<string | undefined, string | undefined>;
     cardTitle: import("vue").ComputedRef<string>;
     readonly: import("vue").ComputedRef<boolean>;
     canCreate: import("vue").ComputedRef<boolean>;

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/index.d.ts

@@ -8,6 +8,8 @@ export type { OpenRouteOptions, WorkbenchNavigation, WorkbenchPageOpenResult } f
 export { routeUrlWithOpenOptions } from './workbenchNavigation';
 export { configureWorkspaceViewContributions, createWorkspaceViewDescriptor, createWorkspaceViewRegistry, dismissWorkspaceViewDescriptor, resolveWorkspaceView, } from './workspaceViews';
 export { provideWorkspaceViewHost, useWorkspaceViewHost } from './workspaceViewHost';
+export { useWorkspaceViewNavigation } from './workspaceViewNavigation';
+export { useWorkspaceViewUnsavedState } from './useWorkspaceViewUnsavedState';
 export { defineWorkspaceView } from './workspaceViewContract';
 export type { ResolvedWorkspaceView, WorkspaceViewRegistry } from './workspaceViews';
 export type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation, WorkspaceDrawerProfile, } from './workspaceViewContract';

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

@@ -0,0 +1,5 @@
+/**
+ * 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, isBusy?: () => boolean): void;

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

@@ -1,4 +1,4 @@
-import type { PageDescriptor, RouteQueryValue } from '../web-contracts/index';
+import type { MenuRecord, MenuTreeNode, PageDescriptor, RouteQueryValue } from '../web-contracts/index';
 export interface OpenRouteOptions {
     /** Opens an independent internal tab instance without changing the public URL. */
     newInstance?: boolean;
@@ -6,6 +6,10 @@ export interface OpenRouteOptions {
     query?: Record<string, RouteQueryValue>;
 }
 export interface WorkbenchNavigation {
+    /** Reloads visible menus without resetting open pages or their edits. */
+    refreshMenus?(): Promise<MenuTreeNode[]>;
+    /** Uses the same navigation policy as clicking a sidebar menu. */
+    openMenu?(menu: MenuRecord): void;
     openRoute(path: string, options?: OpenRouteOptions): WorkbenchPageOpenResult;
     replaceRoute(path: string, options?: OpenRouteOptions): WorkbenchPageOpenResult;
     closeCurrentTab(fallbackPath: string): WorkbenchPageOpenResult;

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

@@ -13,6 +13,11 @@ export interface WorkspaceViewDefinition<TInput extends WorkspaceViewInput> {
     drawerProfile?: WorkspaceDrawerProfile;
     routeTitle?: string;
     titleOf(input: TInput): string;
+    /**
+     * Returns the input fields that identify one workbench tab. Other parsed
+     * input fields remain URL-restorable view state and can change in-place.
+     */
+    tabIdentityParamsOf?(input: TInput): Record<string, RouteQueryValue>;
     parentRouteQueryOf?(input: TInput): Record<string, RouteQueryValue>;
     parse(query: Record<string, RouteQueryValue>): TInput | undefined;
     presentations: readonly WorkspaceViewPresentation[];

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

@@ -1,7 +1,12 @@
+import type { RouteQueryValue } from '../web-contracts/index';
 import type { WorkspaceViewPresentation } from './workspaceViewContract';
 export interface WorkspaceViewHost {
     presentation: WorkspaceViewPresentation;
     setTitle(title: string): void;
+    /** 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, isBusy?: () => boolean): () => void;
     dismiss(): void;
     /** Closes the current independent workbench view. */
     close(): void;

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

@@ -0,0 +1,9 @@
+import type { RouteQueryValue } from '../web-contracts/index';
+/**
+ * Updates navigation state owned by the current workspace view. The workbench
+ * replaces the current page descriptor, so this does not open another tab or
+ * add a browser-history entry.
+ */
+export declare function useWorkspaceViewNavigation(): {
+    replaceQuery(query: Record<string, RouteQueryValue | undefined>): void;
+};

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

@@ -0,0 +1,5 @@
+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/BusinessRuleGovernanceSurface.vue.d.ts

@@ -0,0 +1,10 @@
+import { type BusinessRuleFormulaCapability, type BusinessRuleFormulaCatalogEntry } from './businessRuleGovernance';
+type __VLS_Props = {
+    moduleAlias: string;
+    moduleTitle?: string;
+    /** A server-supplied portable catalogue can replace the built-in capability descriptors. */
+    formulaCapabilities?: readonly (BusinessRuleFormulaCapability | BusinessRuleFormulaCatalogEntry)[];
+};
+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/MetadataGovernanceSurface.vue.d.ts

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

@@ -0,0 +1,44 @@
+import { type UiTreeNode } from '../vue-ui-antdv/index';
+type __VLS_Props = {
+    nodes: UiTreeNode[];
+    title?: string;
+    embedded?: boolean;
+    searchKeyword?: string;
+    showSystemFields?: boolean;
+    searchable?: boolean;
+    refreshDisabled?: boolean;
+    loading?: boolean;
+    unavailable?: boolean;
+    unavailableDescription?: string;
+};
+declare var __VLS_34: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_34) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refresh: () => any;
+    "update:searchKeyword": (value: string) => any;
+    "update:showSystemFields": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefresh?: (() => any) | undefined;
+    "onUpdate:searchKeyword"?: ((value: string) => any) | undefined;
+    "onUpdate:showSystemFields"?: ((value: boolean) => any) | undefined;
+}>, {
+    title: string;
+    loading: boolean;
+    unavailable: boolean;
+    embedded: boolean;
+    refreshDisabled: boolean;
+    searchKeyword: string;
+    searchable: boolean;
+    showSystemFields: boolean;
+    unavailableDescription: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};