@octaviaflow/flow-rules 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -43,30 +43,63 @@ __export(exports_src, {
   ActionStatus: () => ActionStatus,
   ActionType: () => ActionType,
   AggregateFunction: () => AggregateFunction,
+  AiAgentConfig: () => AiAgentConfig,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
   CONFIG_CONTRACTS: () => CONFIG_CONTRACTS,
+  CONNECTOR_EVENT_ENTITIES: () => CONNECTOR_EVENT_ENTITIES,
   ConditionConfig: () => ConditionConfig,
+  ConnectorTriggerConfig: () => ConnectorTriggerConfig,
+  CsvActionConfig: () => CsvActionConfig,
   DATABASE_CONNECTOR_IDS: () => DATABASE_CONNECTOR_IDS,
+  DROPBOX_OPERATIONS: () => DROPBOX_OPERATIONS,
   DebugConfig: () => DebugConfig,
+  DropboxActionConfig: () => DropboxActionConfig,
+  EVENT_CAPABLE_CONNECTOR_IDS: () => EVENT_CAPABLE_CONNECTOR_IDS,
   EdgeType: () => EdgeType,
   EmailConfig: () => EmailConfig,
+  ExcelActionConfig: () => ExcelActionConfig,
+  FILE_ACTION_FORMATS: () => FILE_ACTION_FORMATS,
+  FILE_ACTION_MODES: () => FILE_ACTION_MODES,
+  FILE_ACTION_OUTPUT_FORMATS: () => FILE_ACTION_OUTPUT_FORMATS,
+  FILE_ACTION_SOURCES: () => FILE_ACTION_SOURCES,
+  FILE_EDIT_DESTINATIONS: () => FILE_EDIT_DESTINATIONS,
+  FILE_EDIT_MATCH_OPS: () => FILE_EDIT_MATCH_OPS,
+  FILE_EDIT_OPERATIONS: () => FILE_EDIT_OPERATIONS,
+  FILE_EDIT_SCHEMA: () => FILE_EDIT_SCHEMA,
+  FILE_EDIT_SOURCES: () => FILE_EDIT_SOURCES,
+  FILE_FORMAT_OPERATIONS: () => FILE_FORMAT_OPERATIONS,
+  FTP_OPERATIONS: () => FTP_OPERATIONS,
   FieldType: () => FieldType,
+  FileActionConfig: () => FileActionConfig,
   ForEachConfig: () => ForEachConfig,
+  FtpActionConfig: () => FtpActionConfig,
+  GOOGLE_DRIVE_OPERATIONS: () => GOOGLE_DRIVE_OPERATIONS,
+  GoogleDriveActionConfig: () => GoogleDriveActionConfig,
+  GroupConfig: () => GroupConfig,
+  IDP_EXTRACT_STRATEGIES: () => IDP_EXTRACT_STRATEGIES,
+  IdpExtractConfig: () => IdpExtractConfig,
   JoinType: () => JoinType,
+  JsonActionConfig: () => JsonActionConfig,
   LogicalOperator: () => LogicalOperator,
   MAPPING_FUNCTIONS: () => MAPPING_FUNCTIONS,
   MAPPING_FUNCTION_SPECS: () => MAPPING_FUNCTION_SPECS,
   MAX_STEP_CONFIG_BYTES: () => MAX_STEP_CONFIG_BYTES,
   ManualTriggerConfig: () => ManualTriggerConfig,
   NodeStatus: () => NodeStatus,
+  ONEDRIVE_OPERATIONS: () => ONEDRIVE_OPERATIONS,
+  OneDriveActionConfig: () => OneDriveActionConfig,
   QueryMode: () => QueryMode,
   QueryType: () => QueryType,
+  S3ActionConfig: () => S3ActionConfig,
+  S3_OPERATIONS: () => S3_OPERATIONS,
   STORAGE_CONNECTOR_IDS: () => STORAGE_CONNECTOR_IDS,
   SortDirection: () => SortDirection,
+  StorageActionConfig: () => StorageActionConfig,
   TRANSFORM_OPERATIONS: () => TRANSFORM_OPERATIONS,
   TransformConfig: () => TransformConfig,
   USER_FUNCTION_PREFIX: () => USER_FUNCTION_PREFIX,
   VariablesConfig: () => VariablesConfig,
+  XmlActionConfig: () => XmlActionConfig,
   actionsRegistry: () => actionsRegistry,
   buildPathOptions: () => buildPathOptions,
   collectArrayPaths: () => collectArrayPaths,
@@ -79,6 +112,8 @@ __export(exports_src, {
   contractVocabularyDrift: () => contractVocabularyDrift,
   declaredKeys: () => declaredKeys,
   emailDefinition: () => emailDefinition,
+  fileEditErrors: () => fileEditErrors,
+  fileFormatErrors: () => fileFormatErrors,
   flattenNestedWorkflow: () => flattenNestedWorkflow,
   generateConnectionsFromSteps: () => generateConnectionsFromSteps,
   generateEdgeId: () => generateEdgeId,
@@ -89,20 +124,25 @@ __export(exports_src, {
   getActionsByCategory: () => getActionsByCategory,
   getAllActions: () => getAllActions,
   getEdgeValidationStatus: () => getEdgeValidationStatus,
+  getEntitiesForConnector: () => getEntitiesForConnector,
   getNodeConfigStatus: () => getNodeConfigStatus,
   getNodeValidationStatus: () => getNodeValidationStatus,
   getStorageProvider: () => getStorageProvider,
   inferSchemaFromSample: () => inferSchemaFromSample,
   isEditorPrivateKey: () => isEditorPrivateKey,
+  isEventCapableConnector: () => isEventCapableConnector,
   isMappingFunction: () => isMappingFunction,
   isQueryableConnector: () => isQueryableConnector,
   mappingTransformFunctionName: () => mappingTransformFunctionName,
   migrateDelayConfig: () => migrateDelayConfig,
   queryDefinition: () => queryDefinition,
   storageConfigKeys: () => storageConfigKeys,
+  storageOperations: () => storageOperations,
+  summarizeConnectorTriggerEvents: () => summarizeConnectorTriggerEvents,
   transformConnectionToEdge: () => transformConnectionToEdge,
   transformFlowToWorkflow: () => transformFlowToWorkflow,
   transformStepToNode: () => transformStepToNode,
+  validateConnectorTriggerEvents: () => validateConnectorTriggerEvents,
   validateEdge: () => validateEdge,
   validateFlowData: () => validateFlowData,
   validateNode: () => validateNode,
@@ -555,7 +595,7 @@ var connectorTriggerDefinition = {
         key: "events",
         label: "Events",
         type: "json" /* JSON */,
-        description: "Entity/operation pairs to subscribe to",
+        description: 'Entity/operation pairs to subscribe to, as [{ "entity": "contact", "operations": ["Create", "Update"] }]. ' + "This is what registers the trigger — the platform derives the flow's connector subscription from it. " + "Entity and operation names are per connector (describe_action_type lists them); a name outside that list never fires.",
         validation: { required: true }
       }
     ]
@@ -1704,7 +1744,7 @@ var csvActionDefinition = {
   color: "#198038",
   inputSchema: {
     fields: [
-      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (CSV → Records)", value: "parse" }, { label: "Generate (Records → CSV)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (CSV → Records)", value: "parse" }, { label: "Generate (Records → CSV)", value: "generate" }, { label: "Edit existing file", value: "edit" }], defaultValue: "parse", validation: { required: true } },
       { key: "content", label: "CSV Content", type: "string" /* String */, description: "Paste CSV content or use FX token from upstream step" },
       { key: "delimiter", label: "Delimiter", type: "select" /* Select */, options: [{ label: "Comma (,)", value: "," }, { label: "Semicolon (;)", value: ";" }, { label: "Tab", value: "\t" }, { label: "Pipe (|)", value: "|" }], defaultValue: "," },
       { key: "headerRow", label: "Header Row", type: "number" /* Number */, description: "Row number containing column headers (default: 1)", defaultValue: 1 },
@@ -1743,7 +1783,7 @@ var jsonActionDefinition = {
   color: "#f1c21b",
   inputSchema: {
     fields: [
-      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (JSON → Records)", value: "parse" }, { label: "Generate (Records → JSON)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (JSON → Records)", value: "parse" }, { label: "Generate (Records → JSON)", value: "generate" }, { label: "Edit existing file", value: "edit" }], defaultValue: "parse", validation: { required: true } },
       { key: "format", label: "Format", type: "select" /* Select */, options: [{ label: "JSON (array)", value: "json" }, { label: "JSONL (one object per line)", value: "jsonl" }], defaultValue: "json" },
       { key: "content", label: "JSON Content", type: "string" /* String */, description: "Paste JSON content or use FX token from upstream step" },
       { key: "prettyPrint", label: "Pretty Print", type: "boolean" /* Boolean */, description: "Format output with indentation", defaultValue: true },
@@ -1780,7 +1820,7 @@ var xmlActionDefinition = {
   color: "#e65100",
   inputSchema: {
     fields: [
-      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (XML → Records)", value: "parse" }, { label: "Generate (Records → XML)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (XML → Records)", value: "parse" }, { label: "Generate (Records → XML)", value: "generate" }, { label: "Edit existing file", value: "edit" }], defaultValue: "parse", validation: { required: true } },
       { key: "content", label: "XML Content", type: "string" /* String */, description: "Paste XML or use FX token" },
       { key: "rootElement", label: "Root Element", type: "string" /* String */, description: "Root XML element name (for generate)", defaultValue: "data" },
       { key: "rowElement", label: "Row Element", type: "string" /* String */, description: "Element name per record (for generate)", defaultValue: "row" },
@@ -1817,7 +1857,7 @@ var excelActionDefinition = {
   color: "#217346",
   inputSchema: {
     fields: [
-      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (Excel → Records)", value: "parse" }, { label: "Generate (Records → Excel)", value: "generate" }], defaultValue: "parse", validation: { required: true } },
+      { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "Parse (Excel → Records)", value: "parse" }, { label: "Generate (Records → Excel)", value: "generate" }, { label: "Edit existing file", value: "edit" }], defaultValue: "parse", validation: { required: true } },
       { key: "content", label: "Excel File", type: "string" /* String */, description: "S3 key of uploaded Excel file or FX token from upstream" },
       { key: "sheetName", label: "Sheet Name", type: "string" /* String */, description: "Name of sheet to read (default: first sheet)" },
       { key: "headerRow", label: "Header Row", type: "number" /* Number */, description: "Row number containing headers", defaultValue: 1 },
@@ -1855,6 +1895,7 @@ var s3ActionDefinition = {
   color: "#569A31",
   inputSchema: {
     fields: [
+      { key: "connector", label: "S3 Connection", type: "connection" /* Connection */, description: "Select a connected S3 account", validation: { required: true } },
       { key: "operation", label: "Operation", type: "select" /* Select */, options: [{ label: "List Files", value: "list" }, { label: "Upload File", value: "upload" }, { label: "Download File", value: "download" }, { label: "Delete File", value: "delete" }, { label: "Copy File", value: "copy" }, { label: "Move / Rename", value: "move" }, { label: "Get Signed URL", value: "presign" }], defaultValue: "download", validation: { required: true } },
       { key: "bucket", label: "Bucket Name", type: "string" /* String */, description: "S3 bucket name (defaults to the connector’s bucket)" },
       { key: "key", label: "Object Key (Path)", type: "string" /* String */, description: "S3 object key, e.g. data/reports/monthly.csv" },
@@ -2073,7 +2114,8 @@ var storageActionDefinition = {
           { label: "Get signed URL", value: "presign" },
           { label: "Share", value: "share" },
           { label: "Create folder", value: "create_folder" },
-          { label: "Transfer to another connector", value: "transfer" }
+          { label: "Transfer to another connector", value: "transfer" },
+          { label: "Sync folder to another connector", value: "sync" }
         ],
         defaultValue: "download",
         validation: { required: true }
@@ -3974,6 +4016,672 @@ function storageConfigKeys() {
   }
   return [...keys];
 }
+// src/catalog/ai/ai-agent/config.ts
+var AiAgentConfig = {
+  defaults: {
+    agentId: ""
+  },
+  schema: {
+    agentId: { type: "string", required: true, description: "Public id of a saved agent (agt_…)" },
+    input: { type: "text", required: false, description: "The prompt; may reference upstream data with {{ods://…}} tokens. Empty uses the first upstream output." },
+    overrides: { type: "object", required: false, description: "Per-step overrides: model, temperature, topP, maxTokens, reasoningEffort, verbosity, batchSize, instructions, instructionsMode, expectedSchema" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.agentId || typeof config.agentId !== "string")
+      errors.push("Select an agent");
+    if (config.overrides !== undefined && (typeof config.overrides !== "object" || config.overrides === null || Array.isArray(config.overrides))) {
+      errors.push("overrides must be an object");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...AiAgentConfig.defaults, ...userConfig }),
+  getLabel: (config) => config.agentId ? `Agent ${config.agentId}` : "AI Agent"
+};
+// src/catalog/ai/idp-extract/config.ts
+var IDP_EXTRACT_STRATEGIES = ["vision-direct", "auto"];
+var IdpExtractConfig = {
+  defaults: {
+    llmConnectorId: "",
+    model: "",
+    strategy: "vision-direct"
+  },
+  schema: {
+    llmConnectorId: { type: "connection", required: true, description: "AI connector instance (its key and model run the extraction)" },
+    model: { type: "string", required: true, description: "Model id offered by the connector" },
+    expectedSchema: { type: "json", required: false, description: "JSON Schema of the fields to extract; empty extracts every field" },
+    systemPromptOverride: { type: "text", required: false },
+    strategy: { type: "select", required: false, options: IDP_EXTRACT_STRATEGIES }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.llmConnectorId)
+      errors.push("Select an AI connection");
+    if (!config.model)
+      errors.push("Select a model");
+    if (typeof config.expectedSchema === "string" && config.expectedSchema.trim() !== "") {
+      try {
+        JSON.parse(config.expectedSchema);
+      } catch {
+        errors.push("expectedSchema is not valid JSON");
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...IdpExtractConfig.defaults, ...userConfig }),
+  getLabel: (config) => config.model ? `IDP: ${config.model}` : "IDP Extract"
+};
+// src/catalog/logic/group/config.ts
+var GroupConfig = {
+  defaults: {},
+  schema: {},
+  validate: (_config) => ({ valid: true, errors: [] }),
+  merge: (_userConfig) => ({}),
+  getLabel: () => "Group"
+};
+// src/catalog/triggers/connector-trigger/events.ts
+var EVENT_CAPABLE_CONNECTOR_IDS = new Set([
+  "quickbooks_online",
+  "shopify",
+  "hubspot",
+  "salesforce",
+  "google_sheets",
+  "whatsapp"
+]);
+var QBO_ENTITIES = [
+  { entity: "Invoice", supportedOperations: ["Create", "Update", "Delete", "Void", "Emailed"] },
+  { entity: "Customer", supportedOperations: ["Create", "Update", "Delete", "Merge"] },
+  { entity: "Payment", supportedOperations: ["Create", "Update", "Delete", "Void"] },
+  { entity: "Bill", supportedOperations: ["Create", "Update", "Delete", "Void"] },
+  { entity: "Estimate", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "SalesReceipt", supportedOperations: ["Create", "Update", "Delete", "Void", "Emailed"] },
+  { entity: "CreditMemo", supportedOperations: ["Create", "Update", "Delete", "Void", "Emailed"] },
+  { entity: "Vendor", supportedOperations: ["Create", "Update", "Delete", "Merge"] },
+  { entity: "Item", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "Account", supportedOperations: ["Create", "Update", "Delete", "Merge"] },
+  { entity: "JournalEntry", supportedOperations: ["Create", "Update", "Delete", "Void"] },
+  { entity: "PurchaseOrder", supportedOperations: ["Create", "Update", "Delete"] }
+];
+var SALESFORCE_ENTITIES = [
+  { entity: "Lead", supportedOperations: ["Create", "Update", "Delete", "Undelete"] },
+  { entity: "Account", supportedOperations: ["Create", "Update", "Delete", "Undelete"] },
+  { entity: "Contact", supportedOperations: ["Create", "Update", "Delete", "Undelete"] },
+  { entity: "Opportunity", supportedOperations: ["Create", "Update", "Delete", "Undelete"] },
+  { entity: "Case", supportedOperations: ["Create", "Update", "Delete", "Undelete"] }
+];
+var HUBSPOT_ENTITIES = [
+  { entity: "contact", supportedOperations: ["Create", "Update", "Delete", "Merge", "Restore", "AssociationChange"] },
+  { entity: "company", supportedOperations: ["Create", "Update", "Delete", "Merge", "Restore", "AssociationChange"] },
+  { entity: "deal", supportedOperations: ["Create", "Update", "Delete", "Merge", "Restore", "AssociationChange"] },
+  { entity: "ticket", supportedOperations: ["Create", "Update", "Delete", "Merge", "Restore", "AssociationChange"] },
+  { entity: "product", supportedOperations: ["Create", "Update", "Delete", "Restore"] },
+  { entity: "line_item", supportedOperations: ["Create", "Update", "Delete", "Restore"] },
+  { entity: "lead", supportedOperations: ["Create", "Update", "Delete", "Restore"] },
+  { entity: "quote", supportedOperations: ["Create", "Update", "Delete", "Restore"] },
+  { entity: "call", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "email", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "meeting_event", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "task", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "note", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "order", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "cart", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "invoice", supportedOperations: ["Create", "Update", "Delete"] }
+];
+var SHOPIFY_ENTITIES = [
+  { entity: "Order", supportedOperations: ["Create", "Update", "Paid", "Fulfilled", "Cancelled"] },
+  { entity: "Product", supportedOperations: ["Create", "Update"] },
+  { entity: "Customer", supportedOperations: ["Create", "Update"] }
+];
+var GOOGLE_SHEETS_ENTITIES = [
+  { entity: "Row", supportedOperations: ["Create", "Update", "Delete"] },
+  { entity: "Sheet", supportedOperations: ["Create", "Update"] }
+];
+var WHATSAPP_ENTITIES = [
+  { entity: "Message", supportedOperations: ["Received"] }
+];
+var CONNECTOR_EVENT_ENTITIES = {
+  quickbooks_online: QBO_ENTITIES,
+  salesforce: SALESFORCE_ENTITIES,
+  hubspot: HUBSPOT_ENTITIES,
+  shopify: SHOPIFY_ENTITIES,
+  google_sheets: GOOGLE_SHEETS_ENTITIES,
+  whatsapp: WHATSAPP_ENTITIES
+};
+function getEntitiesForConnector(connectorId) {
+  return CONNECTOR_EVENT_ENTITIES[connectorId] ?? [];
+}
+function isEventCapableConnector(connectorId) {
+  return EVENT_CAPABLE_CONNECTOR_IDS.has(connectorId) && getEntitiesForConnector(connectorId).length > 0;
+}
+function summarizeConnectorTriggerEvents(connectorName, events) {
+  const eventCount = events.reduce((acc, ev) => acc + ev.operations.length, 0);
+  if (eventCount === 0)
+    return connectorName;
+  const noun = eventCount === 1 ? "event" : "events";
+  return `${connectorName} · ${eventCount} ${noun}`;
+}
+function validateConnectorTriggerEvents(connectorId, events) {
+  const entities = getEntitiesForConnector(connectorId);
+  if (!isEventCapableConnector(connectorId)) {
+    return `"${connectorId}" does not emit events a trigger can subscribe to. ` + `Event-capable connectors: ${[...EVENT_CAPABLE_CONNECTOR_IDS].join(", ")}.`;
+  }
+  if (!Array.isArray(events) || events.length === 0) {
+    return 'events must be a non-empty array of { "entity": string, "operations": string[] }.';
+  }
+  const seen = new Set;
+  for (const ev of events) {
+    const entity = ev?.entity;
+    const operations = ev?.operations;
+    if (typeof entity !== "string" || !entity) {
+      return 'Each event needs an "entity" (string).';
+    }
+    const known = entities.find((e) => e.entity === entity);
+    if (!known) {
+      const caseHit = entities.find((e) => e.entity.toLowerCase() === entity.toLowerCase());
+      const hint = caseHit ? ` Did you mean "${caseHit.entity}"? Names are case-sensitive.` : "";
+      return `Unknown entity "${entity}" for ${connectorId}.${hint} Entities: ${entities.map((e) => e.entity).join(", ")}.`;
+    }
+    if (seen.has(entity))
+      return `Entity "${entity}" is listed twice — give it one entry with all its operations.`;
+    seen.add(entity);
+    if (!Array.isArray(operations) || operations.length === 0) {
+      return `Event "${entity}" needs a non-empty "operations" array. Operations: ${known.supportedOperations.join(", ")}.`;
+    }
+    for (const op of operations) {
+      if (typeof op !== "string" || !known.supportedOperations.includes(op)) {
+        const caseHit = typeof op === "string" ? known.supportedOperations.find((o) => o.toLowerCase() === op.toLowerCase()) : undefined;
+        const hint = caseHit ? ` Did you mean "${caseHit}"?` : "";
+        return `Unknown operation "${String(op)}" for ${connectorId} ${entity}.${hint} Operations: ${known.supportedOperations.join(", ")}.`;
+      }
+    }
+  }
+  return null;
+}
+
+// src/catalog/triggers/connector-trigger/config.ts
+var ConnectorTriggerConfig = {
+  defaults: {
+    connectorInstanceId: ""
+  },
+  schema: {
+    connectorInstanceId: { type: "connection", required: true, description: "The connected app instance that emits the events" },
+    events: { type: "array", required: true, description: "[{ entity, operations }] — exact names from the connector vocabulary; registers the trigger" },
+    connectorId: { type: "string", required: false, description: "Connector type of the instance (hubspot, google_sheets, …)" },
+    connectorName: { type: "string", required: false, description: "Display name of the instance" },
+    subscribed: { type: "boolean", required: false, description: "Registration snapshot" },
+    eventCount: { type: "number", required: false, description: "Registration snapshot" },
+    summary: { type: "string", required: false, description: "Registration snapshot shown on the canvas" },
+    sheetFileId: { type: "string", required: false, description: "Google Sheets: spreadsheet id" },
+    sheetFileLabel: { type: "string", required: false, description: "Google Sheets: spreadsheet name" },
+    sheetName: { type: "string", required: false, description: "Google Sheets: tab name" },
+    sheetKeyColumn: { type: "string", required: false, description: "Google Sheets: row key column" },
+    description: { type: "string", required: false, description: "Added to the trigger output when set" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connectorInstanceId)
+      errors.push("Select a connected app");
+    if (config.events !== undefined && !Array.isArray(config.events)) {
+      errors.push("events must be an array of { entity, operations }");
+    } else if (config.connectorId && Array.isArray(config.events) && config.events.length > 0) {
+      const why = validateConnectorTriggerEvents(config.connectorId, config.events);
+      if (why)
+        errors.push(why);
+    }
+    if (config.connectorId === "google_sheets") {
+      if (!config.sheetFileId)
+        errors.push("Select a spreadsheet");
+      if (!config.sheetName)
+        errors.push("Select a sheet");
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...ConnectorTriggerConfig.defaults, ...userConfig }),
+  getLabel: (config) => config.summary || config.connectorName || "Connector Trigger"
+};
+// src/catalog/storage/fileEditContract.ts
+var FILE_FORMAT_OPERATIONS = ["parse", "generate", "edit"];
+var FILE_EDIT_OPERATIONS = ["append", "update", "upsert", "set_fields"];
+var FILE_EDIT_MATCH_OPS = ["=", "!=", ">", "<", ">=", "<=", "contains"];
+var FILE_EDIT_DESTINATIONS = ["new", "in_place"];
+var FILE_EDIT_SOURCES = ["inline", "s3", "url"];
+var FILE_EDIT_SCHEMA = {
+  editOperation: { type: "select", required: false, options: FILE_EDIT_OPERATIONS, description: "How the file is edited: append rows, update rows by key, upsert, or set fields on matching rows" },
+  keyField: { type: "string", required: false, description: "Match key column for update / upsert" },
+  mergeUpdate: { type: "boolean", required: false, description: "false replaces the whole matched row; default merges" },
+  matchField: { type: "string", required: false, description: "set_fields: column the row filter reads" },
+  matchOp: { type: "select", required: false, options: FILE_EDIT_MATCH_OPS, description: 'set_fields: comparison; "=" by default' },
+  matchValue: { type: "string", required: false, description: "set_fields: value compared against" },
+  setFields: { type: "object", required: false, description: "set_fields: { column: newValue } applied to matching rows" },
+  destination: { type: "select", required: false, options: FILE_EDIT_DESTINATIONS, description: '"new" writes an edited copy (default); "in_place" overwrites an S3 source' },
+  outputFileName: { type: "string", required: false, description: 'Name of the edited copy when destination is "new"' },
+  source: { type: "select", required: false, options: FILE_EDIT_SOURCES, description: "Where the file to edit comes from; inferred from content when absent" },
+  s3Key: { type: "string", required: false, description: 'source "s3": platform-bucket key of the file to edit' },
+  url: { type: "url", required: false, description: 'source "url": the file to edit is fetched from here' }
+};
+function fileEditErrors(config) {
+  const errors = [];
+  if (config.operation !== "edit")
+    return errors;
+  const op = config.editOperation ?? "append";
+  if (!FILE_EDIT_OPERATIONS.includes(op))
+    errors.push(`Unknown edit operation "${op}"`);
+  if ((op === "update" || op === "upsert") && !config.keyField)
+    errors.push(`File edit "${op}" needs a Match key field`);
+  return errors;
+}
+function fileFormatErrors(config) {
+  const errors = [];
+  if (config.operation !== undefined && config.operation !== "" && !FILE_FORMAT_OPERATIONS.includes(config.operation)) {
+    errors.push(`Unknown operation "${config.operation}" — use parse, generate or edit`);
+  }
+  return [...errors, ...fileEditErrors(config)];
+}
+// src/catalog/storage/csv-action/config.ts
+var CsvActionConfig = {
+  defaults: {
+    operation: "parse",
+    delimiter: ",",
+    headerRow: 1,
+    includeHeader: true,
+    fileName: "export.csv"
+  },
+  schema: {
+    operation: { type: "select", required: true, options: FILE_FORMAT_OPERATIONS, description: "parse (CSV → records), generate (records → CSV) or edit an existing file" },
+    content: { type: "text", required: false, description: "CSV text, or an FX token from an upstream step" },
+    delimiter: { type: "select", required: false, options: [",", ";", "\t", "|"] },
+    headerRow: { type: "number", required: false, min: 1, description: "1-based row that holds the column headers" },
+    encoding: { type: "string", required: false, description: "Text encoding (utf-8 by default)" },
+    includeHeader: { type: "boolean", required: false, description: "generate: write the header row" },
+    fileName: { type: "string", required: false, description: "generate: name of the produced file" },
+    ...FILE_EDIT_SCHEMA
+  },
+  validate: (config) => {
+    const errors = fileFormatErrors(config);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...CsvActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `CSV: ${config.operation || "parse"}`
+};
+// src/catalog/storage/json-action/config.ts
+var JsonActionConfig = {
+  defaults: {
+    operation: "parse",
+    format: "json",
+    prettyPrint: true,
+    fileName: "export.json"
+  },
+  schema: {
+    operation: { type: "select", required: true, options: FILE_FORMAT_OPERATIONS, description: "parse (JSON → records), generate (records → JSON) or edit an existing file" },
+    format: { type: "select", required: false, options: ["json", "jsonl"], description: "json (array) or jsonl (one object per line)" },
+    content: { type: "text", required: false, description: "JSON text, or an FX token from an upstream step" },
+    prettyPrint: { type: "boolean", required: false, description: "generate: indent the output" },
+    fileName: { type: "string", required: false, description: "generate: name of the produced file" },
+    jsonl: { type: "boolean", required: false, description: "edit: treat the file as JSONL" },
+    ...FILE_EDIT_SCHEMA
+  },
+  validate: (config) => {
+    const errors = fileFormatErrors(config);
+    const format = config.format;
+    if (format !== undefined && format !== "" && !["json", "jsonl"].includes(format)) {
+      errors.push(`Unknown format "${format}" — use json or jsonl`);
+    }
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...JsonActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `JSON: ${config.operation || "parse"}`
+};
+// src/catalog/storage/xml-action/config.ts
+var XmlActionConfig = {
+  defaults: {
+    operation: "parse",
+    rootElement: "data",
+    rowElement: "row",
+    fileName: "export.xml"
+  },
+  schema: {
+    operation: { type: "select", required: true, options: FILE_FORMAT_OPERATIONS, description: "parse (XML → records), generate (records → XML) or edit an existing file" },
+    content: { type: "text", required: false, description: "XML text, or an FX token from an upstream step" },
+    rootElement: { type: "string", required: false, description: "generate: root element name" },
+    rowElement: { type: "string", required: false, description: "Element that holds one record" },
+    fileName: { type: "string", required: false, description: "generate: name of the produced file" },
+    ...FILE_EDIT_SCHEMA
+  },
+  validate: (config) => {
+    const errors = fileFormatErrors(config);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...XmlActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `XML: ${config.operation || "parse"}`
+};
+// src/catalog/storage/excel-action/config.ts
+var ExcelActionConfig = {
+  defaults: {
+    operation: "parse",
+    headerRow: 1,
+    fileName: "export.xlsx"
+  },
+  schema: {
+    operation: { type: "select", required: true, options: FILE_FORMAT_OPERATIONS, description: "parse (Excel → records), generate (records → Excel) or edit an existing file" },
+    content: { type: "text", required: false, description: "Platform-bucket key of the workbook, base64 bytes, or an FX token from an upstream step" },
+    sheetName: { type: "string", required: false, description: "Sheet to read; the first sheet when absent" },
+    headerRow: { type: "number", required: false, min: 1, description: "1-based row that holds the column headers" },
+    fileName: { type: "string", required: false, description: "generate: name of the produced file" },
+    ...FILE_EDIT_SCHEMA
+  },
+  validate: (config) => {
+    const errors = fileFormatErrors(config);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...ExcelActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `Excel: ${config.operation || "parse"}`
+};
+// src/catalog/storage/file-action/config.ts
+var FILE_ACTION_MODES = ["parse", "generate", "convert", "edit"];
+var FILE_ACTION_SOURCES = ["inline", "s3", "url", "previous_step", "upload"];
+var FILE_ACTION_FORMATS = ["auto", "csv", "tsv", "json", "jsonl", "xml", "excel"];
+var FILE_ACTION_OUTPUT_FORMATS = ["csv", "json", "excel", "xml", "tsv"];
+var FileActionConfig = {
+  defaults: {
+    mode: "parse",
+    source: "inline",
+    format: "auto"
+  },
+  schema: {
+    ...FILE_EDIT_SCHEMA,
+    mode: { type: "select", required: true, options: FILE_ACTION_MODES, description: "parse, generate, convert or edit" },
+    operation: { type: "select", required: false, options: FILE_ACTION_MODES, description: "Alias of mode; read first when both are set" },
+    source: { type: "select", required: false, options: FILE_ACTION_SOURCES, description: "Where the file comes from (inline by default)" },
+    format: { type: "select", required: false, options: FILE_ACTION_FORMATS, description: "File format; auto-detected from the name, then the content" },
+    inlineContent: { type: "text", required: false, description: 'source "inline": the text (base64 for Excel)' },
+    content: { type: "text", required: false, description: "Alias of inlineContent" },
+    outputFormat: { type: "select", required: false, options: FILE_ACTION_OUTPUT_FORMATS, description: "generate / convert: format to write" },
+    outputFileName: { type: "string", required: false, description: "generate / convert: name of the produced file" },
+    fileName: { type: "string", required: false, description: "Name used to detect the format" },
+    encoding: { type: "string", required: false },
+    delimiter: { type: "string", required: false, description: "CSV / TSV delimiter" },
+    headerRow: { type: "number", required: false, min: 1 },
+    rowElement: { type: "string", required: false, description: "XML element that holds one record" },
+    sheetName: { type: "string", required: false, description: "Excel sheet to read" },
+    includeHeader: { type: "boolean", required: false },
+    options: { type: "json", required: false, description: "Parser options read ahead of the top-level keys" }
+  },
+  validate: (config) => {
+    const errors = [];
+    const mode = config.operation || config.mode;
+    if (mode !== undefined && mode !== "" && !FILE_ACTION_MODES.includes(mode)) {
+      errors.push(`Unknown mode "${mode}" — use parse, generate, convert or edit`);
+    }
+    if (config.source === "upload")
+      errors.push('source "upload" is not supported at run time');
+    errors.push(...fileEditErrors({ ...config, operation: mode, source: undefined }));
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...FileActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `File: ${config.operation || config.mode || "parse"}`
+};
+// src/catalog/storage/storage-action/config.ts
+var FIXED_SCHEMA = {
+  connector: { type: "connection", required: true, description: "Storage connector instance; its provider decides the operations" },
+  operation: { type: "select", required: true, description: "Per provider: list, download, upload, delete, copy, move, presign, share, create_folder, transfer, sync" },
+  outputAs: { type: "string", required: false, description: "Name of this step's output in the run's data bag" },
+  content: { type: "text", required: false, description: "upload: the body" },
+  destConnector: { type: "connection", required: false, description: "transfer / sync: destination connector instance" },
+  destPath: { type: "string", required: false, description: "transfer / sync: destination path; also move / copy destination on path-based providers" },
+  sourceIsDirectory: { type: "boolean", required: false, description: "transfer: copy a folder recursively" },
+  cursor: { type: "json", required: false, description: "sync: walk cursor threaded by a cursor ForEach ({{$item.cursor}})" },
+  fileBudget: { type: "number", required: false, min: 1, description: "sync: files per pass" },
+  timeBudgetMs: { type: "number", required: false, min: 1, description: "sync: milliseconds per pass" },
+  fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+  filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" },
+  bucket: { type: "string", required: false, description: "S3 / GCS: overrides the connector's bucket" },
+  container: { type: "string", required: false, description: "Azure: overrides the connector's container" },
+  region: { type: "string", required: false, description: "S3: overrides the connector's region" }
+};
+var EXTRA_TYPE = {
+  string: "string",
+  number: "number",
+  select: "select",
+  boolean: "boolean"
+};
+function extraField(f) {
+  const field = { type: EXTRA_TYPE[f.type] ?? "string", required: false };
+  if (f.type === "select" && f.options)
+    field.options = f.options.map((o) => o.value);
+  if (f.label)
+    field.description = f.label;
+  return field;
+}
+function storageOperations() {
+  const seen = new Set;
+  for (const provider of Object.values(STORAGE_PROVIDERS)) {
+    for (const op of provider.operations)
+      seen.add(op.value);
+  }
+  return [...seen];
+}
+function buildSchema() {
+  const schema = { ...FIXED_SCHEMA };
+  schema.operation = { ...schema.operation, options: storageOperations() };
+  const pathKey = (key, label) => {
+    if (!schema[key])
+      schema[key] = { type: "string", required: false, description: label };
+    const name = `${key}Name`;
+    if (!schema[name])
+      schema[name] = { type: "string", required: false, description: `Display name of the item picked for ${key}` };
+  };
+  for (const provider of Object.values(STORAGE_PROVIDERS)) {
+    for (const op of provider.operations) {
+      if (op.path)
+        pathKey(op.path.key, op.path.label);
+      if (op.dest)
+        pathKey(op.dest.key, op.dest.label);
+      for (const f of op.fields ?? []) {
+        if (!schema[f.key])
+          schema[f.key] = extraField(f);
+      }
+    }
+  }
+  return schema;
+}
+var StorageActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "download"
+  },
+  schema: buildSchema(),
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select a storage connector");
+    if (!config.operation)
+      errors.push("Select an operation");
+    else if (!storageOperations().includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    if (config.operation === "transfer" || config.operation === "sync") {
+      if (!config.destConnector)
+        errors.push("Select a destination connector");
+      if (!config.path)
+        errors.push(config.operation === "transfer" ? "Select a source path" : "Select a source folder");
+    }
+    if (config.fileBudget !== undefined && typeof config.fileBudget !== "number")
+      errors.push("fileBudget must be a number");
+    if (config.timeBudgetMs !== undefined && typeof config.timeBudgetMs !== "number")
+      errors.push("timeBudgetMs must be a number");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...StorageActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `Storage: ${config.operation || "download"}`
+};
+// src/catalog/storage/s3-action/config.ts
+var S3_OPERATIONS = ["list", "download", "upload", "delete", "copy", "move", "presign"];
+var S3ActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "download",
+    contentType: "application/octet-stream",
+    expiresIn: 3600,
+    maxKeys: 100
+  },
+  schema: {
+    connector: { type: "connection", required: true, description: "S3 connector instance" },
+    operation: { type: "select", required: true, options: S3_OPERATIONS },
+    bucket: { type: "string", required: false, description: "Overrides the connector's bucket" },
+    region: { type: "string", required: false, description: "Overrides the connector's region" },
+    key: { type: "string", required: false, description: "Object key" },
+    prefix: { type: "string", required: false, description: "list: key prefix" },
+    content: { type: "text", required: false, description: "upload: the body" },
+    contentType: { type: "string", required: false, description: "upload: MIME type" },
+    destBucket: { type: "string", required: false, description: "copy / move: destination bucket" },
+    destKey: { type: "string", required: false, description: "copy / move: destination key" },
+    expiresIn: { type: "number", required: false, min: 1, description: "presign: URL lifetime in seconds" },
+    maxKeys: { type: "number", required: false, min: 1, description: "list: page size" },
+    fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+    filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select an S3 connection");
+    if (config.operation && !S3_OPERATIONS.includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...S3ActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `S3: ${config.operation || "download"}`
+};
+// src/catalog/storage/ftp-action/config.ts
+var FTP_OPERATIONS = ["download", "upload", "list", "delete", "move"];
+var FtpActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "download",
+    ifExists: "overwrite"
+  },
+  schema: {
+    connector: { type: "connection", required: true, description: "FTP / SFTP connector instance" },
+    operation: { type: "select", required: true, options: FTP_OPERATIONS },
+    remotePath: { type: "string", required: false, description: "File or folder path on the server" },
+    content: { type: "text", required: false, description: "upload: the body" },
+    fileName: { type: "string", required: false, description: "upload: file name" },
+    destPath: { type: "string", required: false, description: "move: the new path" },
+    ifExists: { type: "select", required: false, options: ["overwrite", "skip"], description: "upload: when the file exists" },
+    fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+    filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select an FTP/SFTP connection");
+    if (config.operation && !FTP_OPERATIONS.includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...FtpActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `FTP: ${config.operation || "download"}`
+};
+// src/catalog/storage/google-drive-action/config.ts
+var GOOGLE_DRIVE_OPERATIONS = ["upload", "download", "list", "delete", "move", "copy", "share", "create_folder"];
+var GoogleDriveActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "upload",
+    mimeType: "application/octet-stream",
+    shareRole: "reader",
+    pageSize: 50
+  },
+  schema: {
+    connector: { type: "connection", required: true, description: "Google Drive connector instance" },
+    operation: { type: "select", required: true, options: GOOGLE_DRIVE_OPERATIONS },
+    fileId: { type: "string", required: false, description: "download / delete / move / copy / share: the file" },
+    folderId: { type: "string", required: false, description: "upload / list / create_folder: the folder (root when empty)" },
+    folderName: { type: "string", required: false, description: "upload: folder path resolved or created when folderId is empty" },
+    fileName: { type: "string", required: false, description: "upload / copy / create_folder: the name" },
+    content: { type: "text", required: false, description: "upload: the body" },
+    mimeType: { type: "string", required: false, description: "upload: MIME type" },
+    createFolderIfNotExists: { type: "boolean", required: false, description: "upload: create folderName when missing" },
+    destFolderId: { type: "string", required: false, description: "move / copy: destination folder" },
+    shareEmail: { type: "string", required: false, description: "share: who" },
+    shareRole: { type: "select", required: false, options: ["reader", "writer"], description: "share: permission" },
+    query: { type: "string", required: false, description: "list: Drive search query" },
+    pageSize: { type: "number", required: false, min: 1, description: "list: page size" },
+    fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+    filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select a Google Drive connection");
+    if (config.operation && !GOOGLE_DRIVE_OPERATIONS.includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    if (config.operation === "share" && !config.shareEmail)
+      errors.push("share: an email address is required");
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...GoogleDriveActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `Drive: ${config.operation || "upload"}`
+};
+// src/catalog/storage/dropbox-action/config.ts
+var DROPBOX_OPERATIONS = ["list", "download", "upload", "delete", "move", "copy"];
+var DropboxActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "download",
+    mode: "overwrite"
+  },
+  schema: {
+    connector: { type: "connection", required: true, description: "Dropbox connector instance" },
+    operation: { type: "select", required: true, options: DROPBOX_OPERATIONS },
+    path: { type: "string", required: false, description: "File path, or the folder to list" },
+    content: { type: "text", required: false, description: "upload: the body" },
+    fileName: { type: "string", required: false, description: "upload: file name" },
+    destPath: { type: "string", required: false, description: "move / copy: destination path" },
+    mode: { type: "select", required: false, options: ["overwrite", "add"], description: "upload: write mode" },
+    fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+    filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select a Dropbox connection");
+    if (config.operation && !DROPBOX_OPERATIONS.includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...DropboxActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `Dropbox: ${config.operation || "download"}`
+};
+// src/catalog/storage/onedrive-action/config.ts
+var ONEDRIVE_OPERATIONS = ["download", "upload", "list", "delete", "move", "copy"];
+var OneDriveActionConfig = {
+  defaults: {
+    connector: "",
+    operation: "download",
+    contentType: "application/octet-stream"
+  },
+  schema: {
+    connector: { type: "connection", required: true, description: "Microsoft / OneDrive connector instance" },
+    operation: { type: "select", required: true, options: ONEDRIVE_OPERATIONS },
+    path: { type: "string", required: false, description: "Path from the drive root" },
+    itemId: { type: "string", required: false, description: "Item id, as an alternative to path" },
+    content: { type: "text", required: false, description: "upload: the body" },
+    fileName: { type: "string", required: false, description: "upload: file name" },
+    destPath: { type: "string", required: false, description: "move / copy: full destination path" },
+    contentType: { type: "string", required: false, description: "upload: MIME type" },
+    fileTypes: { type: "array", required: false, description: "list: keep only these extensions" },
+    filePattern: { type: "string", required: false, description: "list: keep only names matching this glob" }
+  },
+  validate: (config) => {
+    const errors = [];
+    if (!config.connector)
+      errors.push("Select a OneDrive connection");
+    if (config.operation && !ONEDRIVE_OPERATIONS.includes(config.operation))
+      errors.push(`Unknown operation "${config.operation}"`);
+    return { valid: errors.length === 0, errors };
+  },
+  merge: (userConfig) => ({ ...OneDriveActionConfig.defaults, ...userConfig }),
+  getLabel: (config) => `OneDrive: ${config.operation || "download"}`
+};
 // src/catalog/workflow.ts
 var NodeStatus;
 ((NodeStatus) => {
@@ -4861,7 +5569,22 @@ var CONFIG_CONTRACTS = {
   webhook_trigger: { schema: WebhookTriggerConfig.schema, validate: asValidator(WebhookTriggerConfig.validate) },
   debug: { schema: DebugConfig.schema, validate: asValidator(DebugConfig.validate) },
   error: { schema: ErrorConfig.schema, validate: asValidator(ErrorConfig.validate) },
-  variables: { schema: VariablesConfig.schema, validate: asValidator(VariablesConfig.validate) }
+  variables: { schema: VariablesConfig.schema, validate: asValidator(VariablesConfig.validate) },
+  ai_agent: { schema: AiAgentConfig.schema, validate: asValidator(AiAgentConfig.validate) },
+  idp_extract: { schema: IdpExtractConfig.schema, validate: asValidator(IdpExtractConfig.validate) },
+  group: { schema: GroupConfig.schema, validate: asValidator(GroupConfig.validate) },
+  connector_trigger: { schema: ConnectorTriggerConfig.schema, validate: asValidator(ConnectorTriggerConfig.validate) },
+  csv_action: { schema: CsvActionConfig.schema, validate: asValidator(CsvActionConfig.validate) },
+  json_action: { schema: JsonActionConfig.schema, validate: asValidator(JsonActionConfig.validate) },
+  xml_action: { schema: XmlActionConfig.schema, validate: asValidator(XmlActionConfig.validate) },
+  excel_action: { schema: ExcelActionConfig.schema, validate: asValidator(ExcelActionConfig.validate) },
+  file_action: { schema: FileActionConfig.schema, validate: asValidator(FileActionConfig.validate) },
+  storage_action: { schema: StorageActionConfig.schema, validate: asValidator(StorageActionConfig.validate) },
+  s3_action: { schema: S3ActionConfig.schema, validate: asValidator(S3ActionConfig.validate) },
+  ftp_action: { schema: FtpActionConfig.schema, validate: asValidator(FtpActionConfig.validate) },
+  google_drive_action: { schema: GoogleDriveActionConfig.schema, validate: asValidator(GoogleDriveActionConfig.validate) },
+  dropbox_action: { schema: DropboxActionConfig.schema, validate: asValidator(DropboxActionConfig.validate) },
+  onedrive_action: { schema: OneDriveActionConfig.schema, validate: asValidator(OneDriveActionConfig.validate) }
 };
 function contractFor(actionId) {
   return actionId ? CONFIG_CONTRACTS[actionId] : undefined;