@ximatai/muyun-web-app 0.26.16 → 0.26.17

package/dist/types/web-contracts/workflow.d.ts

@@ -108,7 +108,15 @@ export interface WorkflowTask {
     decision?: string;
     completedAt?: string;
 }
+export interface WorkflowRecordInstance {
+    id: string;
+    versionNo?: number;
+    instanceStatus: string;
+    approvalEnabled: boolean;
+    startedAt?: string;
+}
 export interface WorkflowEvent {
+    version?: number | null;
     messageText?: TextPresentation;
     id: string;
     taskId?: string;
@@ -184,12 +192,14 @@ export interface WorkflowWorkbenchCard {
         readable: boolean;
         moduleTitleSource?: import('./index').TextReference;
         moduleTitleText?: import('./index').TextPresentation;
+        titleContentText?: import('./index').BusinessContentTextPresentation;
     };
     instanceId: string;
     moduleAlias: string;
     recordId: string;
     taskId?: string;
     nodeTitle?: string;
+    taskKind?: string;
     taskStatus?: string;
     approvalStatus?: string;
     instanceStatus: string;

package/dist/types/web-core/assistantTurnClient.d.ts

@@ -12,5 +12,7 @@ export interface AssistantModelRequestObservation {
     toolCallCount?: number;
 }
 export type AssistantTurnRequester = (input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress) => Promise<AssistantTurnOutput>;
+/** Reads only the current backend identity's configuration decision, without exposing route details. */
+export declare function readAssistantAvailability(http: HttpClient, signal?: AbortSignal): Promise<boolean>;
 /** Uses the supplied transport as-is so page-owned tenant scope remains authoritative. */
 export declare function createAssistantTurnRequester(http: HttpClient): AssistantTurnRequester;

package/dist/types/web-core/businessContent.d.ts

@@ -0,0 +1,38 @@
+import type { HttpClient } from './http';
+import type { BusinessContentGenerationSource, BusinessContentGenerationBatchCommand, BusinessContentGenerationBatchResult } from '../web-contracts/index';
+import type { BusinessContentSources, BusinessContentRevision } from '../web-contracts/index';
+import type { BusinessContentReading, BusinessContentGenerationStatus, BusinessContentTranslationMaintenance, BusinessContentTranslationChange, BusinessContentTranslationRevision } from '../web-contracts/index';
+export type BusinessContentRelationScope = {
+    kind?: 'aggregate';
+    parentId: string;
+    relationCode: string;
+    workflowInstanceId?: never;
+    history?: never;
+} | {
+    kind: 'workflowEvent';
+    workflowInstanceId: string;
+    history?: boolean;
+    parentId?: never;
+    relationCode?: never;
+};
+export declare function businessContentGenerationBatch(http: HttpClient, source: BusinessContentGenerationSource, command: BusinessContentGenerationBatchCommand, operation: 'status' | 'request', signal?: AbortSignal): Promise<BusinessContentGenerationBatchResult>;
+/** The source belongs to the actual row, including an owned aggregate child. */
+export declare function businessContentPath(moduleAlias: string, id: string, relation?: BusinessContentRelationScope): string;
+export declare function loadBusinessContentSources(http: HttpClient, moduleAlias: string, id: string, relation?: BusinessContentRelationScope, snapshot?: object, sessionKey?: string | number): Promise<BusinessContentSources>;
+export declare function loadBusinessContentHistory(http: HttpClient, moduleAlias: string, id: string, field: string, page: number, relation?: BusinessContentRelationScope): Promise<BusinessContentRevision[]>;
+export declare function loadBusinessContentReading(http: HttpClient, moduleAlias: string, id: string, language: string, relation?: BusinessContentRelationScope, snapshot?: object, sessionKey?: string | number, refreshRevision?: number): Promise<BusinessContentReading>;
+export declare function prepareBusinessContentTranslation(http: HttpClient, moduleAlias: string, id: string, field: string, language: string, access: 'edit' | 'confirm', relation?: BusinessContentRelationScope): Promise<BusinessContentTranslationMaintenance>;
+export declare function changeBusinessContentTranslation(http: HttpClient, moduleAlias: string, id: string, field: string, language: string, operation: 'draft' | 'confirm' | 'remove', change: BusinessContentTranslationChange, relation?: BusinessContentRelationScope, snapshot?: object): Promise<BusinessContentTranslationMaintenance>;
+export declare function loadBusinessContentTranslationHistory(http: HttpClient, moduleAlias: string, id: string, field: string, language: string, access: 'edit' | 'confirm', source: {
+    revisionId: string;
+    revision: number;
+}, page: number, relation?: BusinessContentRelationScope): Promise<BusinessContentTranslationRevision[]>;
+export interface BusinessContentGenerationOptions {
+    relation?: BusinessContentRelationScope;
+    snapshot?: object;
+    signal?: AbortSignal;
+}
+/** Read-only status. No enqueue, retry or model invocation. */
+export declare function loadBusinessContentGeneration(http: HttpClient, moduleAlias: string, id: string, field: string, language: string, options?: BusinessContentGenerationOptions): Promise<BusinessContentGenerationStatus>;
+/** Explicit reading generation or manual-field drafting; source, identity and route are resolved by the server. */
+export declare function requestBusinessContentGeneration(http: HttpClient, moduleAlias: string, id: string, field: string, language: string, retry?: boolean, options?: BusinessContentGenerationOptions): Promise<BusinessContentGenerationStatus>;

package/dist/types/web-core/businessContentLanguage.d.ts

@@ -0,0 +1,18 @@
+import type { LanguageContext } from './language';
+export declare const businessContentLanguages: readonly [{
+    readonly value: "zh-CN";
+    readonly label: "简体中文";
+}, {
+    readonly value: "en";
+    readonly label: "English";
+}, {
+    readonly value: "de";
+    readonly label: "Deutsch";
+}];
+export type BusinessContentLanguageContext = Pick<LanguageContext, 'languageTag' | 'requestedLanguageTag' | 'selectionRevision' | 'setLanguage'>;
+/** Reading intent belongs to this interface scope; it never changes the interface or original language. */
+export declare function businessContentLanguageContext(language: LanguageContext): BusinessContentLanguageContext;
+/** A bounded reading snapshot lets language changes preserve local picker and form drafts. */
+export declare function businessContentReadHeaders(options?: {
+    contentLanguage?: string;
+}): Record<string, string>;

package/dist/types/web-core/index.d.ts

@@ -28,3 +28,8 @@ export type { WorkspaceUnsavedStateRegistrar } from './workspaceUnsavedState';
 export * from './language';
 export * from './languagePreference';
 export * from './presentationTexts';
+export * from './businessContent';
+export * from './useBusinessContentGenerationBatch';
+export * from './useBusinessContentReading';
+export * from './businessContentLanguage';
+export * from './recordReadRefreshGuard';

package/dist/types/web-core/languagePreference.d.ts

@@ -1,8 +1,8 @@
 import type { LanguageContext } from './language';
 import { type UserPreferenceStore } from './userPreferences';
 /** Scope changes and user selection invalidate delayed restores; queued writes never cross accounts. */
-export declare function createLanguagePreferenceController(context: LanguageContext, store?: UserPreferenceStore): {
+export declare function createLanguagePreferenceController(context: Pick<LanguageContext, 'setLanguage' | 'languageTag' | 'requestedLanguageTag' | 'selectionRevision'>, store?: UserPreferenceStore, preferenceKey?: string): {
     restore(identity?: string): Promise<void>;
-    save(tag: string): Promise<void>;
+    save(tag?: string): Promise<void>;
     dispose(): void;
 };

package/dist/types/web-core/module/dataExchangeClient.d.ts

@@ -1,5 +1,83 @@
 import type { HttpClient } from '../http';
 import type { TextPresentation, WebQueryRequest } from '../../web-contracts/index';
+import type { RecordQueryRequestOptions } from './staticModuleClient';
+export type ExchangePurpose = 'DATA' | 'TRANSLATIONS' | 'READING';
+export interface ExchangeOptions {
+    purpose: ExchangePurpose;
+    language: string;
+    timeZone?: string;
+}
+export interface ExchangeCommand {
+    documentId?: string;
+    previewDigest?: string;
+    sourceLanguage?: string;
+    resolutionLanguage?: string;
+    sheets: Array<{
+        entityAlias: string;
+        matchField: string;
+        duplicateStrategy: ImportDuplicateStrategy;
+    }>;
+    confirmations: Array<{
+        row: string;
+        field: string;
+        input: string;
+        candidateId: string;
+    }>;
+}
+export interface ExchangeRow {
+    row: string;
+    entity: string;
+    relation: string;
+    operation: string;
+    recordId?: string;
+    currentValues: Record<string, unknown>;
+    changes: Record<string, unknown>;
+    languages: Record<string, {
+        languageTag?: string;
+        expectedRevision?: number;
+    }>;
+    choices: Array<{
+        field: string;
+        input: string;
+        candidates: Array<{
+            id: string;
+            title: string;
+            matchedText: string;
+            kind: string;
+            subtitle?: string | null;
+        }>;
+    }>;
+    problem?: string;
+    references?: Record<string, {
+        current?: string | null;
+        submitted?: string | null;
+    }>;
+}
+export interface ExchangePreview {
+    documentId: string;
+    previewDigest: string;
+    purpose: ExchangePurpose;
+    language?: string;
+    sheets: Array<{
+        entityAlias: string;
+        sheetName: string;
+        main: boolean;
+        rowCount: number;
+        matchFields: string[];
+        fieldTitles: Record<string, string>;
+        recommendedMatchField?: string | null;
+    }>;
+    rows: ExchangeRow[];
+}
+export interface ExchangeResult {
+    created: number;
+    updated: number;
+    skipped: number;
+    errorCount: number;
+    partialSuccess: boolean;
+    errorWorkbookBase64?: string;
+    rows: ExchangeRow[];
+}
 export type ImportDuplicateStrategy = 'ERROR' | 'SKIP' | 'OVERWRITE';
 export interface ImportSheet {
     sheetName: string;
@@ -44,8 +122,12 @@ export interface ImportExecutionResult {
     errorFileName?: string;
     errorFileToken?: string;
 }
-/** Dynamic EXCHANGE transport; domain execution remains behind the module's standard action scope. */
+/** Source-neutral file transport. The legacy v1 methods remain available while consumers migrate. */
 export declare function createDataExchangeClient(http: HttpClient, moduleAlias: string): {
+    fileTemplate: (options: ExchangeOptions) => Promise<Blob>;
+    preview(file: File, command?: ExchangeCommand): Promise<ExchangePreview>;
+    importFile(file: File, command: ExchangeCommand): Promise<ExchangeResult>;
+    exportFile(query: WebQueryRequest | undefined, options: ExchangeOptions, ids?: string[], queryOptions?: RecordQueryRequestOptions): Promise<Blob>;
     template: () => Promise<Blob>;
     parse(file: File): Promise<ImportParseResult>;
     execute(file: File, command: ImportExecutionCommand): Promise<ImportExecutionResult>;

package/dist/types/web-core/module/staticModuleClient.d.ts

@@ -11,6 +11,10 @@ export interface QuerySchemaRequestOptions {
     uiConfigId?: string;
     queryTemplateId?: string;
 }
+/** Display intent only, independent of original-content and interface languages. */
+export interface RecordQueryRequestOptions {
+    contentLanguage?: string;
+}
 export interface RecordSaveRequestOptions {
     requestId: string;
 }
@@ -23,7 +27,7 @@ export interface RecordSaveReceipt {
 /** Source-neutral client for a platform module's standard CRUD contract. */
 export interface ModuleCrudClient<TRecord> {
     querySchema(options?: QuerySchemaRequestOptions): Promise<QuerySchema>;
-    query(request?: WebQueryRequest): Promise<WebPageResponse<TRecord>>;
+    query(request?: WebQueryRequest, options?: RecordQueryRequestOptions): Promise<WebPageResponse<TRecord>>;
     view(id: string): Promise<TRecord>;
     insert(record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
     update(id: string, record: TRecord, options?: RecordSaveRequestOptions): Promise<StaticRecordMutationResult<TRecord>>;
@@ -61,7 +65,7 @@ export interface ModuleEnableClient {
  * server-issued relation code are the only routing facts a surface receives.
  */
 export interface ManagedDetailRelationClient<TRecord> {
-    query(request?: WebQueryRequest): Promise<WebPageResponse<TRecord>>;
+    query(request?: WebQueryRequest, options?: RecordQueryRequestOptions): Promise<WebPageResponse<TRecord>>;
     insert(record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
     update(id: string, record: TRecord): Promise<StaticRecordMutationResult<TRecord>>;
     delete(id: string, request: RecordActionRequest): Promise<StaticCountMutationResult>;
@@ -79,7 +83,7 @@ export interface NavigatorReferenceCrudClient<TRecord> extends ModuleCrudClient<
     translate(ids: readonly string[]): Promise<WebPageResponse<TRecord>>;
 }
 /** The navigation-only read surface deliberately does not reuse the module query endpoint. */
-export declare function createNavigatorReferenceCrudClient<TRecord>(http: HttpClient, options: {
+export declare function createNavigatorReferenceCrudClient<TRecord>(http: HttpClient, navigatorOptions: {
     moduleAlias: string;
     navigatorReference?: NavigatorReferenceRequestContext;
 }): NavigatorReferenceCrudClient<TRecord>;
@@ -120,3 +124,5 @@ export declare function normalizeModuleRecord<TRecord>(record: TRecord): TRecord
  * public lets those descriptor-driven surfaces reuse the one normalization rule.</p>
  */
 export declare function normalizeModulePageResponse<TRecord>(response: WebPageResponse<TRecord>): WebPageResponse<TRecord>;
+export declare function normalizeModuleListResponse<TRecord>(response: WebListResponse<TRecord>): WebListResponse<TRecord>;
+export declare function normalizeModuleTreeResponse<TRecord>(response: WebListResponse<WebTreeNode<TRecord>>): WebListResponse<WebTreeNode<TRecord>>;

package/dist/types/web-core/presentationTexts.d.ts

@@ -1,3 +1,4 @@
+import type { BusinessContentTextPresentation } from '../web-contracts/index';
 import type { TextReference, TextPresentation, TextPresentationDocument } from '../web-contracts/index';
 import type { LanguageContext, TextResolution } from './language';
 /** Snapshot a producer's concrete CODE original; arguments format deployed resources, never business values in the fallback. */
@@ -14,3 +15,7 @@ export declare function recordPresentationText(record: object | undefined, field
 export declare function recordPresentationLabel(record: object, field: string, context: LanguageContext): string | undefined;
 /** Removes only the record's read metadata; arbitrary nested JSON business values are preserved. */
 export declare function withoutRecordPresentation<T>(record: T): T;
+/** An edited original immediately invalidates its disposable reading snapshot. */
+export declare function businessContentLabel(original: string, text: BusinessContentTextPresentation | undefined, context: LanguageContext): string | undefined;
+export declare function recordBusinessContentText(record: object | undefined, field: string): BusinessContentTextPresentation | undefined;
+export declare function recordBusinessContentArray(record: Record<string, unknown>, field: string, context: LanguageContext): unknown;

package/dist/types/web-core/recordReadRefreshGuard.d.ts

@@ -0,0 +1,7 @@
+/** Nested record hosts share a guard so a read refresh cannot destroy an open maintenance session. */
+export declare function provideRecordReadRefreshGuard(): {
+    blocked: import("vue").ComputedRef<boolean>;
+    invalidate: () => void;
+};
+export declare function useRecordReadRefreshRevision(): import("vue").ComputedRef<number>;
+export declare function useRecordReadRefreshGuard(held: () => boolean): void;

package/dist/types/web-core/useBusinessContentGenerationBatch.d.ts

@@ -0,0 +1,36 @@
+import type { BusinessContentGenerationBatchResult, BusinessContentGenerationSource } from '../web-contracts/index';
+import type { HttpClient } from './http';
+interface Selection {
+    active: boolean;
+    http?: HttpClient;
+    source?: BusinessContentGenerationSource | null;
+    records: readonly {
+        id: string;
+        version?: unknown;
+    }[];
+    language: string;
+    includeChildren: boolean;
+    sessionKey?: unknown;
+}
+/** A topic-specific selection session: previews never enqueue; polling never retries generation. */
+export declare function useBusinessContentGenerationBatch(options: () => Selection): {
+    result: import("vue").Ref<BusinessContentGenerationBatchResult | undefined, BusinessContentGenerationBatchResult | undefined>;
+    items: import("vue").ComputedRef<{
+        recordId: string;
+        ownerId: string;
+        relationCode: string | null;
+        childId: string | null;
+        field: string | null;
+        status: import("../web-contracts/index").BusinessContentGenerationStatus;
+    }[]>;
+    loading: import("vue").Ref<boolean, boolean>;
+    failed: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<unknown, unknown>;
+    pollingPaused: import("vue").Ref<boolean, boolean>;
+    pending: import("vue").ComputedRef<boolean>;
+    canGenerate: import("vue").ComputedRef<boolean>;
+    canRetry: import("vue").ComputedRef<boolean>;
+    preview: () => Promise<void>;
+    request: (retry?: boolean) => Promise<void>;
+};
+export {};

package/dist/types/web-core/useBusinessContentReading.d.ts

@@ -0,0 +1,30 @@
+import type { BusinessContentField, BusinessContentGenerationStatus, BusinessContentReadingField } from '../web-contracts/index';
+import type { HttpClient } from './http';
+import { type BusinessContentRelationScope } from './businessContent';
+interface ReadingOptions {
+    active?: boolean;
+    http?: HttpClient;
+    moduleAlias?: string;
+    record: Record<string, unknown>;
+    fieldName: string;
+    content: BusinessContentField;
+    language: string;
+    mode: 'create' | 'edit' | 'view';
+    relation?: BusinessContentRelationScope;
+    sessionKey?: string | number;
+}
+/** Shared saved-record reading. Translation work never mutates the caller's business draft. */
+export declare function useBusinessContentReading(options: () => ReadingOptions): {
+    reading: import("vue").Ref<BusinessContentReadingField | undefined, BusinessContentReadingField | undefined>;
+    loading: import("vue").Ref<boolean, boolean>;
+    failed: import("vue").Ref<boolean, boolean>;
+    matches: import("vue").ComputedRef<boolean>;
+    status: import("vue").Ref<BusinessContentGenerationStatus | undefined, BusinessContentGenerationStatus | undefined>;
+    generationBusy: import("vue").Ref<boolean, boolean>;
+    generationFailed: import("vue").Ref<boolean, boolean>;
+    pollingPaused: import("vue").Ref<boolean, boolean>;
+    canRetry: import("vue").ComputedRef<boolean>;
+    load: () => Promise<void>;
+    retry: () => Promise<void>;
+};
+export {};

package/dist/types/web-core/workflow.d.ts

@@ -1,10 +1,11 @@
-import type { WorkflowDefinition, WorkflowVersion, WorkflowTaskPreparation, WorkflowConfigurationCatalog, WorkflowDefinitionSelection, WorkflowDefinitionCreate, WorkflowAdminInstance, WorkflowAdminTask, WorkflowAdminInstanceQuery, WorkflowAdminHistoryQuery, WorkflowAction, WorkflowAddSignExplanation, WorkflowBranch, WorkflowDesign, WorkflowEvent, WorkflowHistoryInstance, WorkflowRenderBundle, WorkflowStatus, WorkflowTask, WorkflowWorkbenchCard, WorkflowWorkbenchFilters, WebPageResponse } from '../web-contracts/index';
+import type { WorkflowDefinition, WorkflowVersion, WorkflowTaskPreparation, WorkflowConfigurationCatalog, WorkflowDefinitionSelection, WorkflowDefinitionCreate, WorkflowAdminInstance, WorkflowAdminTask, WorkflowAdminInstanceQuery, WorkflowAdminHistoryQuery, WorkflowAction, WorkflowAddSignExplanation, WorkflowBranch, WorkflowDesign, WorkflowEvent, WorkflowHistoryInstance, WorkflowRenderBundle, WorkflowStatus, WorkflowTask, WorkflowRecordInstance, WorkflowWorkbenchCard, WorkflowWorkbenchFilters, WebPageResponse } from '../web-contracts/index';
 import type { HttpClient } from './http';
 import type { ModuleContext } from './module/moduleContext';
 /** Workflow mutations change ordinary record rights as well as the record itself. */
 export declare function refreshWorkflowRecordActions(context: Pick<ModuleContext<unknown>, 'invalidateRecordActions' | 'recordActions'>, recordId: string): Promise<void>;
 /** All operation rights remain server decisions. The client only carries typed intent. */
 export declare function createWorkflowClient(http: HttpClient): {
+    recordInstances: (moduleAlias: string, recordId: string, page?: number, size?: number) => Promise<WebPageResponse<WorkflowRecordInstance>>;
     history: (moduleAlias: string, recordId: string) => Promise<WorkflowHistoryInstance[]>;
     historyBundle: (id: string) => Promise<WorkflowRenderBundle>;
     historyTasks: (id: string) => Promise<WorkflowTask[]>;