@nocobase/plugin-flow-engine 2.1.0-beta.43 → 2.1.0-beta.45

package/dist/server/flow-surfaces/runjs-authoring/inspect.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 { FlowSurfaceErrorItemInput } from '../errors';
+import type { RunJsAuthoringInspectionInput } from './types';
+import type { RunJsAuthoringContext, RunJsSourceBudget } from './internal-types';
+export declare function inspectRunJsAuthoringCodeForWrite(input: RunJsAuthoringInspectionInput, budget?: RunJsSourceBudget, context?: RunJsAuthoringContext): FlowSurfaceErrorItemInput[];
+export declare function inspectRunJsAuthoringCode(input: RunJsAuthoringInspectionInput, context?: RunJsAuthoringContext): FlowSurfaceErrorItemInput[];

package/dist/server/flow-surfaces/runjs-authoring/inspect.js

@@ -0,0 +1,149 @@
+/**
+ * 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 inspect_exports = {};
+__export(inspect_exports, {
+  inspectRunJsAuthoringCode: () => inspectRunJsAuthoringCode,
+  inspectRunJsAuthoringCodeForWrite: () => inspectRunJsAuthoringCodeForWrite
+});
+module.exports = __toCommonJS(inspect_exports);
+var import_constants = require("./runtime/constants");
+var import_surface = require("./runtime/surface");
+var import_parser = require("./ast/parser");
+var import_errors = require("./runtime/errors");
+var import_source_budget = require("./runtime/source-budget");
+var import_scan = require("./scan");
+var import_validators = require("./validators");
+function inspectRunJsAuthoringCodeForWrite(input, budget, context = {}) {
+  const limitResult = (0, import_source_budget.collectRunJsSourceLimitErrors)(input, budget);
+  if (limitResult.skipInspection || limitResult.errors.length) {
+    return limitResult.errors;
+  }
+  return inspectRunJsAuthoringCode(input, context);
+}
+function inspectRunJsAuthoringCode(input, context = {}) {
+  const errors = [];
+  const source = String(input.code || "");
+  const modelUse = (0, import_surface.normalizeText)(input.modelUse);
+  const surface = (0, import_surface.normalizeText)(input.surface);
+  const surfaceStyle = (0, import_surface.resolveSurfaceStyle)(input);
+  const sourceLimitResult = (0, import_source_budget.collectRunJsSourceLimitErrors)(input);
+  if (sourceLimitResult.skipInspection || sourceLimitResult.errors.length) {
+    return sourceLimitResult.errors;
+  }
+  if (surface && !import_constants.SURFACE_STYLE_BY_ID[surface]) {
+    errors.push(
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: "unknown-surface-stop",
+        message: `flowSurfaces authoring ${input.path} references unknown RunJS surface '${surface}'`,
+        modelUse,
+        surface,
+        index: 0,
+        source
+      })
+    );
+    return errors;
+  }
+  if (modelUse && !import_constants.KNOWN_MODEL_USES.has(modelUse)) {
+    errors.push(
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: "unknown-model-stop",
+        message: `flowSurfaces authoring ${input.path} references unknown JS model '${modelUse}'`,
+        modelUse,
+        surface,
+        index: 0,
+        source
+      })
+    );
+    return errors;
+  }
+  if (surface && modelUse && import_constants.SURFACE_ALLOWED_MODEL_USES[surface] && !import_constants.SURFACE_ALLOWED_MODEL_USES[surface].has(modelUse)) {
+    errors.push(
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: "unknown-model-stop",
+        message: `flowSurfaces authoring ${input.path} model '${modelUse}' is not supported by RunJS surface '${surface}'`,
+        modelUse,
+        surface,
+        index: 0,
+        source
+      })
+    );
+    return errors;
+  }
+  if (!surfaceStyle) {
+    errors.push(
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: modelUse ? "unknown-model-stop" : "unknown-surface-stop",
+        message: `flowSurfaces authoring ${input.path} cannot resolve a RunJS validation surface`,
+        modelUse,
+        surface,
+        index: 0,
+        source
+      })
+    );
+    return errors;
+  }
+  const parseResult = (0, import_parser.parseRunJsAuthoringAst)(source);
+  if (parseResult.error) {
+    return [
+      (0, import_errors.buildRunJsAuthoringError)({
+        path: input.path,
+        repairClass: "syntax-stop",
+        ruleId: "runjs-syntax-invalid",
+        message: `flowSurfaces authoring ${input.path} has invalid JavaScript syntax: ${parseResult.error.message}`,
+        modelUse,
+        surface,
+        index: parseResult.error.index,
+        source,
+        details: {
+          syntaxMessage: parseResult.error.message
+        }
+      })
+    ];
+  }
+  const scan = (0, import_scan.scanJavaScriptSource)(source, parseResult.ast, context, modelUse);
+  errors.push(
+    ...(0, import_validators.collectRunJsInspectionErrors)({
+      context,
+      input,
+      modelUse,
+      scan,
+      source,
+      surface,
+      surfaceStyle
+    })
+  );
+  return (0, import_errors.dedupeErrors)(errors).slice(0, import_constants.MAX_RUNJS_ERRORS_PER_SOURCE);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  inspectRunJsAuthoringCode,
+  inspectRunJsAuthoringCodeForWrite
+});

package/dist/server/flow-surfaces/runjs-authoring/internal-types.d.ts

@@ -0,0 +1,333 @@
+/**
+ * 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.
+ */
+export type FlowSurfaceAuthoringWriteAction = 'applyBlueprint' | 'compose' | 'addBlock' | 'addBlocks' | 'configure';
+export type RunJsAuthoringContext = {
+    authoringActionName?: FlowSurfaceAuthoringWriteAction;
+    applyBlueprintScriptAssets?: Record<string, any>;
+    currentCollectionName?: string;
+    currentDataSourceKey?: string;
+    currentNode?: any;
+    getCollection?: (dataSourceKey: string, collectionName: string) => any;
+    hostBlockType?: string;
+    hostCollectionName?: string;
+    hostDataSourceKey?: string;
+    runJsSourceBudget?: RunJsSourceBudget;
+};
+export type RunJsCodeSource = {
+    code: string;
+    path: string;
+};
+export type PlainRecord = Record<string, any>;
+export type SourceRange = {
+    start: number;
+    end: number;
+};
+export type SourceBinding = SourceRange & {
+    declarationStart?: number;
+    executionScope?: SourceRange;
+    name: string;
+};
+export type StringLiteralBinding = SourceBinding & {
+    value: string;
+};
+export type StaticStringBinding = StringLiteralBinding;
+export type StaticFilterValueBinding = SourceBinding & {
+    declarationStart: number;
+    executionScope: SourceRange;
+    valueNode: any;
+};
+export type AstIdentifierWrite = {
+    alwaysRunsInExecutionScope: boolean;
+    executionScope: SourceRange;
+    index: number;
+    name: string;
+};
+export type AstStaticObjectAliasCopy = SourceRange & {
+    declarationStart: number;
+    executionScope: SourceRange;
+    name: string;
+    sourceName: string;
+};
+export type ReactComponentAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    name: string;
+};
+export type ReactAsyncComponentBinding = SourceRange & {
+    capability: string;
+    component: string;
+    declarationStart?: number;
+    name: string;
+};
+export type ReactCreateElementAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    name: string;
+};
+export type ReactNamespaceAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+    precedenceStart?: number;
+};
+export type ReactDefaultAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+    precedenceStart?: number;
+};
+export type AstCapabilityAlias = SourceRange & {
+    capability: string;
+    name: string;
+    precedenceStart?: number;
+};
+export declare const AST_DYNAMIC_MEMBER_ALIAS = "[*]";
+export type InvalidReactRuntimeBinding = SourceRange & {
+    binding: string;
+    capability: string;
+    declarationStart?: number;
+    index: number;
+    ruleId: 'runjs-react-default-alias-forbidden';
+};
+export type FlowResourceAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    name: string;
+};
+export type FlowResourceInstanceType = 'unknown' | 'FlowResource' | 'APIResource' | 'SingleRecordResource' | 'MultiRecordResource' | 'SQLResource';
+export type AstFlowResourceAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+    resourceType: FlowResourceInstanceType;
+};
+export type AstFlowResourceSource = {
+    capability: string;
+    index: number;
+    resourceType: FlowResourceInstanceType;
+};
+export type AstRunJsResourceState = {
+    capability: string;
+    collectionName?: string;
+    dataSourceKey: string;
+    resourceType: FlowResourceInstanceType;
+};
+export type CtxLibMemberCaseMismatch = {
+    accessKind: 'bracket' | 'destructure' | 'member';
+    capability: string;
+    expectedCapability: string;
+    expectedMember: string;
+    index: number;
+    member: string;
+};
+export type InvalidCtxLibMemberAccess = {
+    accessKind: 'bracket' | 'destructure' | 'member';
+    capability: string;
+    index: number;
+    library: string;
+    member: string;
+    ruleId: 'runjs-ctx-libs-member-unknown';
+    suggestedImport?: string;
+};
+export type CallArgumentSource = SourceRange & {
+    source: string;
+};
+export type ResourceCallInReactHook = {
+    capability: string;
+    hook: string;
+    index: number;
+};
+export type SharedCtxResourceCallInFunction = {
+    capability: string;
+    functionName?: string;
+    index: number;
+};
+export type RunJsSourceBudget = {
+    count: number;
+    countLimitReported?: boolean;
+    totalLength: number;
+    totalLimitReported?: boolean;
+};
+export type RunJsAstInspection = {
+    unknownBareGlobals: Array<{
+        index: number;
+        name: string;
+        suggestedCapability?: string;
+    }>;
+    invalidApiResourceCalls: Array<{
+        index: number;
+        match: string;
+        matchIndex?: number;
+        method: string;
+    }>;
+    invalidResourceActionCalls: Array<{
+        actionName: string;
+        allowedActions?: string[];
+        capability: string;
+        collectionName?: string;
+        dataSourceKey?: string;
+        endpoint?: string;
+        index: number;
+        invalidReason: string;
+        resourceType?: FlowResourceInstanceType;
+        suggestedMethod?: string;
+    }>;
+    invalidCtxApiMemberAccesses: Array<{
+        capability: string;
+        index: number;
+        match?: string;
+        matchIndex?: number;
+        member?: string;
+        ruleId: string;
+    }>;
+    invalidCtxNonFunctionCalls: Array<{
+        capability: string;
+        index: number;
+        member: string;
+        ruleId: 'runjs-ctx-member-not-callable';
+    }>;
+    invalidCtxLibMemberAccesses: InvalidCtxLibMemberAccess[];
+    invalidResourceTypeCalls: Array<{
+        capability: string;
+        expression?: string;
+        index: number;
+        resourceType?: string;
+        ruleId: string;
+    }>;
+    invalidFlowResourceListCalls: Array<{
+        capability: string;
+        index: number;
+    }>;
+    invalidFlowResourceMethodCalls: Array<{
+        capability: string;
+        index: number;
+        method: string;
+        resourceType?: FlowResourceInstanceType;
+        suggestedMethod?: string;
+    }>;
+    invalidResourceFilterCalls: Array<{
+        availableFields?: string[];
+        capability: string;
+        collectionName?: string;
+        dataSourceKey?: string;
+        fieldInterface?: string;
+        fieldPath?: string;
+        fieldType?: string;
+        invalidShape?: string;
+        index: number;
+        invalidReason?: string;
+        invalidValue?: any;
+        message: string;
+        operator?: string;
+        repairExample?: Record<string, any>;
+        repairHint?: string;
+        resourceType?: FlowResourceInstanceType;
+        ruleId: string;
+        unsupportedKeys?: string[];
+        suggestedOperator?: string;
+        suggestedValue?: any;
+        examples?: Record<string, any>;
+    }>;
+    nestedRunjsCalls: Array<{
+        capability: string;
+        index: number;
+    }>;
+    invalidReactRuntimeBindings: InvalidReactRuntimeBinding[];
+    reactAsyncComponentReferences: Array<{
+        capability: string;
+        component: string;
+        index: number;
+    }>;
+    reactComponentCtxRenderCalls: Array<{
+        capability: string;
+        component: string;
+        index: number;
+    }>;
+    sharedCtxResourceCallsInFunctions: SharedCtxResourceCallInFunction[];
+    topLevelReachableCtxRenderCalls: Array<{
+        capability: string;
+        index: number;
+    }>;
+};
+export type CtxMethodAlias = SourceRange & {
+    capability: string;
+    method: string;
+    name: string;
+};
+export type CtxRootAlias = SourceRange & {
+    capability: 'ctx';
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+};
+export type CtxNonFunctionRootAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    member: string;
+    name: string;
+};
+export type CtxLibsRootAlias = SourceRange & {
+    capability: 'ctx.libs';
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+};
+export type CtxLibAlias = SourceRange & {
+    capability: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    library: string;
+    name: string;
+};
+export type CtxApiCapability = 'ctx.api' | 'ctx.api.auth' | 'ctx.api.request' | 'ctx.api.resource' | `ctx.api.auth.${string}`;
+export type CtxApiAlias = SourceRange & {
+    capability: CtxApiCapability;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+};
+export type CtxApiResourceHandleAlias = SourceRange & {
+    calleeSource: string;
+    dataSourceKey?: string;
+    declarationStart?: number;
+    executionScope: SourceRange;
+    name: string;
+    resourceName?: string;
+};
+export type CtxApiResourceMethodAlias = SourceRange & {
+    declarationStart?: number;
+    executionScope: SourceRange;
+    method: string;
+    name: string;
+};
+export type CtxApiResourceAliases = {
+    handles: CtxApiResourceHandleAlias[];
+    methods: CtxApiResourceMethodAlias[];
+};
+export type AstIdentifierBinding = SourceRange & {
+    declarationStart?: number;
+    name: string;
+    unavailableRanges?: SourceRange[];
+};
+export type AstFunctionBinding = SourceRange & {
+    declarationStart: number;
+    functionNode: any;
+    hoisted: boolean;
+    name: string;
+    scopeStart: number;
+};
+export type AstCtxRenderCall = {
+    args: any[];
+    capability: string;
+    index: number;
+};

package/dist/server/flow-surfaces/runjs-authoring/internal-types.js

@@ -0,0 +1,36 @@
+/**
+ * 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 internal_types_exports = {};
+__export(internal_types_exports, {
+  AST_DYNAMIC_MEMBER_ALIAS: () => AST_DYNAMIC_MEMBER_ALIAS
+});
+module.exports = __toCommonJS(internal_types_exports);
+const AST_DYNAMIC_MEMBER_ALIAS = "[*]";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AST_DYNAMIC_MEMBER_ALIAS
+});

package/dist/server/flow-surfaces/runjs-authoring/rules.js

@@ -45,6 +45,7 @@ var import_resource_runtime_contract_stop = require("./resource-runtime-contract
 var import_source_limit_stop = require("./source-limit-stop");
 var import_switch_to_resource_api = require("./switch-to-resource-api");
 var import_syntax_stop = require("./syntax-stop");
+var import_unknown_global_stop = require("./unknown-global-stop");
 var import_unknown_model_stop = require("./unknown-model-stop");
 var import_unknown_surface_stop = require("./unknown-surface-stop");
 var import_value_surface_forbids_render = require("./value-surface-forbids-render");
@@ -61,6 +62,7 @@ const RUNJS_AUTHORING_RULES = [
   import_render_top_level_function_wrapper.renderTopLevelFunctionWrapperRule,
   import_render_unreachable_render_call.renderUnreachableRenderCallRule,
   import_blocked_global_stop.blockedGlobalStopRule,
+  import_unknown_global_stop.unknownGlobalStopRule,
   import_blocked_capability_reroute.blockedCapabilityRerouteRule,
   import_react_runtime_contract_stop.reactRuntimeContractStopRule,
   import_resource_runtime_contract_stop.resourceRuntimeContractStopRule,

package/dist/server/flow-surfaces/runjs-authoring/runtime/constants.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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 { FlowResourceInstanceType } from '../internal-types';
+import type { RunJsAuthoringRepairClass, RunJsAuthoringSurfaceStyle } from '../types';
+export declare const RENDER_MODEL_USES: Set<string>;
+export declare const ACTION_MODEL_USES: Set<string>;
+export declare const VALUE_MODEL_USES: Set<string>;
+export declare const KNOWN_MODEL_USES: Set<string>;
+export declare const PUBLIC_BLOCK_TYPE_BY_MODEL_USE: Record<string, string>;
+export declare const SURFACE_STYLE_BY_ID: Record<string, RunJsAuthoringSurfaceStyle>;
+export declare const SURFACE_ALLOWED_MODEL_USES: Record<string, Set<string>>;
+export declare const ALLOWED_CTX_ROOTS: Set<string>;
+export declare const CHART_CTX_ROOTS: Set<string>;
+export declare const BLOCKED_CTX_CAPABILITIES: Record<string, {
+    capability: string;
+    reroute: string;
+}>;
+export declare const FORBIDDEN_BARE_GLOBALS: Set<string>;
+export declare const RUNJS_ALLOWED_BARE_GLOBALS: Set<string>;
+export declare const RUNJS_ALLOWED_BARE_GLOBALS_BY_MODEL_USE: Record<string, Set<string>>;
+export declare const NON_METHOD_CALL_KEYWORDS: Set<string>;
+export declare const ACTION_TYPE_ALIASES: Map<string, string>;
+export declare const REACT_HOOK_NAMES: string[];
+export declare const REACT_HOOK_PATTERN: string;
+export declare const RUNJS_RESOURCE_ACTION_PATTERN = "(?:list|get|create|update|destroy)";
+export declare const MAX_RUNJS_SOURCE_LENGTH: number;
+export declare const MAX_RUNJS_TOTAL_SOURCE_LENGTH: number;
+export declare const MAX_RUNJS_SOURCES_PER_REQUEST = 100;
+export declare const MAX_RUNJS_ERRORS_PER_SOURCE = 20;
+export declare const RUNJS_SUPPORTED_FILTER_OPERATORS: Set<string>;
+export declare const RUNJS_DATE_FILTER_OPERATORS: Set<string>;
+export declare const RUNJS_UNSUPPORTED_DATE_RANGE_VALUE_KEYS: Set<string>;
+export declare const FLOW_RESOURCE_CLASS_NAMES: Set<string>;
+export declare const INIT_RESOURCE_CLASS_NAMES: Set<string>;
+export declare const AST_CTX_METHOD_NAMES: Set<string>;
+export declare const RUNJS_CTX_NON_FUNCTION_ROOTS: Set<string>;
+export declare const RUNJS_CTX_NON_FUNCTION_ROOTS_BY_MODEL_USE: Record<string, Set<string>>;
+export declare const REACT_NODE_COMPONENT_PROP_NAMES: Set<string>;
+export declare const CANONICAL_CTX_LIB_MEMBERS: string[];
+export declare const CTX_LIB_MEMBER_BY_LOWERCASE: Map<string, string>;
+export declare const RUNJS_CTX_LIB_ANTD_ALLOWED_MEMBERS: Set<string>;
+export declare const RUNJS_CTX_LIB_ALLOWED_MEMBERS_BY_LIBRARY: Map<string, Set<string>>;
+export declare const RUNJS_CTX_API_ALLOWED_MEMBERS: Set<string>;
+export declare const RUNJS_CTX_API_AUTH_ALLOWED_MEMBERS: Set<string>;
+export declare const RUNJS_RESOURCE_METHODS: Set<string>;
+export declare const RUNJS_COLLECTION_RESOURCE_ACTIONS: Set<string>;
+export declare const RUNJS_COLLECTION_RESOURCE_ACTION_ALIASES: Map<string, string[]>;
+export declare const RUNJS_RESOURCE_ENDPOINT_ACTION_PATTERN = "[A-Za-z_$][\\w$-]*";
+export declare const FLOW_RESOURCE_BASE_METHODS: Set<string>;
+export declare const API_RESOURCE_METHODS: Set<string>;
+export declare const RECORD_RESOURCE_METHODS: Set<string>;
+export declare const RUNJS_RESOURCE_CHAINABLE_STATE_METHODS: Set<string>;
+export declare const MULTI_RECORD_RESOURCE_METHODS: Set<string>;
+export declare const SINGLE_RECORD_RESOURCE_METHODS: Set<string>;
+export declare const SQL_RESOURCE_METHODS: Set<string>;
+export declare const FLOW_RESOURCE_METHODS_BY_TYPE: Record<Exclude<FlowResourceInstanceType, 'unknown'>, Set<string>>;
+export declare const UNKNOWN_FLOW_RESOURCE_METHODS: Set<string>;
+export declare const FLOW_RESOURCE_METHOD_SUGGESTIONS: Map<string, string>;
+export declare const CONTEXT_FIRST_REPAIR_CLASSES: Set<RunJsAuthoringRepairClass>;
+export declare const RUNJS_FIX_AND_RETRY_INSTRUCTION = "Do not skip this JS/RunJS step. Fix the error and retry the same write. If the response contains errors[], fix every listed error in one payload revision before retrying. Do not remove, defer, or replace the JS/RunJS capability to bypass validation.";
+export declare const RUNJS_CONTEXT_AND_RETRY_INSTRUCTION = "Do not skip this JS/RunJS step. Resolve the blocking context/problem first, then retry the same write. If the response contains errors[], fix every listed error in one payload revision before retrying. Do not remove, defer, or replace the JS/RunJS capability to bypass validation.";