@ximatai/muyun-web-app 0.26.3

package/dist/types/App.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/app/ChangeOwnPasswordDialog.vue.d.ts

@@ -0,0 +1,27 @@
+type __VLS_Props = {
+    open?: boolean;
+    currentPassword: string;
+    newPassword: string;
+    confirmPassword: string;
+    saving?: boolean;
+    error?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+    submit: () => any;
+    "update:currentPassword": (value: string) => any;
+    "update:newPassword": (value: string) => any;
+    "update:confirmPassword": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+    onSubmit?: (() => any) | undefined;
+    "onUpdate:currentPassword"?: ((value: string) => any) | undefined;
+    "onUpdate:newPassword"?: ((value: string) => any) | undefined;
+    "onUpdate:confirmPassword"?: ((value: string) => any) | undefined;
+}>, {
+    open: boolean;
+    error: string;
+    saving: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/app/LoginView.vue.d.ts

@@ -0,0 +1,14 @@
+import type { AuthClient } from '@muyun/web-core';
+import type { LoginResult } from '@muyun/web-contracts';
+type __VLS_Props = {
+    authClient: AuthClient;
+    loading?: boolean;
+    error?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    authenticated: (result: LoginResult) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAuthenticated?: ((result: LoginResult) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/app/appWorkbenchStartup.d.ts

@@ -0,0 +1,3 @@
+import type { WorkbenchStartupState } from '@muyun/web-contracts';
+export declare function loadAppWorkbenchStartupState(): Promise<WorkbenchStartupState>;
+export declare function usesMockStartup(): boolean;

package/dist/types/app/devWorkbenchStartup.d.ts

@@ -0,0 +1 @@
+export declare function loadDevWorkbenchStartupState(): Promise<import("../web-contracts").WorkbenchStartupState>;

package/dist/types/app/loginTenant.d.ts

@@ -0,0 +1,6 @@
+export interface LoginTenantDefaults {
+    tenantId: string;
+    tenantLocked: boolean;
+}
+export declare function resolveLoginTenantDefaults(envTenantId?: string | null, search?: string, pathname?: string): LoginTenantDefaults;
+export declare function normalizeInitialValue(value: string | null | undefined): string;

package/dist/types/app/platformMessage.d.ts

@@ -0,0 +1,6 @@
+import type { PlatformErrorCode } from '@muyun/web-core';
+/**
+ * Application-facing message boundary. The current platform only ships a zh-CN
+ * default dictionary; future locale packs resolve the same stable error code here.
+ */
+export declare function platformMessage(code: PlatformErrorCode, fallback: string, locale?: string): string;

package/dist/types/app/query.d.ts

@@ -0,0 +1,3 @@
+import { VueQueryPlugin } from '@muyun/web-core';
+export declare const queryClient: import("@tanstack/vue-query").QueryClient;
+export { VueQueryPlugin };

package/dist/types/app/router.d.ts

@@ -0,0 +1 @@
+export declare const router: import("vue-router")._RouterClassic;

package/dist/types/app/workbenchStartup.d.ts

@@ -0,0 +1,24 @@
+import type { MenuClient, SessionClient } from '@muyun/web-core';
+import type { MenuNavigationTarget, MenuRecord, MenuTab, PageDescriptor, WorkbenchStartupState } from '@muyun/web-contracts';
+import { type PageDescriptorResolveOptions } from '@muyun/platform-workbench';
+export interface WorkbenchStartupClients {
+    sessionClient: SessionClient;
+    menuClient: MenuClient;
+}
+export declare function loadWorkbenchStartupState(clients: WorkbenchStartupClients, options?: PageDescriptorResolveOptions): Promise<WorkbenchStartupState>;
+export declare function openMenuTab(tabs: MenuTab[], menu: MenuRecord, target: MenuNavigationTarget, options?: PageDescriptorResolveOptions): {
+    tabs: MenuTab[];
+    activeTabKey: string;
+};
+export declare function openDirectTab(tabs: MenuTab[], descriptor: PageDescriptor): {
+    tabs: MenuTab[];
+    activeTabKey: string;
+    created: boolean;
+};
+export declare function menuTargetUrl(menu: MenuRecord, target: MenuNavigationTarget): string;
+export declare function activeTabUrlOf(state: WorkbenchStartupState): string | undefined;
+export declare function restoreWorkbenchStartupStateFromUrl(state: WorkbenchStartupState, url: string, options?: PageDescriptorResolveOptions): WorkbenchStartupState;
+export declare function closeMenuTab(tabs: MenuTab[], activeTabKey: string | undefined, closedTabKey: string): {
+    tabs: MenuTab[];
+    activeTabKey: string | undefined;
+};

package/dist/types/consumer/PlatformAdminOutlet.vue.d.ts

@@ -0,0 +1,7 @@
+import type { PageDescriptor } from '@muyun/web-contracts';
+type __VLS_Props = {
+    descriptor?: PageDescriptor;
+};
+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/consumer/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public App-consumer surface. It deliberately exposes the workbench shell
+ * and its runtime primitives, including first-party platform administration
+ * pages.  It deliberately excludes pages owned by a consuming business App.
+ *
+ * Consumers must import `@ximatai/muyun-web-app/style.css` explicitly.
+ */
+import '../styles.css';
+export * from '../web-contracts/index';
+export * from '../web-core/index';
+export * from '../platform-components/index';
+export * from '../dynamic-page-runtime/index';
+export * from '../platform-workbench/index';
+export * from '../platform-admin-runtime/index';
+export { default as PlatformAdminOutlet } from './PlatformAdminOutlet.vue';

package/dist/types/dynamic-page-runtime/DynamicModuleHost.vue.d.ts

@@ -0,0 +1,7 @@
+import type { DynamicModulePageDescriptor } from '@muyun/web-contracts';
+type __VLS_Props = {
+    descriptor: DynamicModulePageDescriptor;
+};
+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/dynamic-page-runtime/DynamicModulePage.vue.d.ts

@@ -0,0 +1,7 @@
+import type { DynamicPageDescriptor } from '@muyun/web-contracts';
+type __VLS_Props = {
+    descriptor: DynamicPageDescriptor;
+};
+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/dynamic-page-runtime/actionReactions.d.ts

@@ -0,0 +1,16 @@
+import type { ActionContract } from '@muyun/web-contracts';
+export type DynamicLegacyActionRefresh = 'none' | 'record' | 'list' | 'all';
+export interface DynamicActionReaction {
+    type: 'refresh-list' | 'refresh-detail';
+    payload?: {
+        moduleAlias?: string;
+        recordId?: string;
+    };
+}
+export interface DynamicLegacyRefreshActionContract extends ActionContract {
+    refresh?: DynamicLegacyActionRefresh;
+}
+export declare function resolveDynamicActionReactions(action: ActionContract, context: {
+    moduleAlias: string;
+    recordId?: string;
+}): DynamicActionReaction[];

package/dist/types/dynamic-page-runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DynamicModuleHost } from './DynamicModuleHost.vue';
+export { default as DynamicModulePage } from './DynamicModulePage.vue';
+export { customerDescriptor } from './mockDescriptor';

package/dist/types/dynamic-page-runtime/mockDescriptor.d.ts

@@ -0,0 +1,2 @@
+import type { DynamicPageDescriptor } from '@muyun/web-contracts';
+export declare const customerDescriptor: DynamicPageDescriptor;

package/dist/types/main.d.ts

@@ -0,0 +1,2 @@
+import '@muyun/vue-ui-antdv/styles.css';
+import './styles.css';

package/dist/types/platform-admin-runtime/PlatformAdminOutlet.vue.d.ts

@@ -0,0 +1,7 @@
+import type { BusinessRoutePageDescriptor } from '@muyun/web-contracts';
+type __VLS_Props = {
+    descriptor: BusinessRoutePageDescriptor;
+};
+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-admin-runtime/WorkspaceViewDrawer.vue.d.ts

@@ -0,0 +1,32 @@
+import { type DrawerPromotion } from '@muyun/platform-components';
+import type { WorkspaceDrawerProfile } from './workspaceViewContract';
+type __VLS_Props = {
+    open: boolean;
+    title: string;
+    subtitle?: string;
+    profile?: WorkspaceDrawerProfile;
+    promotion?: DrawerPromotion;
+};
+declare var __VLS_11: {}, __VLS_13: {};
+type __VLS_Slots = {} & {
+    operation?: (props: typeof __VLS_11) => any;
+} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (() => any) | undefined;
+}>, {
+    subtitle: string;
+    profile: WorkspaceDrawerProfile;
+    promotion: DrawerPromotion;
+}, {}, {}, {}, 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;
+    };
+};

package/dist/types/platform-admin-runtime/WorkspaceViewOutlet.vue.d.ts

@@ -0,0 +1,7 @@
+import type { BusinessRoutePageDescriptor } from '@muyun/web-contracts';
+type __VLS_Props = {
+    descriptor: BusinessRoutePageDescriptor;
+};
+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-admin-runtime/authSession.d.ts

@@ -0,0 +1,8 @@
+export declare function effectiveAuthToken(envToken?: string): string | undefined;
+export declare function storedAuthToken(): string | undefined;
+export declare function storedAuthSessionId(): string | undefined;
+export declare function saveAuthToken(token: string): void;
+export declare function saveAuthSessionId(sessionId?: string | null): void;
+export declare function clearAuthToken(): void;
+export declare function isAuthenticationRequiredError(cause: unknown): boolean;
+export declare function isPasswordChangeRequiredError(cause: unknown): boolean;

package/dist/types/platform-admin-runtime/backendHttp.d.ts

@@ -0,0 +1,3 @@
+export declare function createBackendHttpClient(options?: {
+    withAuth?: boolean;
+}): import("@muyun/web-core").HttpClient;

package/dist/types/platform-admin-runtime/currentUserContext.d.ts

@@ -0,0 +1,4 @@
+import { type Ref } from 'vue';
+import type { CurrentUser } from '@muyun/web-contracts';
+export declare function provideCurrentUserContext(currentUser: Readonly<Ref<CurrentUser | undefined>>): void;
+export declare function useCurrentUserContext(): Readonly<Ref<CurrentUser | undefined, CurrentUser | undefined>> | undefined;

package/dist/types/platform-admin-runtime/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * First-party management runtime shipped to management-oriented applications.
+ *
+ * It owns the platform administration route registry and the context APIs
+ * required by those pages.  Application composition remains outside this
+ * directory: an App supplies its startup state, navigation and HTTP factory.
+ */
+export { default as PlatformAdminRouteOutlet } from './PlatformAdminOutlet.vue';
+export { isPlatformAdminRoutePage, platformAdminModuleRoutes, platformAdminRouteLayouts, platformAdminRoutePrefixes, platformAdminRoutes, resolvePlatformAdminRoute, } from './platformAdminRoutes';
+export type { PlatformAdminRoute } from './platformAdminRoutes';
+export { provideCurrentUserContext, useCurrentUserContext } from './currentUserContext';
+export { createBackendHttpClient } from './backendHttp';

package/dist/types/platform-admin-runtime/moduleOpenApi.d.ts

@@ -0,0 +1,36 @@
+import type { HttpClient } from '@muyun/web-core';
+import type { PageDescriptor } from '@muyun/web-contracts';
+export interface ModuleOpenApiDocument {
+    openapi: string;
+    info: {
+        title?: string;
+        version?: string;
+    };
+    paths: Record<string, unknown>;
+    components?: Record<string, unknown>;
+    'x-muyun-module-alias'?: string;
+}
+/** Returns the module alias only for the dedicated, authenticated OpenAPI viewer path. */
+export declare function moduleAliasFromOpenApiPath(pathname: string): string | undefined;
+/** Creates the workbench page contract for one module's authenticated API document. */
+export declare function createModuleOpenApiPageDescriptor(moduleAlias: string, moduleTitle?: string): PageDescriptor;
+/** Recognizes the app-owned OpenAPI tab without teaching the shared route resolver about this feature. */
+export declare function isModuleOpenApiPage(descriptor?: PageDescriptor): boolean;
+export declare function isOpenApiCatalogPath(pathname: string): boolean;
+export interface OpenApiModuleCatalogItem {
+    moduleAlias: string;
+    title: string;
+    moduleKind: 'static' | 'dynamic';
+    documentPath: string;
+}
+/** Loads the source-independent API document through the normal authenticated backend client. */
+export declare function loadModuleOpenApi(client: HttpClient, moduleAlias: string): Promise<ModuleOpenApiDocument>;
+export declare function loadOpenApiCatalog(client: HttpClient): Promise<OpenApiModuleCatalogItem[]>;
+/**
+ * Supplies the workbench session only to this application's frontend or configured backend origin.
+ * Scalar may render user-selectable servers, so forwarding the token to an arbitrary server would
+ * turn a documentation convenience into a credential leak.
+ */
+export declare function createOpenApiAuthenticatedFetch(): typeof fetch;
+/** Resolves the backend server used by the workbench's interactive API client. */
+export declare function openApiBackendBaseUrl(): any;

package/dist/types/platform-admin-runtime/pageRealtime.d.ts

@@ -0,0 +1,61 @@
+import { type WebBusinessRealtimeEvent, type WebCommittedChangeSet, type WebDataChange } from '@muyun/web-contracts';
+export interface PageRealtimeSubscription {
+    unsubscribe(): void;
+}
+export interface PageBusinessEventOptions {
+    type?: string | string[];
+    moduleAlias?: string;
+    recordId?: string | (() => string | undefined);
+    handler: (event: WebBusinessRealtimeEvent) => void | Promise<void>;
+    predicate?: (event: WebBusinessRealtimeEvent) => boolean;
+}
+export interface PageDataChangeOptions {
+    moduleAlias?: string;
+    recordId?: string | (() => string | undefined);
+    handler: (changeSet: WebCommittedChangeSet, changes: WebDataChange[]) => void | Promise<void>;
+    predicate?: (change: WebDataChange) => boolean;
+}
+export interface PageRecordExternalChangeOptions {
+    moduleAlias: string;
+    recordId: string | (() => string | undefined);
+    editing: boolean | (() => boolean);
+    saving?: boolean | (() => boolean);
+    changeTypes?: string[];
+}
+export interface PageRecordExternalChangeState {
+    externalChangedRecordId: Readonly<{
+        value: string | undefined;
+    }>;
+    externallyChanged: Readonly<{
+        value: boolean;
+    }>;
+    markExternalRecordChanged(recordId: string | undefined): boolean;
+    clearExternalChanged(): void;
+    handleDataChanges(changes: WebDataChange[]): void;
+}
+export interface RealtimeRefreshQueueOptions<TKey extends string> {
+    delay?: number;
+    load: (run: RealtimeRefreshRun<TKey>) => void | Promise<void>;
+}
+export interface RealtimeRefreshRun<TKey extends string> {
+    keys: TKey[];
+    isLatest(key: TKey): boolean;
+    active(): boolean;
+}
+export interface RealtimeRefreshQueue<TKey extends string> {
+    enqueue(key: TKey | TKey[] | undefined): void;
+    reset(): void;
+    dispose(): void;
+}
+export declare function createPageBusinessEventHandler(options: PageBusinessEventOptions): (event: WebBusinessRealtimeEvent) => void;
+export declare function createPageDataChangeHandler(options: PageDataChangeOptions): (changeSet: WebCommittedChangeSet) => void;
+export declare function usePageDataChangeHandler(handler: (changeSet: WebCommittedChangeSet) => void | Promise<void>): void;
+export declare function usePageModuleDataChanges(moduleAlias: string): void;
+export declare function usePageBusinessEventHandler(handler: (event: WebBusinessRealtimeEvent) => void | Promise<void>): void;
+export declare function usePageBusinessEvent(options: PageBusinessEventOptions): void;
+export declare function usePageDataChange(options: PageDataChangeOptions): void;
+export declare function usePageRecordExternalChange(options: PageRecordExternalChangeOptions): PageRecordExternalChangeState;
+export declare function createPageRecordExternalChangeState(options: PageRecordExternalChangeOptions): PageRecordExternalChangeState;
+export declare function useRealtimeRefreshQueue<TKey extends string>(options: RealtimeRefreshQueueOptions<TKey>): RealtimeRefreshQueue<TKey>;
+export declare function createRealtimeRefreshQueue<TKey extends string>(options: RealtimeRefreshQueueOptions<TKey>): RealtimeRefreshQueue<TKey>;
+export declare function usePageRealtimeSubscription(factory: () => PageRealtimeSubscription): void;

package/dist/types/platform-admin-runtime/platformAdminRoutes.d.ts

@@ -0,0 +1,21 @@
+import type { Component } from 'vue';
+import type { BusinessRoutePageDescriptor, PageDescriptor, PageLayoutMode } from '@muyun/web-contracts';
+export interface PlatformAdminRoute {
+    route: string;
+    moduleAlias: string;
+    component: Component;
+    /** Page layout contract resolved before the route enters the workbench. */
+    layout: PageLayoutMode;
+    /** Internal pages share a module context but must not replace that module's menu route. */
+    menuEntry?: boolean;
+}
+export declare const platformAdminRoutes: PlatformAdminRoute[];
+export declare const platformAdminRoutePrefixes: string[];
+export declare const platformAdminModuleRoutes: {
+    [k: string]: string;
+};
+export declare const platformAdminRouteLayouts: {
+    [k: string]: PageLayoutMode;
+};
+export declare function resolvePlatformAdminRoute(descriptor?: BusinessRoutePageDescriptor): PlatformAdminRoute | undefined;
+export declare function isPlatformAdminRoutePage(descriptor?: PageDescriptor): descriptor is BusinessRoutePageDescriptor;

package/dist/types/platform-admin-runtime/realtime.d.ts

@@ -0,0 +1,20 @@
+import { type RealtimeClient, type RealtimeConnectionState } from '@muyun/web-core';
+import type { WebBusinessRealtimeEvent, WebCommittedChangeSet, WebUserNotification } from '@muyun/web-contracts';
+export declare const appDataChangeDispatcher: import("@muyun/web-core").DataChangeDispatcher;
+export interface AppRealtimeOptions {
+    onUnauthorized?: () => void;
+    onUserNotification?: (notification: WebUserNotification) => void;
+    onStateChange?: (state: RealtimeConnectionState) => void;
+}
+export declare function createAppRealtimeClient(options?: AppRealtimeOptions): RealtimeClient;
+export declare function connectAppRealtime(options?: AppRealtimeOptions): {
+    realtime: RealtimeClient;
+    disconnect(): Promise<void>;
+};
+export declare function subscribeAppModuleDataChanges(moduleAlias: string): {
+    unsubscribe(): void;
+};
+export declare function subscribeAppDataChanges(handler: (changeSet: WebCommittedChangeSet) => void | Promise<void>): import("@muyun/web-core").DataChangeSubscription;
+export declare function subscribeAppBusinessEvents(handler: (event: WebBusinessRealtimeEvent) => void | Promise<void>): {
+    unsubscribe(): void;
+};

package/dist/types/platform-admin-runtime/sessionRecovery.d.ts

@@ -0,0 +1,3 @@
+import type { AppError } from '@muyun/web-core';
+export declare function configureAuthenticationRecovery(handler: (error: AppError, token?: string) => boolean): void;
+export declare function recoverAuthentication(error: AppError, token?: string): boolean;

package/dist/types/platform-admin-runtime/useWorkspaceViewPromotion.d.ts

@@ -0,0 +1,24 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { DrawerPromotion } from '@muyun/platform-components';
+import { type WorkspaceViewDefinition, type WorkspaceViewInput } from './workspaceViews';
+/** Facts required by the source host; dirty state belongs to the shared view session. */
+export interface WorkspaceViewPromotionEligibility {
+    hasStableIdentity: boolean;
+    busy?: boolean;
+    /** A legacy host may decline until its detail state has moved into a view session. */
+    canChangeHost?: boolean;
+}
+export declare function canPromoteWorkspaceView(eligibility: WorkspaceViewPromotionEligibility): boolean;
+export declare function useWorkspaceViewPromotion<TInput extends WorkspaceViewInput>(options: {
+    view: WorkspaceViewDefinition<TInput>;
+    input: MaybeRefOrGetter<TInput | undefined>;
+    /** A source host can provide its resolved business identity for the new tab label. */
+    title?: MaybeRefOrGetter<string | undefined>;
+    eligibility: MaybeRefOrGetter<WorkspaceViewPromotionEligibility>;
+    /** Transfers source state before the target opens; return false when an existing target rejects it. */
+    beforePromote?: (input: TInput) => boolean | void | Promise<boolean | void>;
+    onPromoted?: (result: {
+        created: boolean;
+    }) => void;
+    onPromotionRejected?: () => void;
+}): import("vue").ComputedRef<DrawerPromotion | undefined>;

package/dist/types/platform-admin-runtime/workspaceViewContract.d.ts

@@ -0,0 +1,36 @@
+import type { Component } from 'vue';
+import type { PageLayoutMode, RouteQueryValue } from '@muyun/web-contracts';
+export type WorkspaceViewInput = object;
+export type WorkspaceViewPresentation = 'drawer' | 'tab';
+/**
+ * Semantic drawer capacities owned by the workbench, rather than by a
+ * particular business page.  A work view declares the amount of workspace it
+ * needs; the host decides the actual pixel value and narrow-screen fallback.
+ */
+export type WorkspaceDrawerProfile = 'detail' | 'wide-work';
+/** Stable declaration shared by all workbench view hosts. */
+export interface WorkspaceViewDefinition<TInput extends WorkspaceViewInput> {
+    type: string;
+    route: string;
+    moduleAlias: string;
+    component: Component;
+    /** Vertical layout contract used when the work view is opened in a tab. */
+    layout?: PageLayoutMode;
+    /** Drawer capacity used when this view is opened as a drawer. */
+    drawerProfile?: WorkspaceDrawerProfile;
+    /** Title restored when a URL-addressable drawer returns to its ordinary route. */
+    routeTitle?: string;
+    titleOf(input: TInput): string;
+    /**
+     * Route context that remains after a drawer is closed.
+     *
+     * A work view may need parent-page context (for example a role ownership
+     * scope) both to identify the view and to return the user to the same
+     * ordinary route.  This keeps that context distinct from the transient
+     * work-view presentation and record identity.
+     */
+    parentRouteQueryOf?(input: TInput): Record<string, RouteQueryValue>;
+    parse(query: Record<string, RouteQueryValue>): TInput | undefined;
+    presentations: readonly WorkspaceViewPresentation[];
+}
+export declare function defineWorkspaceView<TInput extends WorkspaceViewInput>(definition: WorkspaceViewDefinition<TInput>): WorkspaceViewDefinition<TInput>;

package/dist/types/platform-admin-runtime/workspaceViewContributions.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceViewDefinition, WorkspaceViewInput } from './workspaceViewContract';
+/** Application assembly for restorable workspace views. */
+export declare const workspaceViewContributions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[];

package/dist/types/platform-admin-runtime/workspaceViewHost.d.ts

@@ -0,0 +1,10 @@
+import type { WorkspaceViewPresentation } from './workspaceViewContract';
+/** Runtime host facts shared with a view without exposing workbench navigation to business code. */
+export interface WorkspaceViewHost {
+    presentation: WorkspaceViewPresentation;
+    /** Updates the host tab label without leaking workbench navigation into business views. */
+    setTitle(title: string): void;
+    dismiss(): void;
+}
+export declare function provideWorkspaceViewHost(host: WorkspaceViewHost): void;
+export declare function useWorkspaceViewHost(): WorkspaceViewHost | undefined;

package/dist/types/platform-admin-runtime/workspaceViewSessions.d.ts

@@ -0,0 +1,18 @@
+import type { WorkspaceViewDefinition, WorkspaceViewInput } from './workspaceViewContract';
+/** A mounted workspace view may accept a source drawer's in-memory editing state. */
+export type WorkspaceViewHandoffRecipient<TSession> = (session: TSession) => boolean | Promise<boolean>;
+export declare function workspaceViewInstanceKey<TInput extends WorkspaceViewInput>(view: WorkspaceViewDefinition<TInput>, input: TInput): string;
+export declare function getOrCreateWorkspaceViewSession<TInput extends WorkspaceViewInput, TSession>(view: WorkspaceViewDefinition<TInput>, input: TInput, create: () => TSession): TSession;
+export declare function discardWorkspaceViewSession<TInput extends WorkspaceViewInput>(view: WorkspaceViewDefinition<TInput>, input: TInput): void;
+/** Replaces a pending hand-off session before the target host is mounted. */
+export declare function replaceWorkspaceViewSession<TInput extends WorkspaceViewInput, TSession>(view: WorkspaceViewDefinition<TInput>, input: TInput, session: TSession): void;
+/**
+ * Delivers a workspace hand-off to an already mounted target when possible;
+ * otherwise stores it for the target that is about to mount. A recipient can
+ * reject the delivery when it owns conflicting, unsaved state.
+ */
+export declare function handOffWorkspaceViewSession<TInput extends WorkspaceViewInput, TSession>(view: WorkspaceViewDefinition<TInput>, input: TInput, session: TSession): Promise<"accepted" | "rejected">;
+/** Registers the mounted host that can receive a hand-off for one stable workspace identity. */
+export declare function registerWorkspaceViewHandoffRecipient<TInput extends WorkspaceViewInput, TSession>(view: WorkspaceViewDefinition<TInput>, input: TInput, recipient: WorkspaceViewHandoffRecipient<TSession>): () => void;
+/** Consumes a one-time hand-off session; later deep links reload from the URL. */
+export declare function takeWorkspaceViewSession<TInput extends WorkspaceViewInput, TSession>(view: WorkspaceViewDefinition<TInput>, input: TInput): TSession | undefined;

package/dist/types/platform-admin-runtime/workspaceViews.d.ts

@@ -0,0 +1,18 @@
+import type { BusinessRoutePageDescriptor } from '@muyun/web-contracts';
+import type { WorkspaceViewDefinition, WorkspaceViewInput, WorkspaceViewPresentation } from './workspaceViewContract';
+export { defineWorkspaceView, type WorkspaceViewDefinition, type WorkspaceViewInput, type WorkspaceViewPresentation, } from './workspaceViewContract';
+export interface ResolvedWorkspaceView {
+    view: WorkspaceViewDefinition<WorkspaceViewInput>;
+    input: WorkspaceViewInput;
+    presentation: WorkspaceViewPresentation;
+}
+export interface WorkspaceViewRegistry {
+    definitions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[];
+    resolve(descriptor: BusinessRoutePageDescriptor): ResolvedWorkspaceView | undefined;
+}
+export declare function createWorkspaceViewRegistry(definitions: readonly WorkspaceViewDefinition<WorkspaceViewInput>[]): WorkspaceViewRegistry;
+export declare const workspaceViewRegistry: WorkspaceViewRegistry;
+export declare function createWorkspaceViewDescriptor<TInput extends WorkspaceViewInput>(view: WorkspaceViewDefinition<TInput>, input: TInput, presentation?: WorkspaceViewPresentation, title?: string): BusinessRoutePageDescriptor;
+/** Returns the ordinary route descriptor after a URL-restored drawer is dismissed. */
+export declare function dismissWorkspaceViewDescriptor(descriptor: BusinessRoutePageDescriptor, view: WorkspaceViewDefinition<WorkspaceViewInput>): BusinessRoutePageDescriptor;
+export declare function resolveWorkspaceView(descriptor: BusinessRoutePageDescriptor): ResolvedWorkspaceView | undefined;

package/dist/types/platform-components/ApplicationScopeSwitcher.vue.d.ts

@@ -0,0 +1,18 @@
+import type { Option, OptionValue } from '@muyun/web-contracts';
+type __VLS_Props = {
+    value?: OptionValue | null;
+    options: Option[];
+    disabled?: boolean;
+    placeholder?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:value": (value: OptionValue | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:value"?: ((value: OptionValue | null) => any) | undefined;
+}>, {
+    disabled: boolean;
+    value: OptionValue | null;
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-components/CrudRecordListExplorer.vue.d.ts

@@ -0,0 +1,52 @@
+import { type UiRecordInlineAction } from '@muyun/vue-ui-antdv';
+import { type ModuleContext } from '@muyun/web-core';
+import type { RecordExplorerItemDescriptor } from './recordExplorerItemModel';
+import { type CrudRecordListBase } from './crudRecordListModel';
+export type CrudRecordListMode = 'normal' | 'recycleBin';
+type __VLS_Props = {
+    context: ModuleContext<CrudRecordListBase>;
+    selectedId?: string;
+    reloadKey?: number;
+    keyword?: string;
+    emptyDescription?: string;
+    loadingTip?: string;
+    fallbackTitle?: string;
+    titleOf?: (record: CrudRecordListBase) => string;
+    subtitleOf?: (record: CrudRecordListBase) => string | undefined;
+    itemOf?: (record: CrudRecordListBase) => RecordExplorerItemDescriptor | undefined;
+    actionsOf?: (record: CrudRecordListBase) => UiRecordInlineAction[];
+    filterOption?: (record: CrudRecordListBase, normalizedKeyword: string) => boolean;
+    tagOf?: (record: CrudRecordListBase) => string | undefined;
+    mutedOf?: (record: CrudRecordListBase) => boolean;
+    mode?: CrudRecordListMode;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (record: CrudRecordListBase) => any;
+    action: (action: UiRecordInlineAction, record: CrudRecordListBase) => any;
+    loaded: (records: CrudRecordListBase[]) => any;
+    restored: () => any;
+    recycleBinSummary: (total: number | undefined) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((record: CrudRecordListBase) => any) | undefined;
+    onAction?: ((action: UiRecordInlineAction, record: CrudRecordListBase) => any) | undefined;
+    onLoaded?: ((records: CrudRecordListBase[]) => any) | undefined;
+    onRestored?: (() => any) | undefined;
+    onRecycleBinSummary?: ((total: number | undefined) => any) | undefined;
+}>, {
+    mode: CrudRecordListMode;
+    filterOption: (record: CrudRecordListBase, normalizedKeyword: string) => boolean;
+    emptyDescription: string;
+    selectedId: string;
+    keyword: string;
+    titleOf: (record: CrudRecordListBase) => string;
+    itemOf: (record: CrudRecordListBase) => RecordExplorerItemDescriptor | undefined;
+    actionsOf: (record: CrudRecordListBase) => UiRecordInlineAction[];
+    tagOf: (record: CrudRecordListBase) => string | undefined;
+    mutedOf: (record: CrudRecordListBase) => boolean;
+    reloadKey: number;
+    loadingTip: string;
+    fallbackTitle: string;
+    subtitleOf: (record: CrudRecordListBase) => string | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/platform-components/DateTimeText.vue.d.ts

@@ -0,0 +1,15 @@
+import { type PlatformDateTimePrecision } from './platformDateTime';
+type __VLS_Props = {
+    value?: string | number | Date | null;
+    emptyText?: string;
+    precision?: PlatformDateTimePrecision;
+    timeZone?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    value: string | number | Date | null;
+    emptyText: string;
+    precision: PlatformDateTimePrecision;
+    timeZone: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;