@ximatai/muyun-web-app 0.26.15 → 0.26.17

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

@@ -1,5 +1,83 @@
 import type { HttpClient } from '../http';
-import type { WebQueryRequest } from '../../web-contracts/index';
+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;
@@ -40,11 +118,16 @@ export interface ImportExecutionResult {
     }>;
     partialSuccess: boolean;
     message: string;
+    messageText?: TextPresentation;
     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/index.d.ts

@@ -6,3 +6,4 @@ export type { ModuleAbilityClients, ModuleAbilities } from './abilities';
 export * from './moduleContext';
 export * from './pageActionEntries';
 export * from './dataExchangeClient';
+export { displayModuleRuntime } from './runtimeContext';

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

@@ -3,6 +3,7 @@ import type { HttpClient } from '../http';
 import { type ModuleAbilities } from './abilities';
 import { type ModuleActionState, type ModuleRecordActionAvailability, type ModuleRuntimeAction, type ModuleRuntimeContextState } from './runtimeContext';
 import { type NavigatorReferenceRequestContext, type ModuleCrudClient, type ModuleTreeClient } from './staticModuleClient';
+import { type LanguageContext } from '../language';
 export interface ModuleContext<TRecord> {
     moduleAlias: string;
     http: HttpClient;
@@ -21,6 +22,7 @@ export interface ModuleTreeContext<TRecord> extends ModuleContext<TRecord> {
     tree: ModuleTreeClient<TRecord>;
 }
 export interface ModuleContextConfig {
+    language?: LanguageContext;
     http?: HttpClient;
     httpFactory?: () => HttpClient;
 }
@@ -31,6 +33,8 @@ export interface ModuleContextOptions extends ModuleContextConfig {
 }
 export declare function configureModuleContext(config: ModuleContextConfig): void;
 export declare function provideModuleContextConfig(config: ModuleContextConfig): void;
+/** Auxiliary module APIs share the owner's transport without loading another module runtime. */
+export declare function useModuleHttpClient(): HttpClient;
 export declare function createModuleContext<TRecord>(options: ModuleContextOptions): ModuleContext<TRecord>;
 export declare function createModuleTreeContext<TRecord>(options: ModuleContextOptions): ModuleTreeContext<TRecord>;
 export declare function useModuleContext<TRecord>(options?: Partial<ModuleContextOptions>): ModuleContext<TRecord>;

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

@@ -1,3 +1,4 @@
+import { type LanguageContext } from '../language';
 /** Shared interaction vocabulary for page design and business rendering. */
 export declare function pageActionIntent(code: string, anchor: string): {
     operation: string;
@@ -8,7 +9,7 @@ export declare function pageActionEntryTitle(entry: {
     actionCode: string;
     anchor: string;
     title?: string;
-}): string;
+}, language?: LanguageContext): string;
 export declare function pageActionEntryVisible(entry: {
     actionCode: string;
     anchor: string;
@@ -18,4 +19,4 @@ export declare function pageActionEntryVisible(entry: {
 export declare function pageActionEntryDescription(entry: {
     actionCode: string;
     anchor: string;
-}): string;
+}, language?: LanguageContext): string;

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

@@ -1,3 +1,5 @@
+import { type LanguageContext } from '../language';
+import type { TextPresentationDocument } from '../../web-contracts/index';
 import type { PageActionInvocation, ResolvedModuleUiDescriptor } from '../../web-contracts/index';
 import { type AppError } from '../errors';
 import type { HttpClient } from '../http';
@@ -9,6 +11,7 @@ export interface ModuleRuntimeAction {
     actionCode: string;
     permissionActionCode?: string;
     title?: string;
+    titleSource?: import('../../web-contracts/index').TextReference;
     actionLevel?: 'DEFAULT' | 'LIST' | 'RECORD' | 'BATCH' | 'ANY';
     category?: string;
     accessMode?: 'AUTH_REQUIRED' | 'LOGIN_REQUIRED' | 'ANONYMOUS_ALLOWED';
@@ -38,11 +41,13 @@ export interface ModuleRecordActionDecision {
     actionCode: string;
     available: boolean;
     reason?: string;
+    reasonText?: import('../../web-contracts/index').TextPresentation;
 }
-export interface ModuleRuntimeContext {
+export interface ModuleRuntimeContext extends TextPresentationDocument {
     moduleAlias: string;
     tenantRequired?: boolean;
     title?: string;
+    titleSource?: import('../../web-contracts/index').TextReference;
     /** Stable wire code of the registered module kind. */
     moduleKind?: 'static' | 'dynamic';
     entryType?: 'module' | 'route' | 'link';
@@ -60,9 +65,13 @@ export interface ModuleRuntimeContextState {
     ready: Promise<ModuleRuntimeContext>;
     load(): Promise<ModuleRuntimeContext>;
     snapshot(): ModuleRuntimeContext | undefined;
+    presentationSnapshot?(): ModuleRuntimeContext | undefined;
+    /** Refresh only matching source translations; retain execution facts and active drafts. */
+    refreshTexts?(): Promise<void>;
     error(): AppError | undefined;
     hasAbility(ability: ModuleAbilityCode | string): boolean | undefined;
     action(actionCode: string, recordId?: string): ModuleActionState | undefined;
+    /** Action titles follow this display scope; snapshot() retains producer originals. */
     runtimeAction(actionCode: string): ModuleRuntimeAction | undefined;
     can(actionCode: string, recordId?: string): boolean | undefined;
     recordActions(recordId: string): Promise<ModuleRecordActionAvailability>;
@@ -70,5 +79,9 @@ export interface ModuleRuntimeContextState {
     recordActionsSnapshot(recordId: string): ModuleRecordActionAvailability | undefined;
     invalidateRecordActions?(recordIds?: string[]): void;
 }
-export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE' | 'VIEW'): ModuleRuntimeContextState;
+export declare function createModuleRuntimeContextState(http: HttpClient, moduleAlias: string, access?: 'MENU' | 'REFERENCE' | 'VIEW', language?: LanguageContext): ModuleRuntimeContextState;
+/** A language view shares transport, authorization and retained record decisions with its owner. */
+export declare function scopeModuleRuntimeLanguage(context: ModuleRuntimeContextState, language: LanguageContext, access?: Pick<ModuleRuntimeContextState, 'action' | 'runtimeAction'>): ModuleRuntimeContextState;
 export declare function isRuntimeAbilityAvailable(context: ModuleRuntimeContext | undefined, ability: ModuleAbilityCode): boolean;
+/** UI consumers use a disposable display projection; execution and identity consumers keep snapshot(). */
+export declare function displayModuleRuntime(runtime: ModuleRuntimeContextState): ModuleRuntimeContext | undefined;

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

@@ -1,3 +1,5 @@
+import { type LanguageContext } from './language';
+import { type OperationErrorMessage } from './operationErrors';
 import type { OperationPresentation, OperationReceiptReference } from '../web-contracts/index';
 /** Captured platform command. The caller owns the candidate and execution scope. */
 export interface OperationProposal {
@@ -14,6 +16,8 @@ export interface OperationProposal {
 export type OperationConfirmationState = 'pending' | 'executing' | 'checking' | 'succeeded' | 'unknown' | 'cancelled' | 'expired' | 'rejected';
 /** Adapter proof that no persistent operation was accepted (validation or authorization rejection). */
 export declare class OperationRejectedError extends Error {
+    readonly textMessage?: OperationErrorMessage;
+    constructor(message?: string | OperationErrorMessage, options?: ErrorOptions);
 }
 export interface OperationConfirmation {
     readonly confirmLabel: string;
@@ -25,4 +29,4 @@ export interface OperationConfirmation {
     cancel(): void;
 }
 /** Explicit confirmation, duplicate-click protection and read-only recovery of uncertain writes. */
-export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number): OperationConfirmation;
+export declare function createOperationConfirmation(proposal: OperationProposal, scopeIsCurrent: () => boolean, now?: () => number, language?: LanguageContext): OperationConfirmation;

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

@@ -1,8 +1,22 @@
+import type { TextReference } from '../web-contracts/index';
+import { type LanguageContext } from './language';
+export interface OperationErrorMessage {
+    readonly message: string;
+    readonly source: TextReference;
+    readonly args: Readonly<Record<string, string | number | boolean | null>>;
+}
+/** Explicit CODE declaration; parameters are frozen display facts, never inferred from prose. */
+export declare function codeOperationErrorMessage(language: LanguageContext, key: string, original: string, args?: Record<string, unknown>): OperationErrorMessage;
 /** A rejected editor operation with safe, bounded feedback for callers. */
 export declare class OperationUsageError extends Error {
     readonly code: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED';
-    constructor(message: string, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
+    readonly textMessage?: OperationErrorMessage;
+    constructor(message: string | OperationErrorMessage, code?: 'CAPABILITY_USAGE_INVALID' | 'CANDIDATE_AMBIGUOUS' | 'CANDIDATE_EXPIRED' | 'PRECONDITION_FAILED');
 }
+/** Resolves owned presentation facts without replaying validation or changing the error code. */
+export declare function resolveOperationErrorMessage(error: Error & {
+    readonly textMessage?: OperationErrorMessage;
+}, language?: LanguageContext): string;
 /** A staged draft was rejected before publication; no draft or display state was changed. */
 export declare class DraftUpdateRejectedError extends OperationUsageError {
     constructor(failure: OperationUsageError);

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

@@ -0,0 +1,21 @@
+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. */
+export declare function createCodeTextPresentation(key: string, originalText: string, context: LanguageContext, args?: Record<string, unknown>): TextPresentation;
+export declare function resolvePresentationText(text: TextPresentation, context: LanguageContext): TextResolution;
+/** Typed labels outside module descriptors use the same immutable presentation resource. */
+export declare function presentationLabel(original: string, text: TextPresentation | undefined, context: LanguageContext): string;
+/** Restore source facts for execution/dirty checks; projections remain separate and disposable. */
+export declare function originalPresentation<T extends TextPresentationDocument>(document: T): T;
+export declare function translatedPresentation<T extends TextPresentationDocument>(document: T, context: LanguageContext): T;
+export declare function isTextReference(value: unknown): value is TextReference;
+/** A label is valid only while its explicitly declared source still matches the raw record value. */
+export declare function recordPresentationText(record: object | undefined, field: string): TextPresentation | undefined;
+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/sha256.d.ts

@@ -0,0 +1,2 @@
+/** UTF-8 digest shared with server source versions; works without WebCrypto on LAN HTTP. */
+export declare function sha256Hex(text: string): string;

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

@@ -0,0 +1,71 @@
+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[]>;
+    historyEvents: (id: string) => Promise<WorkflowEvent[]>;
+    status: (alias: string, id: string) => Promise<WorkflowStatus>;
+    submitBranches: (alias: string, id: string, payload?: unknown) => Promise<WorkflowBranch[]>;
+    executeGuide: (id: string, guideKey: string, payload: unknown) => Promise<unknown>;
+    preview: (alias: string, id: string, payload?: unknown) => Promise<{
+        semanticJson: string | undefined;
+        layoutJson: string | undefined;
+        definition?: WorkflowStatus["definition"];
+        tasks: WorkflowTask[];
+        taskViews?: WorkflowTask[];
+        instance: import("../web-contracts/index").WorkflowInstance;
+        nodes: import("../web-contracts/index").WorkflowNode[];
+        routes: import("../web-contracts/index").WorkflowRoute[];
+    }>;
+    submit: (alias: string, id: string, payload?: unknown) => Promise<unknown>;
+    bundle: (id: string) => Promise<WorkflowRenderBundle>;
+    addSignExplanations: (id: string) => Promise<WorkflowAddSignExplanation[]>;
+    actions: (id: string) => Promise<WorkflowAction[]>;
+    tasks: (id: string) => Promise<WorkflowTask[]>;
+    events: (id: string) => Promise<WorkflowEvent[]>;
+    branches: (id: string) => Promise<WorkflowBranch[]>;
+    branchChoices: (id: string, payload: unknown) => Promise<WorkflowBranch[]>;
+    taskAction: (id: string, code: string, payload: unknown) => Promise<unknown>;
+    instanceAction: (id: string, code: string, payload: unknown) => Promise<unknown>;
+    workbench: (board: string, pageNumber?: number, moduleAlias?: string) => Promise<WorkflowWorkbenchCard[]>;
+    workbenchModules: () => Promise<import("../web-contracts/index").ModuleTitleCatalog>;
+    workbenchPage: (board: string, pageNum?: number, filters?: WorkflowWorkbenchFilters, keyword?: string, pageSize?: number) => Promise<WebPageResponse<WorkflowWorkbenchCard> & {
+        navigation?: {
+            modules: Record<string, string>;
+            moduleTitles?: import("../web-contracts/index").ModuleTitleCatalog;
+        };
+    }>;
+    taskViews: (id: string) => Promise<WorkflowTask[]>;
+    eventViews: (id: string) => Promise<WorkflowEvent[]>;
+    prepareTask: (id: string) => Promise<WorkflowTaskPreparation>;
+};
+/** Definition commands are scoped to the owning business module. */
+export declare function createWorkflowDefinitionClient(http: HttpClient, moduleAlias: string): {
+    catalog: (id: string) => Promise<WorkflowConfigurationCatalog>;
+    query: () => Promise<WorkflowDefinition[]>;
+    versions: (id: string) => Promise<WorkflowVersion[]>;
+    create: (payload: WorkflowDefinitionCreate) => Promise<WorkflowDefinition>;
+    view: (id: string) => Promise<WorkflowDefinition>;
+    upgrade: (id: string) => Promise<WorkflowVersion>;
+    saveSelection: (id: string, payload: WorkflowDefinitionSelection) => Promise<WorkflowDefinition>;
+    design: (id: string, versionId: string) => Promise<WorkflowDesign>;
+    saveDesign: (id: string, versionId: string, expectedVersion: number, design: WorkflowDesign) => Promise<WorkflowVersion>;
+    validate: (id: string, versionId: string) => Promise<unknown>;
+    publish: (id: string, versionId: string, definitionVersion: number, expectedVersion: number) => Promise<WorkflowVersion>;
+    changeStatus: (id: string, action: "disable" | "archive", expectedVersion: number) => Promise<WorkflowDefinition>;
+};
+/** Management projections and commands keep their separate authorization boundary. */
+export declare function createWorkflowAdminClient(http: HttpClient): {
+    instances: (query: WorkflowAdminInstanceQuery) => Promise<WorkflowAdminInstance[]>;
+    history: (query: WorkflowAdminHistoryQuery) => Promise<WorkflowHistoryInstance[]>;
+    bundle: (id: string, history: boolean) => Promise<WorkflowRenderBundle>;
+    events: (id: string, history: boolean) => Promise<WorkflowEvent[]>;
+    activeTasks: (id: string) => Promise<WorkflowAdminTask[]>;
+    execute: (instanceId: string, code: string, reason: string, taskId?: string) => Promise<unknown>;
+};

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

@@ -0,0 +1,6 @@
+/** A UI host can protect drafts without coupling reusable record panels to the workbench implementation. */
+export interface WorkspaceUnsavedStateRegistrar {
+    registerUnsavedState(source: string, isDirty: () => boolean, isBusy?: () => boolean, sourceTitle?: () => string): () => void;
+}
+export declare function provideWorkspaceUnsavedStateRegistrar(registrar: WorkspaceUnsavedStateRegistrar | undefined): void;
+export declare function useWorkspaceViewUnsavedState(source: string | (() => string), isDirty: () => boolean, isBusy?: () => boolean): void;