@ximatai/muyun-web-app 0.26.3

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

@@ -0,0 +1,18 @@
+type __VLS_Props = {
+    enabled?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    showLabel?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (enabled: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((enabled: boolean) => any) | undefined;
+}>, {
+    enabled: boolean;
+    disabled: boolean;
+    loading: boolean;
+    showLabel: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    enabled?: boolean;
+};
+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-components/RecordTreeSelector.vue.d.ts

@@ -0,0 +1,22 @@
+export interface RecordTreeSelectorRecord {
+    id: string;
+    parentId?: string;
+    title?: string;
+    secondary?: string;
+    enabled?: boolean;
+}
+type __VLS_Props = {
+    records: RecordTreeSelectorRecord[];
+    selectedId?: string;
+    emptyDescription?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (record: RecordTreeSelectorRecord) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((record: RecordTreeSelectorRecord) => any) | undefined;
+}>, {
+    emptyDescription: string;
+    selectedId: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    active?: boolean;
+    hasRecords?: boolean;
+    count?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    count: number;
+    active: boolean;
+    hasRecords: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,44 @@
+type __VLS_Props = {
+    explorerTitle: string;
+    refreshTitle: string;
+    mode: 'view' | 'edit' | 'create';
+    detailTitle: string;
+    mutedMessage?: string;
+    explorerSearchKeyword?: string;
+    explorerSearchPlaceholder?: string;
+    explorerSearchable?: boolean;
+};
+declare var __VLS_24: {}, __VLS_26: {}, __VLS_29: {}, __VLS_38: {}, __VLS_41: {}, __VLS_43: {};
+type __VLS_Slots = {} & {
+    'explorer-actions'?: (props: typeof __VLS_24) => any;
+} & {
+    explorer?: (props: typeof __VLS_26) => any;
+} & {
+    'explorer-footer'?: (props: typeof __VLS_29) => any;
+} & {
+    'detail-status'?: (props: typeof __VLS_38) => any;
+} & {
+    'detail-actions'?: (props: typeof __VLS_41) => any;
+} & {
+    default?: (props: typeof __VLS_43) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refresh: () => any;
+    "update:explorerSearchKeyword": (keyword: string) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefresh?: (() => any) | undefined;
+    "onUpdate:explorerSearchKeyword"?: ((keyword: string) => any) | undefined;
+}>, {
+    mutedMessage: string;
+    explorerSearchKeyword: string;
+    explorerSearchPlaceholder: string;
+    explorerSearchable: boolean;
+}, {}, {}, {}, 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-components/TreeRecordExplorer.vue.d.ts

@@ -0,0 +1,57 @@
+import { type UiRecordInlineAction } from '@muyun/vue-ui-antdv';
+import type { ModuleContext } from '@muyun/web-core';
+import type { RecordExplorerItemDescriptor } from './recordExplorerItemModel';
+import { type TreeRecordBase } from './treeRecordModel';
+type TreeRecordSearchMode = 'always' | 'collapsible' | 'none';
+type __VLS_Props = {
+    context: ModuleContext<TreeRecordBase>;
+    selectedId?: string;
+    reloadKey?: number;
+    keyword?: string;
+    searchMode?: TreeRecordSearchMode;
+    searchTrigger?: 'inline' | 'external';
+    searchPlaceholder?: string;
+    emptyDescription?: string;
+    loadingTip?: string;
+    fallbackTitle?: string;
+    titleOf?: (record: TreeRecordBase) => string;
+    secondaryOf?: (record: TreeRecordBase) => string | undefined;
+    itemOf?: (record: TreeRecordBase) => RecordExplorerItemDescriptor | undefined;
+    actionsOf?: (record: TreeRecordBase) => UiRecordInlineAction[];
+    filterOption?: (record: TreeRecordBase, normalizedKeyword: string) => boolean;
+    tagOf?: (record: TreeRecordBase) => string | undefined;
+    mutedOf?: (record: TreeRecordBase) => boolean;
+};
+declare function openSearch(): void;
+declare function toggleSearch(): void;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    openSearch: typeof openSearch;
+    toggleSearch: typeof toggleSearch;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (record: TreeRecordBase) => any;
+    action: (action: UiRecordInlineAction, record: TreeRecordBase) => any;
+    loaded: (records: TreeRecordBase[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((record: TreeRecordBase) => any) | undefined;
+    onAction?: ((action: UiRecordInlineAction, record: TreeRecordBase) => any) | undefined;
+    onLoaded?: ((records: TreeRecordBase[]) => any) | undefined;
+}>, {
+    filterOption: (record: TreeRecordBase, normalizedKeyword: string) => boolean;
+    emptyDescription: string;
+    searchPlaceholder: string;
+    selectedId: string;
+    keyword: string;
+    titleOf: (record: TreeRecordBase) => string;
+    itemOf: (record: TreeRecordBase) => RecordExplorerItemDescriptor | undefined;
+    actionsOf: (record: TreeRecordBase) => UiRecordInlineAction[];
+    tagOf: (record: TreeRecordBase) => string | undefined;
+    mutedOf: (record: TreeRecordBase) => boolean;
+    reloadKey: number;
+    loadingTip: string;
+    fallbackTitle: string;
+    searchMode: TreeRecordSearchMode;
+    searchTrigger: "inline" | "external";
+    secondaryOf: (record: TreeRecordBase) => string | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,26 @@
+import type { UserSessionView } from '@muyun/web-contracts';
+type __VLS_Props = {
+    sessions: UserSessionView[];
+    loading?: boolean;
+    error?: string;
+    actionsDisabled?: boolean;
+    canRevoke?: (session: UserSessionView) => boolean;
+    canRevokeAll?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    refresh: () => any;
+    revoke: (session: UserSessionView) => any;
+    revokeAll: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRefresh?: (() => any) | undefined;
+    onRevoke?: ((session: UserSessionView) => any) | undefined;
+    onRevokeAll?: (() => any) | undefined;
+}>, {
+    loading: boolean;
+    error: string;
+    actionsDisabled: boolean;
+    canRevoke: (session: UserSessionView) => boolean;
+    canRevokeAll: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,3 @@
+import type { ResolvedModuleUiDescriptor } from '@muyun/web-contracts';
+export declare function actionConfirmationRequiredText(descriptor: ResolvedModuleUiDescriptor | undefined, actionCode: string, record: Record<string, unknown>): string | undefined;
+export declare function recordLabelOf(descriptor: ResolvedModuleUiDescriptor | undefined, record: Record<string, unknown>): string | undefined;

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

@@ -0,0 +1,10 @@
+export interface CrudRecordListBase {
+    id?: string;
+    title?: string;
+    alias?: string;
+    code?: string;
+    enabled?: boolean;
+}
+export declare function defaultCrudRecordListTitle<TRecord extends CrudRecordListBase>(record: TRecord, fallback?: string): string;
+export declare function defaultCrudRecordListSubtitle<TRecord extends CrudRecordListBase>(record: TRecord): string | undefined;
+export declare function defaultCrudRecordListMatches<TRecord extends CrudRecordListBase>(record: TRecord, normalizedKeyword: string, titleOf?: (record: TRecord) => string, subtitleOf?: (record: TRecord) => string | undefined): boolean;

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

@@ -0,0 +1,4 @@
+export interface DrawerPromotion {
+    title?: string;
+    promote(): void | Promise<void>;
+}

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

@@ -0,0 +1,76 @@
+export {};
+export { default as ApplicationScopeSwitcher } from './ApplicationScopeSwitcher.vue';
+export { default as CrudRecordListExplorer } from './CrudRecordListExplorer.vue';
+export { default as DrawerOperationBar } from './DrawerOperationBar.vue';
+export { default as DateTimeText } from './DateTimeText.vue';
+export { default as EnabledSelect } from './EnabledSelect.vue';
+export { default as ModuleActionButton } from './ModuleActionButton.vue';
+export { default as ManagementWorkspace } from './ManagementWorkspace.vue';
+export { default as ManagementExplorerColumn } from './ManagementExplorerColumn.vue';
+export { providePageLayout, usePageLayout } from './pageLayoutContext';
+export { default as RecordActionBar } from './RecordActionBar.vue';
+export { default as RecordDetailDrawer } from './RecordDetailDrawer.vue';
+export type { DrawerPromotion } from './drawerPromotion';
+export { default as RecordExternalChangeNotice } from './RecordExternalChangeNotice.vue';
+export { default as RecordDetailFields } from './RecordDetailFields.vue';
+export { default as RecordDetailPanel } from './RecordDetailPanel.vue';
+export { default as RecordExpandedSubtable } from './RecordExpandedSubtable.vue';
+export { default as UserSessionExpandedSubtable } from './UserSessionExpandedSubtable.vue';
+export { userSessionBrowserTitle, userSessionPresenceDescription, userSessionPresenceTitle, userSessionTerminalTitle, } from './userSessionPresentation';
+export { default as RecordExplorerPanel } from './RecordExplorerPanel.vue';
+export type { RecordExplorerItemDescriptor } from './recordExplorerItemModel';
+export { default as RecordFormFields } from './RecordFormFields.vue';
+export { default as RecordListExplorer } from './RecordListExplorer.vue';
+export { default as RecordMetaSection } from './RecordMetaSection.vue';
+export { default as RecordModeDrawer } from './RecordModeDrawer.vue';
+export { default as RecordPicker } from './RecordPicker.vue';
+export { default as RecordQueryListPanel } from './RecordQueryListPanel.vue';
+export { default as RecycleBinModeButton } from './RecycleBinModeButton.vue';
+export { useRecycleBinExplorerMode, type RecycleBinExplorerMode, type RecycleBinExplorerModeOptions, } from './useRecycleBinExplorerMode';
+export { default as RecordStatusSwitch } from './RecordStatusSwitch.vue';
+export { default as RecordTreeSelector } from './RecordTreeSelector.vue';
+export { default as RecordStatusTag } from './RecordStatusTag.vue';
+export { useRecycleBinState } from './recycleBinState';
+export type { RecycleBinStateOptions } from './recycleBinState';
+export { createSoftDeletedConflictErrorHandler, extractSoftDeletedConflict, useSoftDeletedConflictHandler, } from './softDeletedConflictHandler';
+export type { SoftDeletedConflictHandler, SoftDeletedConflictHandlerOptions, SoftDeletedConflictInfo, } from './softDeletedConflictHandler';
+export { default as StaticManagementLayout } from './StaticManagementLayout.vue';
+export { default as TreeRecordExplorer } from './TreeRecordExplorer.vue';
+export { enabledOnly, firstConstraintMessage, notDescendantOf, notRecordIds, parentRecordConstraints, } from './recordPickerConstraints';
+export { defaultTreeRecordMatches, defaultTreeRecordTitle, expandAllTreeRecords, filterTreeRecords, firstTwoTreeLevels, flattenTreeRecords, } from './treeRecordModel';
+export type { PickerConstraint, PickerConstraintContext, RecordPickerRecord, } from './recordPickerConstraints';
+export { resolveRecordPickerMode } from './recordPickerModel';
+export type { RecordPickerMode } from './recordPickerModel';
+export type { RecordActionItem, ResolvedRecordActionItem } from './recordActionBarModel';
+export type { RecordDetailDisplayResolver, RecordDetailDisplayValue } from './recordDetailFieldModel';
+export type { RecordListExplorerRecord } from './RecordListExplorer.vue';
+export type { QueryListRecord, RecordQueryListColumn, RecordQueryListMode } from './RecordQueryListPanel.vue';
+export type { RecordFormFieldDescriptor, RecordFormFieldFallback, RecordFormFieldPickerConfig, RecordFormFieldState, RecordFormFieldValue, RecordFormRecord, } from './recordFormFieldModel';
+export type { CrudRecordListBase } from './crudRecordListModel';
+export { defaultCrudRecordListMatches, defaultCrudRecordListSubtitle, defaultCrudRecordListTitle, } from './crudRecordListModel';
+export { resolveRecordActions } from './recordActionBarModel';
+export { normalizeRecordDraft } from './recordDraftNormalizer';
+export { resolveRecordDetailDisplayValue } from './recordDetailFieldModel';
+export { formatPlatformDateTime, resolveBrowserTimeZone } from './platformDateTime';
+export { providePlatformTimeZoneContext, usePlatformTimeZoneContext } from './platformTimeZoneContext';
+export type { PlatformDateTimeDisplay, PlatformDateTimeOptions, PlatformDateTimePrecision, } from './platformDateTime';
+export { childResourceDefaultFormViewCode, resolveRecordFormFieldNames, resolveRecordFormFieldState, resolveRecordFormFields, } from './recordFormFieldModel';
+export { createScopedTreeClient, createScopedTreeModuleContext } from './scopedTreeModuleContext';
+export { createEmptyStaticTreeClient, createStaticTreeResourceModuleContext, } from './staticTreeResourceModuleContext';
+export { createScopedResourceTreeModuleContext } from './scopedResourceTreeModuleContext';
+export { presentPlatformError, presentPlatformMessage, presentPlatformSuccess, } from './platformErrorFeedback';
+export { handlePlatformActionSuccess, presentPlatformActionSuccess } from './platformActionResultFeedback';
+export { createPlatformActionResultReactionHandlers, mergePlatformActionResultReactionHandlers, platformActionResultReactions, platformActionResultReactionTypes, resolvePlatformActionResult, resolvePlatformActionResultMessage, withPlatformActionResultReactions, } from './platformActionResultReactions';
+export type { PlatformActionResult, PlatformActionResultReaction, PlatformActionResultReactionHandler, PlatformActionResultReactionPayload, PlatformActionResultReactionType, PlatformActionResultStandardReactionHandlers, } from './platformActionResultReactions';
+export type { PlatformActionResultFeedbackContext, PlatformActionResultHandlingContext, } from './platformActionResultFeedback';
+export { executeStaticFormSave, executeStaticRecordAction } from './staticFormActionFlow';
+export { applyRecordExternalChange, createRecordEditorSessionState } from './recordEditorSessionState';
+export { useFlatCrudManagementState } from './staticCrudManagementState';
+export type { PlatformActionErrorHandler, PlatformErrorFeedbackContext } from './platformErrorFeedback';
+export type { StaticFormActionErrorContext, StaticFormActionErrorHandler, StaticFormSaveMode, StaticFormSaveOptions, StaticRecordActionOptions, } from './staticFormActionFlow';
+export type { RecordEditorSessionOptions, RecordExternalChangeOptions } from './recordEditorSessionState';
+export type { StaticCrudCardMode, StaticCrudConfirmAction, StaticCrudManagementOptions, StaticCrudRecord, } from './staticCrudManagementState';
+export type { TreeRecordBase } from './treeRecordModel';
+export type { ScopedTreeModuleContextOptions } from './scopedTreeModuleContext';
+export type { StaticTreeResourceModuleContextOptions } from './staticTreeResourceModuleContext';
+export type { ScopedResourceTreeModuleContextOptions } from './scopedResourceTreeModuleContext';

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

@@ -0,0 +1,10 @@
+import type { Option, OptionItemDescriptor } from '@muyun/web-contracts';
+export interface UiTreeSelectNode {
+    value: string;
+    title: string;
+    disabled?: boolean;
+    children?: UiTreeSelectNode[];
+}
+export declare function optionItemsToOptions(items: OptionItemDescriptor[]): Option[];
+export declare function hasOptionHierarchy(items: OptionItemDescriptor[]): boolean;
+export declare function optionItemsToTree(items: OptionItemDescriptor[]): UiTreeSelectNode[];

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

@@ -0,0 +1,6 @@
+import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
+import type { PageLayoutMode } from '@muyun/web-contracts';
+/** Provided by a page host; platform components consume the resolved page layout. */
+export declare function providePageLayout(layout: MaybeRefOrGetter<PageLayoutMode | undefined>): void;
+/** Ordinary pages stay flow-layout when mounted outside a workbench host. */
+export declare function usePageLayout(): ComputedRef<PageLayoutMode>;

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

@@ -0,0 +1,12 @@
+import { type PlatformErrorFeedbackContext } from './platformErrorFeedback';
+import { type PlatformActionResultReactionHandler } from './platformActionResultReactions';
+export { createPlatformActionResultReactionHandlers, mergePlatformActionResultReactionHandlers, platformActionResultReactions, platformActionResultReactionTypes, resolvePlatformActionResult, resolvePlatformActionResultMessage, withPlatformActionResultReactions, } from './platformActionResultReactions';
+export type { PlatformActionResult, PlatformActionResultReaction, PlatformActionResultReactionHandler, PlatformActionResultReactionPayload, PlatformActionResultReactionType, PlatformActionResultStandardReactionHandlers, } from './platformActionResultReactions';
+export interface PlatformActionResultFeedbackContext extends PlatformErrorFeedbackContext {
+    fallbackMessage?: string;
+}
+export interface PlatformActionResultHandlingContext extends PlatformActionResultFeedbackContext {
+    reactionHandlers?: Record<string, PlatformActionResultReactionHandler | undefined>;
+}
+export declare function handlePlatformActionSuccess(result: unknown, context?: PlatformActionResultHandlingContext): Promise<import("./platformActionResultReactions").PlatformActionResult>;
+export declare function presentPlatformActionSuccess(result: unknown, context?: PlatformActionResultFeedbackContext): void;

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

@@ -0,0 +1,53 @@
+import { resolveWebActionResultMessage, type ResolvedWebActionResult } from '@muyun/web-core';
+export declare const platformActionResultReactionTypes: {
+    readonly refreshList: "refresh-list";
+    readonly refreshDetail: "refresh-detail";
+    readonly closeEditor: "close-editor";
+    readonly clearSelection: "clear-selection";
+    readonly selectRecord: "select-record";
+};
+export type PlatformActionResultReactionType = (typeof platformActionResultReactionTypes)[keyof typeof platformActionResultReactionTypes];
+export interface PlatformActionResultReactionPayload {
+    moduleAlias?: string;
+    resourceKey?: string;
+    scope?: string;
+    recordId?: string;
+    [key: string]: unknown;
+}
+export interface PlatformActionResultReaction {
+    type: string;
+    payload?: PlatformActionResultReactionPayload;
+}
+export declare const platformActionResultReactions: {
+    refreshList(payload?: PlatformActionResultReactionPayload): PlatformActionResultReaction;
+    refreshDetail(payload?: PlatformActionResultReactionPayload): PlatformActionResultReaction;
+    closeEditor(payload?: PlatformActionResultReactionPayload): PlatformActionResultReaction;
+    clearSelection(payload?: PlatformActionResultReactionPayload): PlatformActionResultReaction;
+    selectRecord(payload?: PlatformActionResultReactionPayload): PlatformActionResultReaction;
+};
+export declare const resolvePlatformActionResultMessage: typeof resolveWebActionResultMessage;
+export interface PlatformActionResult extends ResolvedWebActionResult {
+    reactions: PlatformActionResultReaction[];
+}
+export type PlatformActionResultReactionHandler = (reaction: PlatformActionResultReaction, result: PlatformActionResult) => void | Promise<void>;
+export interface PlatformActionResultStandardReactionHandlers {
+    refreshList?: PlatformActionResultReactionHandler;
+    refreshDetail?: PlatformActionResultReactionHandler;
+    closeEditor?: PlatformActionResultReactionHandler;
+    clearSelection?: PlatformActionResultReactionHandler;
+    selectRecord?: PlatformActionResultReactionHandler;
+}
+export declare function createPlatformActionResultReactionHandlers(handlers: PlatformActionResultStandardReactionHandlers): {
+    "refresh-list": PlatformActionResultReactionHandler | undefined;
+    "refresh-detail": PlatformActionResultReactionHandler | undefined;
+    "close-editor": PlatformActionResultReactionHandler | undefined;
+    "clear-selection": PlatformActionResultReactionHandler | undefined;
+    "select-record": PlatformActionResultReactionHandler | undefined;
+};
+export declare function mergePlatformActionResultReactionHandlers(defaultHandlers: Record<string, PlatformActionResultReactionHandler | undefined>, customHandlers: Record<string, PlatformActionResultReactionHandler | undefined> | undefined): Record<string, PlatformActionResultReactionHandler | undefined>;
+export declare function withPlatformActionResultReactions<T>(result: T, reactions: PlatformActionResultReaction[]): T & {
+    reactions: PlatformActionResultReaction[];
+};
+export declare function resolvePlatformActionResult(result: unknown, options?: {
+    fallbackMessage?: string;
+}): PlatformActionResult;

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

@@ -0,0 +1,16 @@
+export type PlatformDateTimePrecision = 'minute' | 'second';
+export interface PlatformDateTimeOptions {
+    emptyText?: string;
+    locale?: string;
+    precision?: PlatformDateTimePrecision;
+    timeZone?: string;
+}
+export interface PlatformDateTimeDisplay {
+    text: string;
+    title: string;
+    datetime?: string;
+    timeZone?: string;
+    valid: boolean;
+}
+export declare function resolveBrowserTimeZone(): string;
+export declare function formatPlatformDateTime(value: string | number | Date | null | undefined, options?: PlatformDateTimeOptions): PlatformDateTimeDisplay;

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

@@ -0,0 +1,15 @@
+import { type AppError } from '@muyun/web-core';
+export interface PlatformErrorFeedbackContext {
+    source?: string;
+    phase?: 'load' | 'action' | 'validation' | 'authorization';
+    tone?: 'error' | 'success';
+}
+export declare function presentPlatformError(cause: unknown, context?: PlatformErrorFeedbackContext): AppError;
+export declare function presentPlatformMessage(message: string, context?: PlatformErrorFeedbackContext): void;
+export declare function presentPlatformSuccess(message: string, context?: PlatformErrorFeedbackContext): void;
+export type PlatformActionErrorHandler<TContext> = {
+    code?: string;
+    marker?: string;
+    handle: (error: AppError, context: TContext) => void | boolean;
+};
+export declare function matchesPlatformActionErrorHandler<TContext>(error: AppError, handler: PlatformActionErrorHandler<TContext>): boolean;

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

@@ -0,0 +1,3 @@
+import { type Ref } from 'vue';
+export declare function providePlatformTimeZoneContext(timeZone: Readonly<Ref<string | undefined>>): void;
+export declare function usePlatformTimeZoneContext(): Readonly<Ref<string | undefined, string | undefined>> | undefined;

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

@@ -0,0 +1,27 @@
+import type { ModuleContext } from '@muyun/web-core';
+import type { UiIconName } from '@muyun/vue-ui-antdv';
+export interface RecordActionItem {
+    key?: string;
+    actionCode?: string;
+    title: string;
+    before?: string;
+    after?: string;
+    visible?: boolean;
+    /** Keep the row action visible beside the default row action instead of placing it in “more”. */
+    pinned?: boolean;
+    disabled?: boolean;
+    loading?: boolean;
+    primary?: boolean;
+    danger?: boolean;
+    iconName?: UiIconName;
+}
+export interface ResolvedRecordActionItem extends RecordActionItem {
+    key: string;
+    actionCode?: string;
+    authorized: boolean;
+    reason?: string;
+    disabled: boolean;
+    loading: boolean;
+}
+export declare function resolveRecordActions(context: Pick<ModuleContext<unknown>, 'action'>, actions: RecordActionItem[], defaultLoading?: boolean, recordId?: string): ResolvedRecordActionItem[];
+export declare function mergeRecordActions(baseActions: RecordActionItem[], extraActions: RecordActionItem[]): RecordActionItem[];

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

@@ -0,0 +1,7 @@
+import type { RecordFormFieldState, RecordFormRecord } from './recordFormFieldModel';
+export type RecordDetailDisplayValue = string | number | boolean | undefined | null;
+export type RecordDetailDisplayResolver = (fieldName: string, value: unknown, record: RecordFormRecord, field: RecordFormFieldState) => RecordDetailDisplayValue;
+export declare function resolveRecordDetailDisplayValue(field: RecordFormFieldState, record: RecordFormRecord, options?: {
+    displayOf?: RecordDetailDisplayResolver;
+    emptyText?: string;
+}): string;

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

@@ -0,0 +1 @@
+export declare function normalizeRecordDraft<TRecord extends object>(draft: Partial<TRecord>, normalizedFields: Partial<TRecord>): TRecord;

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

@@ -0,0 +1,38 @@
+import { type WebDataChange } from '@muyun/web-contracts';
+export interface RecordEditorSessionOptions<TRecord, TMode extends string> {
+    viewMode: TMode;
+    createMode: TMode;
+    editMode: TMode;
+    emptyDraft: () => TRecord;
+    copyRecord?: (record: TRecord) => TRecord;
+    recordIdOf?: (record: TRecord) => string | undefined;
+}
+export interface RecordEditorSessionCreateOptions<TRecord, TMode extends string> {
+    mode?: TMode;
+    draft?: TRecord | (() => TRecord);
+    selectedRecord?: TRecord;
+    preserveSelection?: boolean;
+}
+export interface RecordExternalChangeOptions {
+    moduleAlias: string;
+    changeTypes?: string[];
+}
+export declare function createRecordEditorSessionState<TRecord, TMode extends string>(options: RecordEditorSessionOptions<TRecord, TMode>): {
+    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: [TMode] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TMode, import("vue").Ref<TMode, TMode>, TMode> : import("vue").Ref<import("vue").UnwrapRef<TMode>, TMode | import("vue").UnwrapRef<TMode>>;
+    readonly: import("vue").ComputedRef<boolean>;
+    externallyChanged: import("vue").ComputedRef<boolean>;
+    externalChangedRecordId: import("vue").Ref<string | undefined, string | undefined>;
+    select: (record: TRecord) => void;
+    replaceSelected: (record: TRecord | undefined) => void;
+    clearSelection: () => void;
+    startCreate: (createOptions?: RecordEditorSessionCreateOptions<TRecord, TMode>) => void;
+    startEdit: () => boolean;
+    cancel: () => void;
+    markExternalRecordChanged: (recordId: string | undefined) => boolean;
+    clearExternalChanged: () => void;
+};
+export declare function applyRecordExternalChange(session: {
+    markExternalRecordChanged(recordId: string | undefined): boolean;
+}, change: WebDataChange, options: RecordExternalChangeOptions): boolean;

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

@@ -0,0 +1,8 @@
+import type { UiRecordInlineAction } from '@muyun/vue-ui-antdv';
+export interface RecordExplorerItemDescriptor {
+    title: string;
+    secondary?: string;
+    tag?: string;
+    muted?: boolean;
+    actions?: UiRecordInlineAction[];
+}

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

@@ -0,0 +1,57 @@
+import type { Option, OptionValueList, ResolvedOptionFieldDescriptor, ResolvedModuleUiDescriptor, ResolvedViewFieldDescriptor, ViewFieldDefinition } from '@muyun/web-contracts';
+import type { ModuleContext } from '@muyun/web-core';
+import type { PickerConstraint, RecordPickerRecord } from './recordPickerConstraints';
+export type RecordFormFieldDescriptor = (ViewFieldDefinition | ResolvedViewFieldDescriptor) & {
+    option?: ResolvedOptionFieldDescriptor;
+};
+export type RecordFormRecord = Record<string, unknown>;
+export type RecordFormFieldValue = string | number | boolean | OptionValueList | undefined;
+export type RecordFormFieldControlType = 'input' | 'select' | 'enabledStatus' | 'recordPicker';
+export interface RecordFormFieldFallback {
+    label: string;
+    required?: boolean;
+    readOnly?: boolean;
+    visible?: boolean;
+    controlType?: RecordFormFieldControlType;
+    placeholder?: string;
+    options?: Option[];
+    optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
+}
+export interface RecordFormFieldPickerConfig {
+    context: ModuleContext<RecordPickerRecord>;
+    reloadKey?: number;
+    mode?: 'list' | 'tree';
+    placeholder?: string;
+    allowClear?: boolean;
+    constraints?: PickerConstraint<RecordPickerRecord>[];
+    titleOf?: (record: RecordPickerRecord) => string;
+    descriptionOf?: (record: RecordPickerRecord) => string | undefined;
+    filterOption?: (record: RecordPickerRecord, keyword: string) => boolean;
+}
+export interface RecordFormFieldState {
+    fieldName: string;
+    label: string;
+    required: boolean;
+    readOnly: boolean;
+    visible: boolean;
+    controlType: RecordFormFieldControlType;
+    hasOption: boolean;
+    optionSelectionMode?: 'SINGLE' | 'MULTIPLE';
+    optionTitleField?: string;
+    pickerConfig?: RecordFormFieldPickerConfig;
+    placeholder?: string;
+    options?: Option[];
+}
+export interface ResolveRecordFormFieldNamesOptions {
+    explicitOrder?: string[];
+    exclude?: Iterable<string>;
+}
+export declare function resolveRecordFormFieldNames(fields?: Map<string, RecordFormFieldDescriptor>, fallback?: Record<string, RecordFormFieldFallback>, options?: ResolveRecordFormFieldNamesOptions): string[];
+export declare function resolveRecordFormFields(uiDescriptor: ResolvedModuleUiDescriptor | undefined, viewCode?: string): Map<string, RecordFormFieldDescriptor>;
+export declare function childResourceDefaultFormViewCode(resource: string): string;
+export declare function resolveRecordFormFieldState(fieldName: string, options?: {
+    fields?: Map<string, RecordFormFieldDescriptor>;
+    fallback?: Record<string, RecordFormFieldFallback>;
+    pickerConfigs?: Record<string, RecordFormFieldPickerConfig>;
+    placeholderOf?: (fieldName: string, field: RecordFormFieldState) => string | undefined;
+}): RecordFormFieldState;

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

@@ -0,0 +1,20 @@
+export interface RecordPickerRecord {
+    id?: string;
+    parentId?: string;
+    title?: string;
+    code?: string;
+    enabled?: boolean;
+}
+export interface PickerConstraintContext<TRecord extends RecordPickerRecord> {
+    records: TRecord[];
+}
+export interface PickerConstraint<TRecord extends RecordPickerRecord> {
+    code: string;
+    message: string;
+    test(record: TRecord, context: PickerConstraintContext<TRecord>): boolean;
+}
+export declare function notRecordIds<TRecord extends RecordPickerRecord>(ids: Array<string | undefined>, message?: string): PickerConstraint<TRecord>;
+export declare function notDescendantOf<TRecord extends RecordPickerRecord>(ancestorId?: string, message?: string): PickerConstraint<TRecord>;
+export declare function enabledOnly<TRecord extends RecordPickerRecord>(message?: string): PickerConstraint<TRecord>;
+export declare function parentRecordConstraints<TRecord extends RecordPickerRecord>(currentId?: string): PickerConstraint<TRecord>[];
+export declare function firstConstraintMessage<TRecord extends RecordPickerRecord>(record: TRecord, context: PickerConstraintContext<TRecord>, constraints: PickerConstraint<TRecord>[]): string | undefined;

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

@@ -0,0 +1,2 @@
+export type RecordPickerMode = 'list' | 'tree';
+export declare function resolveRecordPickerMode(mode: RecordPickerMode, treeAvailable: boolean): RecordPickerMode;