@nocobase/plugin-flow-engine 2.1.0-alpha.38 → 2.1.0-alpha.39

package/dist/server/flow-surfaces/runjs-authoring/value-surface-forbids-render/index.js

@@ -0,0 +1,40 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var value_surface_forbids_render_exports = {};
+__export(value_surface_forbids_render_exports, {
+  valueSurfaceForbidsRenderRule: () => valueSurfaceForbidsRenderRule
+});
+module.exports = __toCommonJS(value_surface_forbids_render_exports);
+const valueSurfaceForbidsRenderRule = {
+  repairClass: "value-surface-forbids-render",
+  defaultRuleId: "runjs-value-render-forbidden",
+  suggestedAction: "Remove ctx.render(...) and return the computed value."
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  valueSurfaceForbidsRenderRule
+});

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

@@ -29,7 +29,7 @@ export declare function getFieldTitle(field: any): any;
 export declare function resolveAssociationNameFromField(field: any, fallbackCollection?: any): any;
 export declare function getFieldInterface(field: any): any;
 export declare function getFieldType(field: any): any;
-export declare function inferFlowContextTypeFromField(field: any): "string" | "number" | "boolean" | "object" | "array";
+export declare function inferFlowContextTypeFromField(field: any): "object" | "string" | "array" | "number" | "boolean";
 export declare function getFieldTarget(field: any): any;
 export declare function getFieldFilterable(field: any): any;
 export declare function inferAssociationLeafDisplayFieldUse(fieldInterface?: string): string;

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

@@ -69,6 +69,26 @@ var import_lodash = __toESM(require("lodash"));
 var import_core_field_default_bindings = require("./core-field-default-bindings");
 const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE = 1;
 const FLOW_SURFACE_TEMPLATE_DEFAULT_PAGE_SIZE = 50;
+const ASSOCIATION_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "belongsto",
+  "hasone",
+  "hasmany",
+  "belongstomany",
+  "belongstoarray",
+  "onetoone"
+]);
+const ASSOCIATION_FIELD_INTERFACES = /* @__PURE__ */ new Set([
+  "m2o",
+  "o2m",
+  "m2m",
+  "o2o",
+  "mbm",
+  "obo",
+  "oho",
+  "manytoone",
+  "onetomany",
+  "manytomany"
+]);
 function toTemplatePlainRow(row) {
   if (!row) {
     return row;
@@ -220,7 +240,12 @@ function isAssociationField(field) {
   if (typeof (field == null ? void 0 : field.isAssociationField) === "function") {
     return field.isAssociationField();
   }
-  return ["belongsTo", "hasOne", "hasMany", "belongsToMany", "belongsToArray"].includes(getFieldType(field));
+  if (getFieldTarget(field)) {
+    return true;
+  }
+  const fieldType = String(getFieldType(field) || "").trim().toLowerCase();
+  const fieldInterface = String(getFieldInterface(field) || "").trim().toLowerCase();
+  return ASSOCIATION_FIELD_TYPES.has(fieldType) || ASSOCIATION_FIELD_INTERFACES.has(fieldInterface);
 }
 function resolveFieldFromCollection(collection, fieldPath) {
   var _a, _b, _c;

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

@@ -106,6 +106,13 @@ export declare function toFlowSurfaceBatchItemError(error: any): {
     message: 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

@@ -198,6 +198,9 @@ function buildBlockCardSettingsFromSemanticChanges(changes) {
   if (import_lodash.default.isEmpty(import_lodash.default.get(nextCardSettings, ["blockHeight"]))) {
     import_lodash.default.unset(nextCardSettings, ["blockHeight"]);
   }
+  if (hasOwnDefined(changes, "linkageRules")) {
+    import_lodash.default.set(nextCardSettings, ["linkageRules", "value"], changes.linkageRules);
+  }
   return Object.keys(nextCardSettings).length ? nextCardSettings : void 0;
 }
 function buildChartCardSettingsFromSemanticChanges(currentCardSettings, changes) {
@@ -609,7 +612,8 @@ function hasLegacyLocatorFields(input, options = {}) {
   return keys.some((key) => Object.prototype.hasOwnProperty.call(input, key));
 }
 function rethrowInlineConfigurationError(error, prefix) {
-  const message = `${prefix}: ${(error == null ? void 0 : error.message) || String(error)}`;
+  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.isFlowSurfaceError)(error)) {
     const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);
     if (normalized.type === "bad_request") {
@@ -626,6 +630,15 @@ function rethrowInlineConfigurationError(error, prefix) {
   (0, import_errors.throwInternalError)(message);
 }
 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
+    };
+  }
   const normalized = (0, import_errors.normalizeFlowSurfaceError)(error);
   return {
     code: normalized.code,
@@ -650,6 +663,7 @@ function splitComposeFieldChanges(changes, wrapperUse) {
     "associationPathName",
     "initialValue",
     "required",
+    "rules",
     "disabled",
     "maxCount",
     "pattern",

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

@@ -32,6 +32,7 @@ type FlowSurfaceAddFieldResult = {
     popupTabUid?: string;
     popupGridUid?: string;
 };
+type FlowSurfacePopupTemplateTreeCache = Map<string, Promise<any | null> | any | null>;
 export declare class FlowSurfacesService {
     private readonly plugin;
     constructor(plugin: Plugin);
@@ -59,6 +60,7 @@ export declare class FlowSurfacesService {
     private readRouteOptions;
     private findMenuRouteById;
     private findMenuGroupRoutesByTitle;
+    private findFlowPageRoutesByParentIdAndTitle;
     private assertMenuParentIsGroup;
     private assertMenuRouteBindable;
     private assertMenuRouteUpdatable;
@@ -101,6 +103,8 @@ export declare class FlowSurfacesService {
     private buildPopupBlockResourceBindings;
     private listPopupAssociatedRecordFields;
     private resolvePopupBlockProfile;
+    private buildAuthoringContextFromPopupProfile;
+    private buildTargetAuthoringContext;
     private resolvePopupCurrentRecordResourceFilterByTk;
     private resolvePopupAssociationFields;
     private findPopupHostNode;
@@ -127,6 +131,7 @@ export declare class FlowSurfacesService {
     }): Promise<import("./types").FlowSurfaceContextResponse>;
     private extractReactionCanonicalRules;
     private buildReactionFieldPathMaps;
+    private extractReactionFieldPaths;
     private requireReactionFieldUid;
     private buildReactionRuleNormalizers;
     private buildReactionFingerprintForSlot;
@@ -169,7 +174,29 @@ export declare class FlowSurfacesService {
     private dispatchPlanOnlyAction;
     private resolveApplyBlueprintReplaceTargetInfo;
     private resolveApplyBlueprintCreateNavigationGroup;
+    private resolveApplyBlueprintCreatePageIdentity;
     private prepareApplyBlueprintRequest;
+    private getApplyBlueprintKanbanBlockResourceObject;
+    private normalizeApplyBlueprintKanbanResourceText;
+    private getApplyBlueprintKanbanBlockBinding;
+    private getApplyBlueprintKanbanBlockDataSourceKey;
+    private getApplyBlueprintKanbanBlockDirectCollectionName;
+    private getApplyBlueprintKanbanFieldPopupAssociationPath;
+    private getApplyBlueprintKanbanBlockAssociationField;
+    private resolveApplyBlueprintKanbanAssociationFieldFromPath;
+    private resolveApplyBlueprintKanbanAssociationResourceContext;
+    private resolveApplyBlueprintKanbanBlockResourceContext;
+    private resolveApplyBlueprintKanbanFieldPopupResourceContext;
+    private getApplyBlueprintKanbanSortFieldName;
+    private createApplyBlueprintKanbanSortField;
+    private prepareApplyBlueprintKanbanBlocks;
+    private prepareApplyBlueprintKanbanBlockList;
+    private prepareApplyBlueprintKanbanPopupBlocks;
+    private prepareApplyBlueprintKanbanBlockTree;
+    private canCreateApplyBlueprintKanbanSortField;
+    private prepareApplyBlueprintKanbanBlock;
+    private cleanupApplyBlueprintKanbanSortFields;
+    private bindTransactionRollbackEmitter;
     applyBlueprint(values: Record<string, any>, options?: {
         transaction?: any;
     }): Promise<{
@@ -178,6 +205,7 @@ export declare class FlowSurfacesService {
         target: _.Dictionary<any>;
         surface: Record<string, any>;
     }>;
+    private applyBlueprintWithTransaction;
     private findApprovalSurfaceRootForNode;
     private syncApprovalRuntimeConfigForSurfaceRoot;
     private syncApprovalRuntimeConfigForNode;
@@ -199,6 +227,8 @@ export declare class FlowSurfacesService {
     private resolveTemplateResourceInfo;
     private resolveBlockTemplateExpectedResourceInfo;
     private getTemplateResourceCompatibilityDisabledReason;
+    private getPopupTemplateAssociationMatchMode;
+    private getPopupTryTemplateResourceDisabledReason;
     private getFieldsTemplateDisabledReason;
     private assertFieldsTemplateCompatibility;
     private loadTemplateListTargetContext;
@@ -210,6 +240,8 @@ export declare class FlowSurfacesService {
     private resolveTemplateListPopupActionContext;
     private getBlockTemplateDisabledReason;
     private assertBlockTemplateCompatibility;
+    private getPopupTryTemplateDisabledReason;
+    private withPopupTryTemplateAvailability;
     private getPopupTemplateDisabledReason;
     private getTemplateListDisabledReason;
     private withTemplateAvailability;
@@ -240,14 +272,20 @@ export declare class FlowSurfacesService {
     private clearFlowTemplateUsagesByModelUids;
     private clearFlowTemplateUsagesForNodeTree;
     private syncFlowTemplateUsagesForNodeTree;
+    private syncFlowTemplateUsagesForNodeTreeExcluding;
+    private clearFlowTemplateUsagesForNodeTreeTemplate;
     private clearFlowTemplateUsagesForRouteSchemaUid;
     private syncTemplateMetaToReferencedModels;
     private resolveFlowModelAttachPosition;
     private repositionFlowModelInParent;
     private convertBlockSourceToTemplateReference;
     private convertPopupSourceToTemplateReference;
+    private loadPopupSourceTemplateTreeInfo;
+    private tryReuseExistingPopupTemplateForSave;
     saveTemplate(values: Record<string, any>, options?: {
         transaction?: any;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
+        reuseExistingPopupTemplate?: boolean;
     }): Promise<FlowSurfaceTemplateRow>;
     updateTemplate(values: Record<string, any>, options?: {
         transaction?: any;
@@ -282,9 +320,13 @@ export declare class FlowSurfacesService {
         transaction?: any;
         enabledPackages?: ReadonlySet<string>;
         popupTemplateAliasSession?: FlowSurfacePopupTemplateAliasSession;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
+        skipGeneratedLayoutSingleColumnErrors?: boolean;
     }): Promise<import("./compose-runtime").FlowSurfaceComposeExecutionResult>;
     configure(values: FlowSurfaceConfigureValues, options?: {
         transaction?: any;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
+        skipConfigureGeneratedDefaultPopup?: boolean;
     }): Promise<_.Dictionary<any> | {
         uid: any;
         updated?: undefined;
@@ -377,22 +419,34 @@ export declare class FlowSurfacesService {
     private normalizeDefaultActionSettings;
     private normalizeDefaultFilterActionSettings;
     private backfillBlockDefaultFilterIntoDefaultActionSettings;
+    private normalizeEffectivePublicDataSurfaceDefaultFilter;
+    private getDefaultFilterCollectionFromResourceInput;
+    private getFieldGridCollectionFromResourceInput;
+    private getDefaultFilterRequiredFieldCountFromResourceInput;
+    private buildDefaultFilterFromResourceInput;
+    private buildDefaultFilterFromDataBlockUid;
     addBlock(values: Record<string, any>, options?: {
         transaction?: any;
         deferAutoLayout?: boolean;
         enabledPackages?: ReadonlySet<string>;
         skipDefaultBlockActions?: boolean;
+        preserveSingleScopeDataBlockTitle?: boolean;
+        skipAuthoringValidation?: boolean;
+        explicitFields?: boolean;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
     }): any;
     addField(values: Record<string, any>, options?: {
         transaction?: any;
         enabledPackages?: ReadonlySet<string>;
         popupTemplateAliasSession?: FlowSurfacePopupTemplateAliasSession;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
     }): Promise<FlowSurfaceAddFieldResult>;
     addAction(values: Record<string, any>, options?: {
         transaction?: any;
         enabledPackages?: ReadonlySet<string>;
         autoCompleteDefaultPopup?: boolean;
         popupTemplateAliasSession?: FlowSurfacePopupTemplateAliasSession;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
     }): Promise<{
         uid: any;
         parentUid: any;
@@ -404,6 +458,7 @@ export declare class FlowSurfacesService {
         enabledPackages?: ReadonlySet<string>;
         autoCompleteDefaultPopup?: boolean;
         popupTemplateAliasSession?: FlowSurfacePopupTemplateAliasSession;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
     }): Promise<{
         uid: string;
         parentUid: any;
@@ -443,20 +498,46 @@ export declare class FlowSurfacesService {
     private validateComposePopupTemplateAliases;
     private validateApplyBlueprintPopupTemplateAliases;
     private normalizeInlineSettings;
+    private normalizeSingleScopeDataBlockTitleSettings;
     private shouldEnableCreatedAtDefaultSorting;
     private normalizeBlockSortingInput;
     private normalizeMapSortingInput;
     private normalizeInlinePopup;
+    private getInlinePopupComposeMode;
+    private getInlinePopupDisplayOpenView;
+    private normalizeInlinePopupOpenViewContext;
+    private getInlinePopupRelationOpenViewContext;
+    private mergePopupRelationOpenViewContext;
+    private getRelationOpenViewContextFromOpenView;
+    private applyInlinePopupContextToTargetContext;
+    private mergeInlinePopupDisplayOpenView;
+    private buildPopupDefaultsMetadata;
+    private buildDefaultsFromPopupMetadata;
+    private stripPopupDefaultsMetadata;
+    private attachPopupDefaultsMetadata;
+    private isGeneratedDefaultPopupActionType;
+    private attachComposeActionPopupDefaults;
+    private attachComposeFieldPopupDefaults;
+    private attachHiddenPopupDefaultsToBlockSettings;
+    private stripHiddenPopupDefaultsFromBlockSettings;
+    private buildConfigureGeneratedDefaultPopup;
     private normalizePopupSaveAsTemplate;
     private hasInlinePopupSaveAsTemplateSource;
     private assertInlinePopupSaveAsTemplateSource;
     private clearPopupSurfaceKeys;
     private buildLegacyAutoGeneratedPopupTemplateMetadata;
+    private getUsableExplicitTitle;
+    private getExplicitCollectionTitle;
+    private getExplicitFieldTitle;
+    private getMainCollectionForTemplateMetadata;
+    private resolveCompiledCollectionTemplateLabel;
+    private resolveCompiledFieldTemplateLabel;
     private formatAutoGeneratedPopupTemplateMetadata;
     private formatAutoGeneratedActionPopupTemplateMetadata;
     private resolveFieldBindingContext;
     private resolveAutoGeneratedFieldPopupTemplateMetadata;
     private shouldAutoSaveDefaultActionPopupTemplate;
+    private shouldAutoSaveDefaultFieldPopupTemplate;
     private resolveDefaultActionPopupSemanticUse;
     private getDefaultActionPopupConfigForNode;
     private isDefaultActionPopupUseForNode;
@@ -477,12 +558,30 @@ export declare class FlowSurfacesService {
     private getDefaultFlowTemplateSort;
     private getPopupTryTemplateExpectedAssociationName;
     private getPopupTryTemplatePriority;
-    private shouldRequireExactPopupTryTemplateAssociation;
+    private shouldAllowGenericPopupTryTemplateAssociation;
+    private hasNestedInlinePopupContent;
+    private shouldRequirePopupTryTemplateExplicitNameMatch;
+    private doesPopupTemplateMatchRequestedSaveAsTemplate;
+    private getExpectedBlueprintAssociationDefaultPopupTemplateName;
+    private getPopupMetadataProfileFromTargetContext;
+    private getPopupMetadataProfileFromResourceInit;
     private getRequestedPopupDefaultType;
     private getPopupTryTemplateAllowedDefaultTypes;
     private inferPopupDefaultTypeFromTemplateTree;
-    private popupTemplateMatchesDefaultType;
+    private resolvePopupTemplateTreePage;
+    private getPopupTemplateTreeBlocks;
+    private loadPopupTemplateTree;
+    private normalizePopupTemplateSignatureValue;
+    private buildPopupTemplateTreeSemanticSignature;
+    private readPopupTemplateTreeInfo;
+    private loadPopupTemplateTreeInfo;
+    private resolvePopupBlockTypeUse;
+    private getRequestedPopupBlockUseList;
+    private getPopupTemplateRequestedBlockUsePriority;
+    private selectPopupTemplateForTargetContext;
+    private tryResolvePopupTemplateForTargetContext;
     private tryResolvePopupTemplateForHost;
+    private tryResolveExistingDefaultActionPopupTemplate;
     private getFlowTemplateOrThrow;
     private buildPopupTemplateOpenView;
     private isReferencedPopupTemplateOpenView;
@@ -501,6 +600,8 @@ export declare class FlowSurfacesService {
     private resolveFieldOpenViewContext;
     private applyFieldOpenViewContext;
     private buildDefaultFieldOpenView;
+    private applyInlineFieldPopupDisplayOpenView;
+    private applyInlineActionPopupDisplayOpenView;
     private ensureLocalFieldPopupSurface;
     private applyInlineNodeSettings;
     private resolveComposeBlockSettings;
@@ -511,9 +612,19 @@ export declare class FlowSurfacesService {
     private isSemanticallyEmptyInlinePopup;
     private isEmptyInlinePopupPayload;
     private shouldAutoCompleteDefaultFieldPopup;
+    private isInlineFieldPopupBlockMissingResource;
+    private buildRelationFieldPopupCurrentRecordResource;
+    private materializeInlineRelationFieldPopupBlocks;
     private getApplyBlueprintPopupDefaultsMetadata;
     private getApplyBlueprintDefaultFieldGroups;
+    private getApplyBlueprintDefaultFormBehavior;
+    private getDefaultFormBehaviorFieldSettings;
+    private getDefaultPopupFieldPath;
+    private applyDefaultFormBehaviorToField;
+    private applyDefaultFormBehaviorToFields;
     private pickDefaultPopupFields;
+    private getDefaultFieldGroupRelationTitleFieldOverride;
+    private hasUsableDefaultFieldGroupRelationTitleFieldOverride;
     private resolveApplyBlueprintDefaultPopupMetadata;
     private resolveApplyBlueprintAssociationDefaultContext;
     private resolveGeneratedDefaultFieldPopupName;
@@ -526,17 +637,27 @@ export declare class FlowSurfacesService {
     private shouldAutoCompleteDefaultActionPopup;
     private resolveGeneratedDefaultActionPopupName;
     private resolveGeneratedDefaultActionPopupMetadata;
+    private resolveGeneratedAssociationDefaultActionPopupMetadata;
     private buildDefaultActionPopupFields;
     private buildDefaultActionPopupNamespace;
     private buildDefaultActionPopupKeyMap;
     private remapDefaultActionPopupField;
     private remapDefaultActionPopupBlocks;
+    private decorateDefaultActionPopupAssociationField;
+    private decorateDefaultActionPopupAssociationFieldObject;
+    private decorateDefaultActionPopupAssociationBlocks;
     private remapDefaultActionPopupLayout;
     private buildDefaultActionPopupBlocks;
     private buildDefaultActionPopupComposeValues;
     private resolveDefaultActionPopupSurfaceState;
+    private resolveDefaultFieldPopupSurfaceState;
     private shouldResetDefaultActionPopupFormLinkageRules;
     private resetDefaultActionPopupFormLinkageRules;
+    private extractDefaultPopupLinkageConditionPaths;
+    private extractDefaultPopupLinkageActionFieldPaths;
+    private isDefaultPopupFormBehaviorLinkageRuleApplicable;
+    private filterDefaultPopupFormBehaviorLinkageRules;
+    private applyDefaultPopupFormBehaviorLinkageRules;
     private resolvePopupTabTitle;
     private syncDefaultActionPopupTabTitle;
     private syncDefaultActionPopupTabTitleForHost;
@@ -552,6 +673,7 @@ export declare class FlowSurfacesService {
         openViewActionName?: string;
         popupTemplateHostUid?: string;
         popupActionContext?: FlowSurfaceTemplateListPopupActionContext;
+        popupTemplateTreeCache?: FlowSurfacePopupTemplateTreeCache;
         skipHiddenPopupHostEnsure?: boolean;
     }): Promise<{
         uid: any;
@@ -560,6 +682,7 @@ export declare class FlowSurfacesService {
         uid: any;
         updated: string[];
     }>;
+    private normalizeLegacyDataScopeFilterWrapperForUpdateSettings;
     private syncCalendarPopupPropsForUpdateSettings;
     private replaceExplicitPopupStepParamSubtreesForUpdateSettings;
     private normalizePopupStepParamReplacementForUpdateSettings;
@@ -567,8 +690,11 @@ export declare class FlowSurfacesService {
     private syncDefaultSortingForUpdateSettings;
     private syncKanbanPopupPropsForUpdateSettings;
     private syncFilterActionSettingsForUpdateSettings;
+    private resolveFilterActionDefaultFilterRequiredFieldCount;
     private syncMirroredStepParamsForUpdateSettings;
+    private syncCreatedFieldWrapperTitleFieldStepParams;
     private syncUpdateActionAssignedValuesForUpdateSettings;
+    private syncActionTriggerWorkflowsForUpdateSettings;
     private syncUpdateActionAssignFormItems;
     private ensureUpdateActionAssignForm;
     private ensureUpdateActionAssignFormGrid;
@@ -591,12 +717,97 @@ export declare class FlowSurfacesService {
     private resolveSqlChartPreview;
     private syncChartCardRuntimeStepParamsForUpdateSettings;
     private stripLegacyChartCardChromeForUpdateSettings;
+    getEventFlowMeta(values: Record<string, any>, options?: {
+        transaction?: any;
+    }): Promise<{
+        target: {
+            uid: string;
+            kind: import("./types").FlowSurfaceContainerKind;
+            use: any;
+        };
+        flowRegistry: any;
+        events: {
+            direct: string[];
+            object: string[];
+        };
+        phases: {
+            supported: string[];
+            defaultAdd: string;
+        };
+        eventBindings: {
+            [k: string]: {
+                stepKeys: string[] | "*";
+            };
+        };
+        stepActions: {
+            use: string;
+            defaultParamsSchema: {
+                type: string;
+                properties: {
+                    code: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        }[];
+        vars: Record<string, import("./types").FlowSurfaceContextVarInfo>;
+        fingerprint: string;
+        writeCapabilities: {
+            defaultAddPhase: string;
+            fineGrainedActions: string[];
+            fullReplaceAction: string;
+        };
+    }>;
+    addEventFlow(values: Record<string, any>, options?: {
+        transaction?: any;
+    }): Promise<{
+        flowRegistry: Record<string, any>;
+        fingerprint: string;
+        flow?: any;
+        uid: any;
+        key: string;
+    }>;
+    setEventFlow(values: Record<string, any>, options?: {
+        transaction?: any;
+    }): Promise<{
+        flowRegistry: Record<string, any>;
+        fingerprint: string;
+        flow?: any;
+        uid: any;
+        key: string;
+    }>;
+    removeEventFlow(values: Record<string, any>, options?: {
+        transaction?: any;
+    }): Promise<{
+        flowRegistry: Record<string, any>;
+        fingerprint: string;
+        flow?: any;
+        uid: any;
+        key: string;
+    }>;
     setEventFlows(values: Record<string, any>, options?: {
         transaction?: any;
     }): Promise<{
         uid: string;
         flowRegistry: any;
+        fingerprint: string;
     }>;
+    private resolveEventFlowTarget;
+    private getEventFlowRegistry;
+    private buildEventFlowFingerprint;
+    private assertEventFlowFingerprint;
+    private normalizeEventFlowKey;
+    private normalizeEventFlowPhase;
+    private normalizeAddEventFlowPhase;
+    private normalizeAddEventFlowInput;
+    private normalizeEventFlowObject;
+    private persistEventFlowRegistry;
+    private buildEventFlowWriteResult;
+    private assertFlowRegistryRunJsAuthoringPayload;
+    private buildEventFlowBindingMeta;
+    private buildEventFlowStepActionsMeta;
     setLayout(values: Record<string, any>, options?: {
         transaction?: any;
     }): Promise<{
@@ -667,6 +878,30 @@ export declare class FlowSurfacesService {
     private resolveTreeChildrenAssociationName;
     private isTreeCollection;
     private isTreeTableEnabled;
+    private resolveTreeTableCreationContext;
+    private isTreeTableViewRecordAction;
+    private isUnreadableTreeTableTitleFieldName;
+    private isDirectTreeTableTitleFieldName;
+    private isUsableTreeTableTitleField;
+    private resolveTreeTableDirectField;
+    private pushTreeTableTitleFieldNameCandidate;
+    private resolveTreeTableTitleFieldNames;
+    private isRecoverableTreeTableTitleFieldError;
+    private getTableColumns;
+    private findTableFieldColumn;
+    private getTableActionsColumn;
+    private buildTreeTableTitlePopup;
+    private ensureTreeTableTitleFieldClickDefaults;
+    private ensureTreeTableTitleFieldColumn;
+    private getFirstUsableExistingTreeTableTitleColumn;
+    private removeTreeTableViewRecordActions;
+    private ensureTreeTableAddChildRecordAction;
+    private reorderTreeTableTitleAndActionsColumns;
+    private findPreviousComposeFieldResultForColumn;
+    private buildComposeFieldResultFromTableColumn;
+    private buildComposeRecordActionResultFromNode;
+    private refreshComposeTreeTableBlockResult;
+    private applyTreeTableCreatedBlockDefaults;
     private resolveAddChildOwnerNode;
     private resolveAddChildOwnerResourceContext;
     private resolveOwnerCollectionForAddChild;
@@ -679,9 +914,9 @@ export declare class FlowSurfacesService {
     private materializeRecordActionContainer;
     private runBatchCreate;
     private buildInjectedComposeDefaultActionSpec;
+    private backfillComposeActionPayloadDefaultFilter;
     private normalizeComposeFieldsLayout;
     private normalizeComposeFieldsLayoutCell;
-    private buildAutoComposeFieldsLayoutRow;
     private buildAutoComposeFieldsLayout;
     private normalizeComposeFieldGroups;
     private applyDefaultActionsForCreatedBlock;
@@ -729,6 +964,7 @@ export declare class FlowSurfacesService {
     private configureFieldNode;
     private normalizeFilterActionDefaultFilterValue;
     private normalizeActionAssignValues;
+    private normalizeActionTriggerWorkflows;
     private configureActionNode;
     private normalizeActionPanelActionChanges;
     private buildFieldCatalog;
@@ -857,7 +1093,9 @@ export declare class FlowSurfacesService {
     private validateCalendarBlockState;
     private validateKanbanBlockState;
     private resolveFieldDefinition;
+    private resolveRelationTitleFieldErrorOptionsForNode;
     private getAssociationDefaultTitleFieldName;
+    private tryGetAssociationDefaultTitleFieldName;
     private getAssociationTitleFieldTargetCollection;
     private buildAssociationTitleFieldUnavailableMessage;
     private resolveTitleFieldSyncDecision;