@nocobase/plugin-flow-engine 2.1.0-alpha.20 → 2.1.0-alpha.21

package/dist/server/flow-surfaces/support-matrix.d.ts

@@ -6,7 +6,7 @@
  * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
-export type FormalFlowSurfaceBlockKey = 'js-block' | 'table' | 'create-form' | 'edit-form' | 'details' | 'filter-form' | 'list' | 'grid-card' | 'markdown' | 'iframe' | 'map' | 'chart' | 'comments' | 'action-panel';
+export type FormalFlowSurfaceBlockKey = 'js-block' | 'table' | 'calendar' | 'create-form' | 'edit-form' | 'details' | 'filter-form' | 'list' | 'grid-card' | 'markdown' | 'iframe' | 'map' | 'chart' | 'comments' | 'action-panel';
 export type FlowSurfaceBlockSupportEntry = {
     key: string;
     formalKey?: FormalFlowSurfaceBlockKey;
@@ -19,8 +19,11 @@ export type FlowSurfaceBlockSupportEntry = {
     readbackSupported: boolean;
     createSupported: boolean;
 };
+export type FormalFlowSurfaceBlockSupportEntry = FlowSurfaceBlockSupportEntry & {
+    formalKey: FormalFlowSurfaceBlockKey;
+};
 export declare const FLOW_SURFACE_BLOCK_SUPPORT_MATRIX: FlowSurfaceBlockSupportEntry[];
-export declare const FORMAL_FLOW_SURFACE_BLOCK_SUPPORT_MATRIX: FlowSurfaceBlockSupportEntry[];
+export declare const FORMAL_FLOW_SURFACE_BLOCK_SUPPORT_MATRIX: FormalFlowSurfaceBlockSupportEntry[];
 export declare const FORMAL_FLOW_SURFACE_BLOCK_KEYS: FormalFlowSurfaceBlockKey[];
 export declare const FLOW_SURFACE_BLOCK_SUPPORT_BY_KEY: Map<string, FlowSurfaceBlockSupportEntry>;
 export declare const FLOW_SURFACE_BLOCK_SUPPORT_BY_USE: Map<string, FlowSurfaceBlockSupportEntry>;

package/dist/server/flow-surfaces/support-matrix.js

@@ -60,6 +60,18 @@ const FLOW_SURFACE_BLOCK_SUPPORT_MATRIX = [
     readbackSupported: true,
     createSupported: true
   },
+  {
+    key: "calendar",
+    formalKey: "calendar",
+    label: "Calendar",
+    modelUse: "CalendarBlockModel",
+    ownerPlugin: "@nocobase/plugin-calendar",
+    topLevelAddable: true,
+    formalBuiltin: true,
+    fixtureCaptured: true,
+    readbackSupported: true,
+    createSupported: true
+  },
   {
     key: "createForm",
     formalKey: "create-form",
@@ -216,9 +228,10 @@ const FLOW_SURFACE_BLOCK_SUPPORT_MATRIX = [
     createSupported: true
   }
 ];
-const FORMAL_FLOW_SURFACE_BLOCK_SUPPORT_MATRIX = FLOW_SURFACE_BLOCK_SUPPORT_MATRIX.filter(
-  (entry) => entry.formalBuiltin
-);
+function hasFormalFlowSurfaceBlockKey(entry) {
+  return entry.formalBuiltin && !!entry.formalKey;
+}
+const FORMAL_FLOW_SURFACE_BLOCK_SUPPORT_MATRIX = FLOW_SURFACE_BLOCK_SUPPORT_MATRIX.filter(hasFormalFlowSurfaceBlockKey);
 const FORMAL_FLOW_SURFACE_BLOCK_KEYS = FORMAL_FLOW_SURFACE_BLOCK_SUPPORT_MATRIX.map(
   (entry) => entry.formalKey
 );

package/dist/server/flow-surfaces/surface-context.js

@@ -47,6 +47,7 @@ var import_approval = require("./approval");
 var import_placement = require("./placement");
 const FILTER_TARGET_BLOCK_USES = /* @__PURE__ */ new Set([
   "TableBlockModel",
+  "CalendarBlockModel",
   "DetailsBlockModel",
   "ListBlockModel",
   "GridCardBlockModel",
@@ -330,7 +331,7 @@ class FlowSurfaceContextResolver {
     var _a;
     const resolved = await this.locator.resolve(target, { transaction });
     const node = resolved.node || await this.repository.findModelById(resolved.uid, { transaction, includeAsyncNode: true });
-    if (["TableBlockModel", "TableActionsColumnModel"].includes(node == null ? void 0 : node.use) || (node == null ? void 0 : node.use) === "ActionPanelBlockModel" || LIST_LIKE_BLOCK_USES.has(node == null ? void 0 : node.use) || LIST_LIKE_ITEM_USES.has(node == null ? void 0 : node.use)) {
+    if (["TableBlockModel", "CalendarBlockModel", "TableActionsColumnModel"].includes(node == null ? void 0 : node.use) || (node == null ? void 0 : node.use) === "ActionPanelBlockModel" || LIST_LIKE_BLOCK_USES.has(node == null ? void 0 : node.use) || LIST_LIKE_ITEM_USES.has(node == null ? void 0 : node.use)) {
       return {
         parentUid: node.uid,
         subKey: "actions",

package/dist/server/flow-surfaces/template-display.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+import type { Database } from '@nocobase/database';
+import type { FlowSurfaceTemplateRow } from './template-service-utils';
+export type TemplateTranslate = (key: string, options?: Record<string, any>) => string;
+export declare function compileTemplateString(value: any, t?: TemplateTranslate): any;
+export declare function resolveFlowTemplateDisplayRow(db: Database, row: FlowSurfaceTemplateRow, options?: {
+    t?: TemplateTranslate;
+    transaction?: any;
+}): Promise<FlowSurfaceTemplateRow>;
+export declare function resolveFlowTemplateDisplayRows(db: Database, rows: FlowSurfaceTemplateRow[], options?: {
+    t?: TemplateTranslate;
+    transaction?: any;
+}): Promise<FlowSurfaceTemplateRow[]>;

package/dist/server/flow-surfaces/template-display.js

@@ -0,0 +1,289 @@
+/**
+ * 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 __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var template_display_exports = {};
+__export(template_display_exports, {
+  compileTemplateString: () => compileTemplateString,
+  resolveFlowTemplateDisplayRow: () => resolveFlowTemplateDisplayRow,
+  resolveFlowTemplateDisplayRows: () => resolveFlowTemplateDisplayRows
+});
+module.exports = __toCommonJS(template_display_exports);
+var import_json_schema = require("@formily/json-schema");
+var import_lodash = __toESM(require("lodash"));
+var import_service_helpers = require("./service-helpers");
+var import_service_utils = require("./service-utils");
+const AUTO_GENERATED_SUFFIX = " (Auto generated)";
+const LEGACY_AUTO_POPUP_PREFIX = "Auto popup ";
+const LEGACY_AUTO_POPUP_DESCRIPTION_PREFIX = "Auto-generated popup template ";
+function getFallbackTranslate() {
+  return (key, options) => key.replace(/\{\{\s*([^}\s]+)\s*\}\}/g, (_match, name) => {
+    const value = options == null ? void 0 : options[name];
+    return import_lodash.default.isUndefined(value) || import_lodash.default.isNull(value) ? "" : String(value);
+  });
+}
+function extractTranslationKey(tokenContent) {
+  var _a;
+  const matched = tokenContent.match(/["'`]([^"'`]+)["'`]/);
+  return ((_a = matched == null ? void 0 : matched[1]) == null ? void 0 : _a.trim()) || "";
+}
+function sanitizePendingTranslationTokens(value) {
+  if (!value.includes("{{")) {
+    return value;
+  }
+  return value.replace(/\{\{\s*t\(([\s\S]*?)\)\s*\}\}/g, (_match, tokenContent) => extractTranslationKey(tokenContent));
+}
+function compileTemplateString(value, t) {
+  if (typeof value !== "string" || !value) {
+    return value;
+  }
+  try {
+    const compiled = import_json_schema.Schema.compile(value, { t: t || getFallbackTranslate() });
+    if (typeof compiled === "string") {
+      return sanitizePendingTranslationTokens(compiled).trim();
+    }
+    return compiled;
+  } catch (error) {
+    return sanitizePendingTranslationTokens(value).trim();
+  }
+}
+function inferPopupDefaultTypeFromTargetTree(node) {
+  var _a, _b, _c, _d;
+  const popupPage = (0, import_service_utils.getSingleNodeSubModel)((_a = node == null ? void 0 : node.subModels) == null ? void 0 : _a.page);
+  const popupTab = import_lodash.default.castArray(((_b = popupPage == null ? void 0 : popupPage.subModels) == null ? void 0 : _b.tabs) || [])[0];
+  const popupGrid = (0, import_service_utils.getSingleNodeSubModel)((_c = popupTab == null ? void 0 : popupTab.subModels) == null ? void 0 : _c.grid);
+  const popupBlock = (0, import_service_utils.getNodeSubModelList)((_d = popupGrid == null ? void 0 : popupGrid.subModels) == null ? void 0 : _d.items)[0];
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "DetailsBlockModel") {
+    return "view";
+  }
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "EditFormModel") {
+    return "edit";
+  }
+  if ((popupBlock == null ? void 0 : popupBlock.use) === "CreateFormModel") {
+    return "addNew";
+  }
+  return "generic";
+}
+function getPopupLabelKey(defaultType) {
+  switch (defaultType) {
+    case "addNew":
+      return "Popup for Add New";
+    case "edit":
+      return "Popup for Edit";
+    case "view":
+      return "Popup for Details";
+    default:
+      return "popup";
+  }
+}
+function getAutoGeneratedDisplaySuffix(t) {
+  const translate = t || getFallbackTranslate();
+  return ` (${translate("Auto generated")})`;
+}
+function isAutoGeneratedPopupTemplateName(name) {
+  return name.endsWith(AUTO_GENERATED_SUFFIX) || name.startsWith(LEGACY_AUTO_POPUP_PREFIX);
+}
+function isAutoGeneratedPopupTemplateDescription(description) {
+  return description.startsWith(LEGACY_AUTO_POPUP_DESCRIPTION_PREFIX) || description.startsWith("Automatically generated popup template for ");
+}
+function buildAutoGeneratedActionPopupMetadata(input) {
+  const translate = input.t || getFallbackTranslate();
+  const popupLabel = translate(getPopupLabelKey(input.popupType));
+  return {
+    name: `${input.collectionLabel} ${popupLabel}${getAutoGeneratedDisplaySuffix(input.t)}`,
+    description: translate(
+      'Automatically generated popup template for collection "{{collectionLabel}}" ({{popupLabel}}).',
+      {
+        collectionLabel: input.collectionLabel,
+        popupLabel
+      }
+    )
+  };
+}
+function buildAutoGeneratedAssociationPopupMetadata(input) {
+  const translate = input.t || getFallbackTranslate();
+  const popupLabel = translate(getPopupLabelKey(input.popupType));
+  return {
+    name: `${input.sourceCollectionLabel} -> ${input.associationFieldLabel} ${popupLabel}${getAutoGeneratedDisplaySuffix(input.t)}`,
+    description: translate(
+      'Automatically generated popup template for relation field "{{associationFieldLabel}}" in collection "{{sourceCollectionLabel}}", targeting "{{targetCollectionLabel}}" ({{popupLabel}}).',
+      {
+        associationFieldLabel: input.associationFieldLabel,
+        sourceCollectionLabel: input.sourceCollectionLabel,
+        targetCollectionLabel: input.targetCollectionLabel,
+        popupLabel
+      }
+    )
+  };
+}
+async function getTargetTree(db, targetUid, transaction) {
+  var _a;
+  const normalizedTargetUid = String(targetUid || "").trim();
+  if (!normalizedTargetUid) {
+    return null;
+  }
+  const repo = (_a = db.getCollection("flowModels")) == null ? void 0 : _a.repository;
+  if (!repo) {
+    return null;
+  }
+  return repo.findModelById(normalizedTargetUid, {
+    transaction,
+    includeAsyncNode: true
+  });
+}
+function getCollection(db, dataSourceKey, collectionName) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const normalizedDataSourceKey = dataSourceKey || "main";
+  const mainCollection = normalizedDataSourceKey === "main" ? (_a = db.getCollection) == null ? void 0 : _a.call(db, collectionName) : null;
+  if (mainCollection) {
+    return mainCollection;
+  }
+  const dataSourceManager = ((_b = db.app) == null ? void 0 : _b.dataSourceManager) || db.dataSourceManager;
+  const ds = ((_c = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _c.call(dataSourceManager, normalizedDataSourceKey)) || ((_e = (_d = dataSourceManager == null ? void 0 : dataSourceManager.dataSources) == null ? void 0 : _d.get) == null ? void 0 : _e.call(_d, normalizedDataSourceKey));
+  return ((_g = (_f = ds == null ? void 0 : ds.collectionManager) == null ? void 0 : _f.getCollection) == null ? void 0 : _g.call(_f, collectionName)) || ((_h = db.getCollection) == null ? void 0 : _h.call(db, collectionName));
+}
+function getAssociationField(collection, associationName) {
+  var _a;
+  const normalized = String(associationName || "").trim();
+  if (!normalized) {
+    return null;
+  }
+  const fieldName = normalized.split(".").slice(-1)[0];
+  return ((_a = collection == null ? void 0 : collection.getField) == null ? void 0 : _a.call(collection, fieldName)) || null;
+}
+function parseAssociationSource(associationName) {
+  const normalized = String(associationName || "").trim();
+  if (!normalized || !normalized.includes(".")) {
+    return null;
+  }
+  const parts = normalized.split(".").filter(Boolean);
+  if (parts.length < 2) {
+    return null;
+  }
+  return {
+    sourceCollectionName: parts[0],
+    associationFieldName: parts[parts.length - 1]
+  };
+}
+async function buildAutoGeneratedPopupMetadata(db, row, t, transaction) {
+  var _a, _b;
+  const targetTree = await getTargetTree(db, row.targetUid, transaction);
+  const popupType = inferPopupDefaultTypeFromTargetTree(targetTree);
+  const dataSourceKey = String(row.dataSourceKey || "main").trim() || "main";
+  const collectionName = String(row.collectionName || "").trim();
+  const associationName = String(row.associationName || "").trim();
+  const collection = getCollection(db, dataSourceKey, collectionName);
+  const collectionLabel = String(
+    compileTemplateString((0, import_service_helpers.getCollectionTitle)(collection) || collectionName, t) || ""
+  ).trim();
+  if (associationName) {
+    const associationSource = parseAssociationSource(associationName);
+    const sourceCollectionName = (associationSource == null ? void 0 : associationSource.sourceCollectionName) || collectionName;
+    const sourceCollection = getCollection(db, dataSourceKey, sourceCollectionName) || collection;
+    const associationField = getAssociationField(sourceCollection, associationName) || ((_a = sourceCollection == null ? void 0 : sourceCollection.getField) == null ? void 0 : _a.call(sourceCollection, (associationSource == null ? void 0 : associationSource.associationFieldName) || ""));
+    const targetCollectionName = String((associationField == null ? void 0 : associationField.target) || ((_b = associationField == null ? void 0 : associationField.options) == null ? void 0 : _b.target) || collectionName || "").trim() || collectionName;
+    const targetCollection = getCollection(db, dataSourceKey, targetCollectionName) || collection;
+    const sourceCollectionLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getCollectionTitle)(sourceCollection) || (0, import_service_helpers.getCollectionName)(sourceCollection) || sourceCollectionName,
+        t
+      ) || ""
+    ).trim();
+    const associationFieldLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getFieldTitle)(associationField) || (0, import_service_helpers.getFieldName)(associationField) || (associationSource == null ? void 0 : associationSource.associationFieldName) || "",
+        t
+      ) || ""
+    ).trim();
+    const targetCollectionLabel = String(
+      compileTemplateString(
+        (0, import_service_helpers.getCollectionTitle)(targetCollection) || (0, import_service_helpers.getCollectionName)(targetCollection) || targetCollectionName,
+        t
+      ) || ""
+    ).trim();
+    if (sourceCollectionLabel && associationFieldLabel && targetCollectionLabel) {
+      return buildAutoGeneratedAssociationPopupMetadata({
+        popupType,
+        sourceCollectionLabel,
+        associationFieldLabel,
+        targetCollectionLabel,
+        t
+      });
+    }
+  }
+  if (collectionLabel) {
+    return buildAutoGeneratedActionPopupMetadata({
+      popupType,
+      collectionLabel,
+      t
+    });
+  }
+  return null;
+}
+async function resolveFlowTemplateDisplayRow(db, row, options = {}) {
+  const plainRow = typeof (row == null ? void 0 : row.toJSON) === "function" ? row.toJSON() : row;
+  if (!plainRow) {
+    return plainRow;
+  }
+  const t = options.t || getFallbackTranslate();
+  const nextRow = {
+    ...plainRow,
+    name: compileTemplateString(plainRow.name, t),
+    description: compileTemplateString(plainRow.description, t)
+  };
+  const hasAutoGeneratedName = isAutoGeneratedPopupTemplateName(String(nextRow.name || "").trim());
+  const hasAutoGeneratedDescription = isAutoGeneratedPopupTemplateDescription(String(nextRow.description || "").trim());
+  if (String(nextRow.type || "").trim() !== "popup" || !hasAutoGeneratedName && !hasAutoGeneratedDescription) {
+    return nextRow;
+  }
+  const rewritten = await buildAutoGeneratedPopupMetadata(db, nextRow, t, options.transaction);
+  if (!rewritten) {
+    return nextRow;
+  }
+  return {
+    ...nextRow,
+    name: hasAutoGeneratedName ? rewritten.name : nextRow.name,
+    description: hasAutoGeneratedDescription ? rewritten.description : nextRow.description
+  };
+}
+async function resolveFlowTemplateDisplayRows(db, rows, options = {}) {
+  return Promise.all(rows.map((row) => resolveFlowTemplateDisplayRow(db, row, options)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileTemplateString,
+  resolveFlowTemplateDisplayRow,
+  resolveFlowTemplateDisplayRows
+});

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

@@ -58,6 +58,7 @@ export type FlowSurfaceDomainContract = {
     wildcard?: boolean;
     mergeStrategy: FlowSurfaceMergeStrategy;
     schema: Record<string, any>;
+    pathSchemas?: Record<string, Record<string, any>>;
     groups?: Record<string, FlowSurfaceDomainGroupContract>;
 };
 export type FlowSurfaceEventCapabilities = {

package/dist/swagger/flow-surfaces.d.ts

@@ -563,6 +563,12 @@ declare const _default: {
                         type: string;
                         additionalProperties: boolean;
                     };
+                    defaultFilter: {
+                        allOf: {
+                            $ref: string;
+                        }[];
+                        description: string;
+                    };
                     fields: {
                         type: string;
                         items: {
@@ -2170,6 +2176,12 @@ declare const _default: {
                         type: string;
                         additionalProperties: boolean;
                     };
+                    defaultFilter: {
+                        allOf: {
+                            $ref: string;
+                        }[];
+                        description: string;
+                    };
                     fields: {
                         type: string;
                         items: {
@@ -2326,6 +2338,108 @@ declare const _default: {
                 };
                 additionalProperties: boolean;
             };
+            FlowSurfaceApplyBlueprintDefaultFieldGroup: {
+                type: string;
+                required: string[];
+                description: string;
+                properties: {
+                    key: {
+                        type: string;
+                    };
+                    title: {
+                        type: string;
+                    };
+                    fields: {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceApplyBlueprintDefaultPopupName: {
+                type: string;
+                required: string[];
+                description: string;
+                properties: {
+                    name: {
+                        type: string;
+                    };
+                    description: {
+                        type: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceApplyBlueprintDefaultPopupActionMap: {
+                type: string;
+                properties: {
+                    view: {
+                        $ref: string;
+                    };
+                    addNew: {
+                        $ref: string;
+                    };
+                    edit: {
+                        $ref: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceApplyBlueprintDefaultPopups: {
+                type: string;
+                description: string;
+                properties: {
+                    view: {
+                        $ref: string;
+                    };
+                    addNew: {
+                        $ref: string;
+                    };
+                    edit: {
+                        $ref: string;
+                    };
+                    associations: {
+                        type: string;
+                        additionalProperties: {
+                            $ref: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceApplyBlueprintDefaultCollection: {
+                type: string;
+                description: string;
+                properties: {
+                    fieldGroups: {
+                        type: string;
+                        minItems: number;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    popups: {
+                        $ref: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceApplyBlueprintDefaults: {
+                type: string;
+                description: string;
+                properties: {
+                    collections: {
+                        type: string;
+                        additionalProperties: {
+                            $ref: string;
+                        };
+                    };
+                };
+                additionalProperties: boolean;
+            };
             FlowSurfaceApplyBlueprintRequest: {
                 type: string;
                 required: string[];
@@ -2348,6 +2462,9 @@ declare const _default: {
                     page: {
                         $ref: string;
                     };
+                    defaults: {
+                        $ref: string;
+                    };
                     tabs: {
                         type: string;
                         minItems: number;
@@ -3088,6 +3205,15 @@ declare const _default: {
                         type: string;
                         additionalProperties: boolean;
                     };
+                    defaultFilter: {
+                        allOf: {
+                            $ref: string;
+                        }[];
+                        description: string;
+                    };
+                    defaultActionSettings: {
+                        $ref: string;
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -3391,6 +3517,15 @@ declare const _default: {
                         type: string;
                         additionalProperties: boolean;
                     };
+                    defaultFilter: {
+                        allOf: {
+                            $ref: string;
+                        }[];
+                        description: string;
+                    };
+                    defaultActionSettings: {
+                        $ref: string;
+                    };
                 };
                 additionalProperties: boolean;
             };
@@ -4862,6 +4997,31 @@ declare const _default: {
                     items: any[];
                 };
             };
+            FlowSurfaceDefaultFilterActionSettings: {
+                type: string;
+                properties: {
+                    filterableFieldNames: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    defaultFilter: {
+                        $ref: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+            FlowSurfaceDefaultActionSettings: {
+                type: string;
+                description: string;
+                properties: {
+                    filter: {
+                        $ref: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
             FlowSurfaceEventCapabilities: {
                 type: string;
                 properties: {