@nocobase/plugin-flow-engine 2.1.0-alpha.40 → 2.1.0-alpha.46

package/dist/server/flow-surfaces/service-helpers.d.ts

@@ -26,6 +26,35 @@ export declare function getCollectionName(collection: any): any;
 export declare function getCollectionTitleFieldName(collection: any): any;
 export declare function getFieldName(field: any): any;
 export declare function getFieldTitle(field: any): any;
+export declare function getCollectionModelAttributes(collection: any): any;
+export type FlowSurfaceChartBuilderSupportedSubfield = {
+    field: string;
+    title?: string;
+    interface?: string;
+};
+export declare function getChartBuilderSupportedRelationSubfields(associationPathName: string, targetCollection: any): FlowSurfaceChartBuilderSupportedSubfield[];
+export declare function formatChartBuilderSupportedRelationSubfields(associationPath: string, supportedFields?: FlowSurfaceChartBuilderSupportedSubfield[]): string;
+export declare function getInvalidChartBuilderRelationDirectSubfieldDetails(input: {
+    associationPathName: string;
+    selectedSubfieldPath: string;
+    targetCollection: any;
+}): {
+    associationPath: string;
+    leafFieldName: string;
+    selectedSubfieldPath: string;
+    supportedFields: FlowSurfaceChartBuilderSupportedSubfield[];
+};
+export declare function getUnsupportedChartBuilderRelationSubfieldDetails(input: {
+    associationPathName: string;
+    leafFieldName: string;
+    leafField?: any;
+    targetCollection: any;
+}): {
+    associationPath: string;
+    leafFieldName: string;
+    columnName: string;
+    supportedFields: FlowSurfaceChartBuilderSupportedSubfield[];
+};
 export declare function resolveAssociationNameFromField(field: any, fallbackCollection?: any): any;
 export declare function getFieldInterface(field: any): any;
 export declare function getFieldType(field: any): any;

package/dist/server/flow-surfaces/service-helpers.js

@@ -40,8 +40,11 @@ __export(service_helpers_exports, {
   buildFilterFieldMeta: () => buildFilterFieldMeta,
   buildFlowTemplateSearchFilter: () => buildFlowTemplateSearchFilter,
   dedupeVisibleFieldCandidates: () => dedupeVisibleFieldCandidates,
+  formatChartBuilderSupportedRelationSubfields: () => formatChartBuilderSupportedRelationSubfields,
   getAssociationFilterTargetKey: () => getAssociationFilterTargetKey,
+  getChartBuilderSupportedRelationSubfields: () => getChartBuilderSupportedRelationSubfields,
   getCollectionFields: () => getCollectionFields,
+  getCollectionModelAttributes: () => getCollectionModelAttributes,
   getCollectionName: () => getCollectionName,
   getCollectionTitle: () => getCollectionTitle,
   getCollectionTitleFieldName: () => getCollectionTitleFieldName,
@@ -51,6 +54,8 @@ __export(service_helpers_exports, {
   getFieldTarget: () => getFieldTarget,
   getFieldTitle: () => getFieldTitle,
   getFieldType: () => getFieldType,
+  getInvalidChartBuilderRelationDirectSubfieldDetails: () => getInvalidChartBuilderRelationDirectSubfieldDetails,
+  getUnsupportedChartBuilderRelationSubfieldDetails: () => getUnsupportedChartBuilderRelationSubfieldDetails,
   hasConfiguredFlowContextValue: () => hasConfiguredFlowContextValue,
   inferAssociationLeafDisplayFieldUse: () => inferAssociationLeafDisplayFieldUse,
   inferFieldMenuEditableFieldUse: () => inferFieldMenuEditableFieldUse,
@@ -178,6 +183,101 @@ function getFieldTitle(field) {
   var _a, _b, _c, _d;
   return ((_a = field == null ? void 0 : field.uiSchema) == null ? void 0 : _a.title) || ((_c = (_b = field == null ? void 0 : field.options) == null ? void 0 : _b.uiSchema) == null ? void 0 : _c.title) || (field == null ? void 0 : field.title) || ((_d = field == null ? void 0 : field.options) == null ? void 0 : _d.title) || getFieldName(field);
 }
+function getCollectionModelAttributes(collection) {
+  var _a, _b, _c;
+  return (typeof ((_a = collection == null ? void 0 : collection.model) == null ? void 0 : _a.getAttributes) === "function" ? collection.model.getAttributes() : null) || ((_b = collection == null ? void 0 : collection.model) == null ? void 0 : _b.rawAttributes) || ((_c = collection == null ? void 0 : collection.model) == null ? void 0 : _c.attributes) || {};
+}
+function getCollectionFieldColumnName(collection, fieldName) {
+  var _a;
+  const normalized = String(fieldName || "").trim();
+  if (!normalized) {
+    return "";
+  }
+  const attribute = (_a = getCollectionModelAttributes(collection)) == null ? void 0 : _a[normalized];
+  return String((attribute == null ? void 0 : attribute.field) || normalized).trim();
+}
+function getChartBuilderSupportedRelationSubfields(associationPathName, targetCollection) {
+  const normalizedAssociationPath = String(associationPathName || "").trim();
+  if (!normalizedAssociationPath || !targetCollection) {
+    return [];
+  }
+  return getCollectionFields(targetCollection).reduce((result, field) => {
+    const fieldName = getFieldName(field);
+    if (!fieldName || isAssociationField(field)) {
+      return result;
+    }
+    if (getCollectionFieldColumnName(targetCollection, fieldName) !== fieldName) {
+      return result;
+    }
+    result.push(
+      import_lodash.default.pickBy(
+        {
+          field: `${normalizedAssociationPath}.${fieldName}`,
+          title: getFieldTitle(field),
+          interface: getFieldInterface(field)
+        },
+        (value) => !import_lodash.default.isUndefined(value)
+      )
+    );
+    return result;
+  }, []);
+}
+function formatChartBuilderSupportedRelationSubfields(associationPath, supportedFields = []) {
+  const fields = supportedFields.map((item) => String((item == null ? void 0 : item.field) || "").trim()).filter(Boolean);
+  if (!fields.length) {
+    return `No chart-builder-compatible fields are available under '${associationPath}'.`;
+  }
+  return `Supported fields under '${associationPath}': ${fields.join(", ")}.`;
+}
+function getInvalidChartBuilderRelationDirectSubfieldDetails(input) {
+  const associationPath = String(input.associationPathName || "").trim();
+  const selectedSubfieldPath = String(input.selectedSubfieldPath || "").trim();
+  const selectedParts = selectedSubfieldPath.split(".").filter(Boolean);
+  if (!associationPath || !input.targetCollection || !selectedParts.length) {
+    return null;
+  }
+  const leafFieldName = selectedParts[0];
+  const leafField = resolveFieldFromCollection(input.targetCollection, leafFieldName);
+  const modelAttributes = getCollectionModelAttributes(input.targetCollection);
+  const modelAttribute = modelAttributes == null ? void 0 : modelAttributes[leafFieldName];
+  const hasModelAttribute = Object.prototype.hasOwnProperty.call(modelAttributes, leafFieldName);
+  const hasNestedSubfieldPath = selectedParts.length > 1;
+  if (leafField && !hasNestedSubfieldPath && !isAssociationField(leafField)) {
+    return null;
+  }
+  if (!leafField && hasModelAttribute && !hasNestedSubfieldPath) {
+    const columnName = String((modelAttribute == null ? void 0 : modelAttribute.field) || leafFieldName).trim();
+    if (columnName && columnName !== leafFieldName) {
+      return null;
+    }
+  }
+  return {
+    associationPath,
+    leafFieldName,
+    selectedSubfieldPath: selectedParts.join("."),
+    supportedFields: getChartBuilderSupportedRelationSubfields(associationPath, input.targetCollection)
+  };
+}
+function getUnsupportedChartBuilderRelationSubfieldDetails(input) {
+  const leafFieldName = String(input.leafFieldName || "").trim();
+  if (!input.targetCollection || !leafFieldName || input.leafField && isAssociationField(input.leafField)) {
+    return null;
+  }
+  const modelAttributes = getCollectionModelAttributes(input.targetCollection);
+  if (!input.leafField && !Object.prototype.hasOwnProperty.call(modelAttributes, leafFieldName)) {
+    return null;
+  }
+  const columnName = getCollectionFieldColumnName(input.targetCollection, leafFieldName);
+  if (!columnName || columnName === leafFieldName) {
+    return null;
+  }
+  return {
+    associationPath: String(input.associationPathName || "").trim(),
+    leafFieldName,
+    columnName,
+    supportedFields: getChartBuilderSupportedRelationSubfields(input.associationPathName, input.targetCollection)
+  };
+}
 function resolveAssociationNameFromField(field, fallbackCollection) {
   const resourceName = typeof (field == null ? void 0 : field.resourceName) === "string" ? field.resourceName.trim() : "";
   if (resourceName) {
@@ -309,8 +409,11 @@ function getAssociationFilterTargetKey(field, targetCollection) {
   buildFilterFieldMeta,
   buildFlowTemplateSearchFilter,
   dedupeVisibleFieldCandidates,
+  formatChartBuilderSupportedRelationSubfields,
   getAssociationFilterTargetKey,
+  getChartBuilderSupportedRelationSubfields,
   getCollectionFields,
+  getCollectionModelAttributes,
   getCollectionName,
   getCollectionTitle,
   getCollectionTitleFieldName,
@@ -320,6 +423,8 @@ function getAssociationFilterTargetKey(field, targetCollection) {
   getFieldTarget,
   getFieldTitle,
   getFieldType,
+  getInvalidChartBuilderRelationDirectSubfieldDetails,
+  getUnsupportedChartBuilderRelationSubfieldDetails,
   hasConfiguredFlowContextValue,
   inferAssociationLeafDisplayFieldUse,
   inferFieldMenuEditableFieldUse,

package/dist/server/flow-surfaces/service-utils.d.ts

@@ -75,6 +75,8 @@ export type NormalizedComposeFieldSpec = {
     pageSize?: number;
     showIndex?: boolean;
     target?: string;
+    defaultTargetUid?: string;
+    targetBlockUid?: string;
     settings: Record<string, any>;
     popup?: Record<string, any>;
     __autoPopupForRelationField?: boolean;
@@ -102,17 +104,29 @@ export declare function hasLegacyLocatorFields(input: any, options?: {
 }): boolean;
 export declare function rethrowInlineConfigurationError(error: any, prefix: string): never;
 export declare function toFlowSurfaceBatchItemError(error: any): {
-    code: string;
     message: string;
+    errorCount: number;
+    details: {
+        requiredBlockPolicy?: {
+            requiredBlockTypes: string[];
+            fixStrategy: string;
+            doNotReplaceOrDrop: boolean;
+        };
+        errorCount: number;
+        mustFixAllErrorsBeforeRetry: boolean;
+        retryPolicy: string;
+        sameWriteRetryRequired: boolean;
+        agentInstruction: string;
+    };
+    errors: import("./errors").FlowSurfaceErrorItem[];
+    code: string;
     status: number;
     type: import("./errors").FlowSurfaceErrorType;
-    errors: import("./errors").FlowSurfaceErrorItem[];
 } | {
     code: string;
     message: string;
     status: number;
     type: import("./errors").FlowSurfaceErrorType;
-    errors?: undefined;
 };
 export declare function splitComposeFieldChanges(changes: Record<string, any>, wrapperUse?: string): {
     wrapperChanges: _.Dictionary<any>;

package/dist/server/flow-surfaces/service-utils.js

@@ -410,6 +410,12 @@ function normalizeComposeFieldSpec(input, index) {
   if (!import_lodash.default.isUndefined(input.target) && typeof input.target !== "string") {
     (0, import_errors.throwBadRequest)(`flowSurfaces compose field #${index + 1} target must be a string block key`);
   }
+  if (!import_lodash.default.isUndefined(input.defaultTargetUid) && typeof input.defaultTargetUid !== "string") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces compose field #${index + 1} defaultTargetUid must be a string`);
+  }
+  if (!import_lodash.default.isUndefined(input.targetBlockUid) && typeof input.targetBlockUid !== "string") {
+    (0, import_errors.throwBadRequest)(`flowSurfaces compose field #${index + 1} targetBlockUid must be a string`);
+  }
   const rawKey = String(input.key || semanticType || (renderer === "js" ? `js:${fieldPath}` : fieldPath)).trim();
   const key = normalizeFlowSurfaceComposeKey(rawKey, `flowSurfaces compose field #${index + 1}`);
   const popupDefaultsMetadata = import_lodash.default.isPlainObject(input[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY]) ? input[import_defaults.FLOW_SURFACE_APPLY_BLUEPRINT_POPUP_DEFAULTS_KEY] : void 0;
@@ -428,6 +434,8 @@ function normalizeComposeFieldSpec(input, index) {
     ...!import_lodash.default.isUndefined(pageSize) && Number.isFinite(pageSize) ? { pageSize } : {},
     ...!import_lodash.default.isUndefined(showIndex) ? { showIndex } : {},
     target: typeof input.target === "string" ? String(input.target || "").trim() || void 0 : void 0,
+    defaultTargetUid: typeof input.defaultTargetUid === "string" ? String(input.defaultTargetUid || "").trim() || void 0 : void 0,
+    targetBlockUid: typeof input.targetBlockUid === "string" ? String(input.targetBlockUid || "").trim() || void 0 : void 0,
     settings: import_lodash.default.isPlainObject(input.settings) ? input.settings : {},
     popup: import_lodash.default.isPlainObject(input.popup) ? input.popup : void 0,
     __autoPopupForRelationField: input.__autoPopupForRelationField === true,
@@ -612,12 +620,14 @@ function hasLegacyLocatorFields(input, options = {}) {
   return keys.some((key) => Object.prototype.hasOwnProperty.call(input, key));
 }
 function rethrowInlineConfigurationError(error, prefix) {
-  const childMessages = (0, import_errors.isFlowSurfaceAggregateError)(error) ? error.errors.map((item) => item.message).filter(Boolean) : [];
-  const message = `${prefix}: ${[(error == null ? void 0 : error.message) || String(error), ...childMessages].join("; ")}`;
+  if ((0, import_errors.isFlowSurfaceAggregateError)(error)) {
+    throw new import_errors.FlowSurfaceAggregateError(error.errors, `${prefix}: ${error.message}`);
+  }
+  const message = `${prefix}: ${(error == null ? void 0 : error.message) || String(error)}`;
   if ((0, import_errors.isFlowSurfaceError)(error)) {
     const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);
     if (normalized.type === "bad_request") {
-      (0, import_errors.throwBadRequest)(message, normalized.code);
+      (0, import_errors.throwBadRequest)(message, normalized.code, normalized.options);
     }
     if (normalized.type === "conflict") {
       (0, import_errors.throwConflict)(message, normalized.code);
@@ -633,10 +643,9 @@ function toFlowSurfaceBatchItemError(error) {
   if ((0, import_errors.isFlowSurfaceAggregateError)(error)) {
     return {
       code: error.code,
-      message: error.message,
       status: error.status,
       type: error.type,
-      errors: error.errors
+      ...error.toResponseBody()
     };
   }
   const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);

package/dist/server/flow-surfaces/service.d.ts

@@ -9,13 +9,20 @@
 import type { Plugin } from '@nocobase/server';
 import _ from 'lodash';
 import FlowModelRepository from '../repository';
+import type { FlowSurfaceApplyBlueprintDocument } from './blueprint';
 import { SurfaceLocator } from './locator';
+import { type FlowSurfaceEventFlowRegistry } from './event-flow-normalizer';
 import type { TemplateTranslate } from './template-display';
 import type { FlowSurfaceActionLinkageRule, FlowSurfaceBlockLinkageRule, FlowSurfaceFieldLinkageRule, FlowSurfaceFieldValueRule, FlowSurfaceGetReactionMetaResult, FlowSurfaceGetReactionMetaValues, FlowSurfaceReactionWriteResult, FlowSurfaceReactionWriteValues } from './reaction/types';
 import type { FlowSurfaceTemplateListPopupActionContext, FlowSurfaceTemplateListValues, FlowSurfaceTemplateRow } from './template-service-utils';
-import type { FlowSurfaceApplyValues, FlowSurfaceCatalogResponse, FlowSurfaceCatalogValues, FlowSurfaceComposeValues, FlowSurfaceConfigureValues, FlowSurfaceContextValues, FlowSurfaceDescribeValues, FlowSurfaceMutateValues } from './types';
+import type { FlowSurfaceApplyValues, FlowSurfaceActionScope, FlowSurfaceCatalogResponse, FlowSurfaceCatalogValues, FlowSurfaceComposeValues, FlowSurfaceConfigureValues, FlowSurfaceContextValues, FlowSurfaceDescribeValues, FlowSurfaceMutateValues } from './types';
+import type { FlowSurfaceContextResponse, FlowSurfaceContextVarInfo } from './types';
 type FlowSurfacePopupTemplateAliasSession = Map<string, string>;
 type FlowSurfaceRequestRoles = readonly string[] | string;
+type FlowSurfaceReadOptions = {
+    transaction?: any;
+    currentRoles?: FlowSurfaceRequestRoles;
+};
 type FlowSurfaceAddFieldResult = {
     uid?: string;
     parentUid?: string;
@@ -34,6 +41,12 @@ type FlowSurfaceAddFieldResult = {
     popupGridUid?: string;
 };
 type FlowSurfacePopupTemplateTreeCache = Map<string, Promise<any | null> | any | null>;
+type FlowSurfaceApplyBlueprintResponse = {
+    version: '1';
+    mode: FlowSurfaceApplyBlueprintDocument['mode'];
+    target: Record<string, any>;
+    surface: any;
+};
 export declare class FlowSurfacesService {
     private readonly plugin;
     constructor(plugin: Plugin);
@@ -61,12 +74,17 @@ export declare class FlowSurfacesService {
     private readRouteOptions;
     private findMenuRouteById;
     private findMenuGroupRoutesByTitle;
+    private routeParentIdMatches;
+    private findMenuGroupRoutesByParentIdAndTitle;
     private findFlowPageRoutesByParentIdAndTitle;
     private assertMenuParentIsGroup;
     private assertMenuRouteBindable;
     private assertMenuRouteUpdatable;
     private assertMenuParentNotSelfOrDescendant;
     private buildMenuResult;
+    private isValidMenuIconName;
+    private assertVisibleNavigationIcon;
+    private assertVisibleNavigationRouteIconUpdate;
     private createFlowMenuGroup;
     private createFlowMenuItem;
     private sanitizePublicCreateMenuValues;
@@ -129,7 +147,7 @@ export declare class FlowSurfacesService {
     private buildAssociatedRecordsResourceInit;
     context(values: FlowSurfaceContextValues, options?: {
         transaction?: any;
-    }): Promise<import("./types").FlowSurfaceContextResponse>;
+    }): Promise<FlowSurfaceContextResponse>;
     private extractReactionCanonicalRules;
     private buildReactionFieldPathMaps;
     private extractReactionFieldPaths;
@@ -162,9 +180,7 @@ export declare class FlowSurfacesService {
     private stripInternalSurfaceMetaFromNodeTree;
     private buildSurfaceReadPayload;
     private buildSurfaceContextFingerprint;
-    get(input: Record<string, any>, options?: {
-        transaction?: any;
-    }): Promise<Record<string, any>>;
+    get(input: Record<string, any>, options?: FlowSurfaceReadOptions): Promise<Record<string, any>>;
     private getDeclaredKeyPersistenceDeps;
     private patchDeclaredKeyModel;
     private persistCreatedKeysForAction;
@@ -177,6 +193,11 @@ export declare class FlowSurfacesService {
     private resolveApplyBlueprintCreateNavigationGroup;
     private resolveApplyBlueprintCreatePageIdentity;
     private prepareApplyBlueprintRequest;
+    private prevalidateApplyBlueprintChartAssets;
+    private composeChartBlockHasInlineConfig;
+    private prepareComposeChartAssetNestedPopupBlocks;
+    private prepareComposeChartAssetBlockList;
+    private prepareComposeChartAssetSettings;
     private getApplyBlueprintKanbanBlockResourceObject;
     private normalizeApplyBlueprintKanbanResourceText;
     private getApplyBlueprintKanbanBlockBinding;
@@ -201,13 +222,11 @@ export declare class FlowSurfacesService {
     applyBlueprint(values: Record<string, any>, options?: {
         transaction?: any;
         currentRoles?: FlowSurfaceRequestRoles;
-    }): Promise<{
-        version: string;
-        mode: import("./blueprint").FlowSurfaceApplyBlueprintMode;
-        target: _.Dictionary<any>;
-        surface: Record<string, any>;
-    }>;
+    }): Promise<FlowSurfaceApplyBlueprintResponse>;
+    private applyBlueprintMutationWithoutExternalTransaction;
+    private assertApplyBlueprintAuthoringPayload;
     private applyBlueprintWithTransaction;
+    private buildApplyBlueprintResponse;
     private findApprovalSurfaceRootForNode;
     private syncApprovalRuntimeConfigForSurfaceRoot;
     private syncApprovalRuntimeConfigForNode;
@@ -456,7 +475,7 @@ export declare class FlowSurfacesService {
         uid: any;
         parentUid: any;
         subKey: string;
-        scope: import("./types").FlowSurfaceActionScope;
+        scope: FlowSurfaceActionScope;
     }>;
     addRecordAction(values: Record<string, any>, options?: {
         transaction?: any;
@@ -469,7 +488,7 @@ export declare class FlowSurfacesService {
         uid: any;
         parentUid: any;
         subKey: string;
-        scope: import("./types").FlowSurfaceActionScope;
+        scope: FlowSurfaceActionScope;
     }>;
     addBlocks(values: Record<string, any>): Promise<{
         [x: string]: number | Record<string, any>[];
@@ -559,6 +578,7 @@ export declare class FlowSurfacesService {
     private resolveDefaultActionPopupTemplateOpenViewTitle;
     private buildInlinePopupTemplateOpenView;
     private peekInlineFieldSettingsOpenView;
+    private isInlineFieldClickToOpenEnabled;
     private assertOpenViewUidTarget;
     private normalizeFlowTemplateMode;
     private normalizeFlowTemplateUsage;
@@ -593,6 +613,11 @@ export declare class FlowSurfacesService {
     private tryResolvePopupTemplateForHost;
     private tryResolveExistingDefaultActionPopupTemplate;
     private getFlowTemplateOrThrow;
+    private shouldUseRuntimeRecordFilterByTkForOpenView;
+    private resolveOpenViewFilterTargetKey;
+    private resolvePopupHostCurrentRecordFilterTargetKey;
+    private resolveOpenViewRuntimeRecordFilterTargetKey;
+    private shouldOmitRuntimeRecordFilterByTk;
     private buildPopupTemplateOpenView;
     private isReferencedPopupTemplateOpenView;
     private isPopupTemplateReferenceOpenViewState;
@@ -622,6 +647,7 @@ export declare class FlowSurfacesService {
     private getActionButtonTitle;
     private isSemanticallyEmptyInlinePopup;
     private isEmptyInlinePopupPayload;
+    private isInlineFieldPopupDefaultShell;
     private shouldAutoCompleteDefaultFieldPopup;
     private isInlineFieldPopupBlockMissingResource;
     private buildRelationFieldPopupCurrentRecordResource;
@@ -727,6 +753,7 @@ export declare class FlowSurfacesService {
     private normalizeChartSelectionFieldPath;
     private validateBuilderChartFieldsForRuntime;
     private resolveBuilderChartAssociationSubfieldSuggestion;
+    private validateChartConfigureForRuntime;
     private stripChartSqlForInspection;
     private normalizeReadOnlyChartSql;
     private buildChartSqlPreviewQuery;
@@ -746,7 +773,7 @@ export declare class FlowSurfacesService {
             kind: import("./types").FlowSurfaceContainerKind;
             use: any;
         };
-        flowRegistry: any;
+        flowRegistry: FlowSurfaceEventFlowRegistry;
         events: {
             direct: string[];
             object: string[];
@@ -773,7 +800,7 @@ export declare class FlowSurfacesService {
                 additionalProperties: boolean;
             };
         }[];
-        vars: Record<string, import("./types").FlowSurfaceContextVarInfo>;
+        vars: Record<string, FlowSurfaceContextVarInfo>;
         fingerprint: string;
         writeCapabilities: {
             defaultAddPhase: string;
@@ -817,6 +844,7 @@ export declare class FlowSurfacesService {
     }>;
     private resolveEventFlowTarget;
     private getEventFlowRegistry;
+    private normalizeEventFlowRegistry;
     private buildEventFlowFingerprint;
     private assertEventFlowFingerprint;
     private normalizeEventFlowKey;
@@ -942,6 +970,10 @@ export declare class FlowSurfacesService {
     private buildAutoComposeFieldsLayout;
     private normalizeComposeFieldGroups;
     private applyDefaultActionsForCreatedBlock;
+    private hasActionWithPublicType;
+    private ensureTableDefaultActionIntegrity;
+    private collectNodeTreeDescendants;
+    private ensureSurfaceTableDefaultActionIntegrity;
     private resolveReusableSingletonAction;
     private normalizeComposeBlock;
     private normalizeComposeBlocks;
@@ -1002,10 +1034,20 @@ export declare class FlowSurfacesService {
     private normalizeActionAssignValues;
     private normalizeActionTriggerWorkflows;
     private isAIEmployeeActionUse;
+    private stableSerializeAIEmployeeValue;
+    private buildAIEmployeeActionDedupIdentity;
+    private normalizeAIEmployeeWorkContextForDedupIdentity;
+    private normalizeAIEmployeeTasksForDedupIdentity;
+    private assertNoDuplicateAIEmployeeAction;
     private hasAIEmployeePublicSettings;
     private assertOnlyAIEmployeePublicSettings;
+    private aiEmployeeNestedRepairHint;
     private assertOnlyAIEmployeeNestedPublicSettings;
     private assertNoAIEmployeeInternalPropSettings;
+    private readAIEmployeePersistedTasks;
+    private buildAIEmployeeTaskStepParams;
+    private mergeAIEmployeeActionSettingsPayload;
+    private syncAIEmployeeTaskStepParamsForUpdateSettings;
     private assertAIEmployeePluginEnabled;
     private readRecordPlainObject;
     private readRecordField;
@@ -1017,6 +1059,23 @@ export declare class FlowSurfacesService {
     private normalizeAIEmployeeWorkContext;
     private normalizeAIEmployeeTaskModel;
     private normalizeAIEmployeeSkillSettings;
+    private collectAIEmployeePromptVariables;
+    private hasAIEmployeePromptVariables;
+    private collectAIEmployeeContextPathEntries;
+    private isAIEmployeeContextInfoPathAllowed;
+    private canResolveAIEmployeeContextPath;
+    private isAIEmployeeContextPathAllowed;
+    private extractAIEmployeePromptContextPath;
+    private buildAIEmployeePromptVariableHint;
+    private throwAIEmployeePromptVariableInvalid;
+    private assertAIEmployeePromptVariablesAllowed;
+    private assertAIEmployeeTaskPromptVariablesAllowed;
+    private appendAIEmployeeCurrentRecordPromptVariable;
+    private resolveAIEmployeePromptActionTargetUid;
+    private buildAIEmployeePromptValidationContext;
+    private appendAIEmployeeCurrentRecordPromptVariableToTasks;
+    private assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings;
+    private normalizeAIEmployeeStepParamTasksForUpdateSettings;
     private normalizeAIEmployeeTaskMessage;
     private normalizeAIEmployeeTaskPatch;
     private normalizeAIEmployeeTasks;