@flowdrop/flowdrop 1.14.0 → 2.0.0-beta.1

package/dist/services/draftStorage.d.ts

@@ -1,12 +1,82 @@
 /**
  * Draft Storage Service for FlowDrop
  *
- * Handles saving and loading workflow drafts to/from localStorage.
+ * Handles saving and loading workflow drafts to/from browser storage
+ * (localStorage by default, configurable via {@link setDraftStorage}).
  * Provides interval-based auto-save functionality.
  *
  * @module services/draftStorage
  */
 import type { Workflow } from '../types/index.js';
+/**
+ * Minimal storage adapter used for draft persistence.
+ *
+ * Implement this to back drafts with anything other than the built-in
+ * `localStorage` / `sessionStorage` options — e.g. an in-memory store, a
+ * key-prefixed wrapper, or a synchronous write-through cache.
+ *
+ * Note the interface is deliberately **synchronous**. Async backends
+ * (IndexedDB, network storage, WebCrypto-encrypted stores) cannot implement
+ * it directly — put a synchronous in-memory cache in front and flush to the
+ * async backend out of band. An `async` method assigned here will type-check
+ * (a Promise is assignable to `void`) but its errors are silently swallowed.
+ */
+export interface DraftStorageAdapter {
+    /** Read a value, or null when absent */
+    getItem(key: string): string | null;
+    /** Write a value */
+    setItem(key: string, value: string): void;
+    /** Remove a value */
+    removeItem(key: string): void;
+    /** List all keys currently held by the adapter */
+    keys(): string[];
+}
+/**
+ * Built-in storage backends
+ * - 'local': localStorage — drafts persist on the device even after the tab
+ *   or browser is closed, until saved or cleared
+ * - 'session': sessionStorage — drafts are scoped to the tab and removed
+ *   when it closes (they do not survive crash-and-reopen)
+ */
+export type DraftStorageType = 'local' | 'session';
+/** Accepted values for the `draftStorage` mount option */
+export type DraftStorageOption = DraftStorageType | DraftStorageAdapter;
+/**
+ * Resolve a {@link DraftStorageOption} to a concrete adapter.
+ *
+ * `'local'` / `'session'` map to the built-in Web Storage adapters, a custom
+ * adapter is returned as-is, and `undefined` resolves to the current
+ * module-level default (see {@link setDraftStorage}).
+ */
+export declare function resolveDraftStorage(option?: DraftStorageOption): DraftStorageAdapter;
+/**
+ * Configure the module-level default for where workflow drafts are persisted.
+ *
+ * - `'local'` (default): `localStorage` — drafts survive reloads and browser
+ *   restarts, and remain stored on the device even after the tab is closed,
+ *   until saved or cleared.
+ * - `'session'`: `sessionStorage` — drafts are scoped to the current tab and
+ *   removed when it closes. Note this also means drafts do not survive a
+ *   crash-and-reopen.
+ * - A custom {@link DraftStorageAdapter} for anything else.
+ *
+ * This sets the default used by the standalone helpers and by managers
+ * constructed without an explicit `storage` option. Mounted apps capture
+ * their own adapter at mount time, so calling this does not retarget
+ * already-running instances. With multiple mounts the most recent mount's
+ * backend wins *for the standalone helpers only*.
+ *
+ * Security note: neither built-in backend protects against same-origin
+ * script access (XSS) — both are readable by any script on the page. If
+ * workflows may contain secrets in node configs, disable drafts via
+ * `features.autoSaveDraft: false` or keep them off-disk with a custom
+ * in-memory adapter.
+ */
+export declare function setDraftStorage(option: DraftStorageOption): void;
+/**
+ * Get the current module-level default draft storage adapter
+ */
+export declare function getDraftStorage(): DraftStorageAdapter;
 /**
  * Draft metadata stored alongside the workflow
  */
@@ -19,7 +89,7 @@ interface DraftMetadata {
     workflowName?: string;
 }
 /**
- * Complete draft data stored in localStorage
+ * Complete draft data stored in draft storage
  */
 interface StoredDraft {
     /** The workflow data */
@@ -27,6 +97,14 @@ interface StoredDraft {
     /** Draft metadata */
     metadata: DraftMetadata;
 }
+/**
+ * Storage prefix of the page-default instance (`flowdrop:draft:default`).
+ *
+ * Every instance — including the default — uses an id-scoped prefix since
+ * v2.0. Standalone helper callers that don't pass a prefix get this one, so
+ * they keep addressing the default editor's drafts.
+ */
+export declare const DEFAULT_INSTANCE_DRAFT_PREFIX = "flowdrop:draft:default";
 /**
  * Generate a storage key for a workflow
  *
@@ -35,48 +113,70 @@ interface StoredDraft {
  *
  * @param workflowId - The workflow ID (optional)
  * @param customKey - Custom storage key provided by enterprise (optional)
+ * @param prefix - Key namespace; pass a FlowDrop instance's `storagePrefix`
+ *   to scope drafts per instance. Defaults to the page-default instance's
+ *   prefix.
  * @returns The storage key to use
  */
-export declare function getDraftStorageKey(workflowId?: string, customKey?: string): string;
+export declare function getDraftStorageKey(workflowId?: string, customKey?: string, prefix?: string): string;
+/**
+ * One-time migration of a 1.x draft key to its 2.0 scoped equivalent.
+ *
+ * In 1.x the page-default instance stored drafts under the bare
+ * `flowdrop:draft:<workflowId>` key; since 2.0 it uses
+ * `flowdrop:draft:default:<workflowId>`. When the scoped key is empty and the
+ * legacy key holds a draft, the draft is moved (copied, then the legacy key
+ * removed) so users upgrading mid-edit don't lose work.
+ *
+ * @param legacyKey - The 1.x bare-prefix key
+ * @param scopedKey - The 2.0 instance-scoped key
+ * @param storage - Adapter to migrate within (defaults to the module-level default)
+ */
+export declare function migrateLegacyDraftKey(legacyKey: string, scopedKey: string, storage?: DraftStorageAdapter): void;
 /**
- * Save a workflow draft to localStorage
+ * Save a workflow draft to draft storage
  *
  * @param workflow - The workflow to save
  * @param storageKey - The storage key to use
+ * @param storage - Adapter to write to (defaults to the module-level default)
  * @returns true if saved successfully, false otherwise
  */
-export declare function saveDraft(workflow: Workflow, storageKey: string): boolean;
+export declare function saveDraft(workflow: Workflow, storageKey: string, storage?: DraftStorageAdapter): boolean;
 /**
- * Load a workflow draft from localStorage
+ * Load a workflow draft from draft storage
  *
  * @param storageKey - The storage key to load from
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns The stored draft, or null if not found
  */
-export declare function loadDraft(storageKey: string): StoredDraft | null;
+export declare function loadDraft(storageKey: string, storage?: DraftStorageAdapter): StoredDraft | null;
 /**
- * Delete a workflow draft from localStorage
+ * Delete a workflow draft from draft storage
  *
  * @param storageKey - The storage key to delete
+ * @param storage - Adapter to delete from (defaults to the module-level default)
  */
-export declare function deleteDraft(storageKey: string): void;
+export declare function deleteDraft(storageKey: string, storage?: DraftStorageAdapter): void;
 /**
  * Check if a draft exists for a given storage key
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to check (defaults to the module-level default)
  * @returns true if a draft exists
  */
-export declare function hasDraft(storageKey: string): boolean;
+export declare function hasDraft(storageKey: string, storage?: DraftStorageAdapter): boolean;
 /**
  * Get draft metadata without loading the full workflow
  *
  * Useful for displaying draft information without parsing the entire workflow.
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns Draft metadata, or null if not found
  */
-export declare function getDraftMetadata(storageKey: string): DraftMetadata | null;
+export declare function getDraftMetadata(storageKey: string, storage?: DraftStorageAdapter): DraftMetadata | null;
 /**
- * Clear all FlowDrop drafts from localStorage
+ * Clear all FlowDrop drafts from draft storage
  *
  * Removes every key beginning with `flowdrop:draft:`. Intended to be called
  * from a host application's logout handler so workflow drafts do not persist
@@ -85,9 +185,10 @@ export declare function getDraftMetadata(storageKey: string): DraftMetadata | nu
  * @param extraKeys - Additional explicit keys to remove. Pass any custom
  *   `draftStorageKey` values configured at mount time so they are cleared
  *   alongside the default-prefixed keys.
+ * @param storage - Adapter to clear (defaults to the module-level default)
  * @returns The number of entries removed.
  */
-export declare function clearAllDrafts(extraKeys?: readonly string[]): number;
+export declare function clearAllDrafts(extraKeys?: readonly string[], storage?: DraftStorageAdapter): number;
 /**
  * Draft auto-save manager
  *
@@ -107,6 +208,17 @@ export declare class DraftAutoSaveManager {
     private getWorkflow;
     /** Function to check if workflow is dirty */
     private isDirty;
+    /**
+     * Runtime gate for draft persistence (e.g. a user-facing opt-out setting).
+     * Checked on every save, so it can change after construction.
+     */
+    private isPersistenceAllowed;
+    /**
+     * Storage adapter this instance writes to.
+     * Captured at construction, so a later `setDraftStorage()` call (e.g. from
+     * another FlowDrop mount on the same page) cannot retarget this manager.
+     */
+    private storage;
     /** Last saved workflow hash (for change detection) */
     private lastSavedHash;
     /**
@@ -120,6 +232,10 @@ export declare class DraftAutoSaveManager {
         enabled: boolean;
         getWorkflow: () => Workflow | null;
         isDirty: () => boolean;
+        /** Optional runtime gate — return false to suppress draft writes (default: always allowed) */
+        isPersistenceAllowed?: () => boolean;
+        /** Storage backend for this instance (default: the module-level default at construction time) */
+        storage?: DraftStorageOption;
     });
     /**
      * Start auto-save interval

package/dist/services/draftStorage.js

@@ -1,7 +1,8 @@
 /**
  * Draft Storage Service for FlowDrop
  *
- * Handles saving and loading workflow drafts to/from localStorage.
+ * Handles saving and loading workflow drafts to/from browser storage
+ * (localStorage by default, configurable via {@link setDraftStorage}).
  * Provides interval-based auto-save functionality.
  *
  * @module services/draftStorage
@@ -11,6 +12,96 @@ import { logger } from '../utils/logger.js';
  * Default storage key prefix
  */
 const STORAGE_KEY_PREFIX = 'flowdrop:draft';
+/**
+ * Wrap a Web Storage object (localStorage/sessionStorage) as a DraftStorageAdapter.
+ * The storage global is resolved lazily so SSR and test environments that
+ * replace the globals keep working.
+ */
+function createWebStorageAdapter(getStorage) {
+    return {
+        getItem: (key) => getStorage().getItem(key),
+        setItem: (key, value) => getStorage().setItem(key, value),
+        removeItem: (key) => getStorage().removeItem(key),
+        keys: () => {
+            const storage = getStorage();
+            const keys = [];
+            for (let i = 0; i < storage.length; i++) {
+                const key = storage.key(i);
+                if (key !== null) {
+                    keys.push(key);
+                }
+            }
+            return keys;
+        }
+    };
+}
+const WEB_STORAGE_ADAPTERS = {
+    local: createWebStorageAdapter(() => localStorage),
+    session: createWebStorageAdapter(() => sessionStorage)
+};
+/**
+ * Module-level default adapter (localStorage by default).
+ *
+ * Used by the standalone helpers (`saveDraft`, `clearAllDrafts`, ...) when no
+ * explicit adapter is passed, and as the fallback for managers constructed
+ * without a `storage` option. Per-instance code (each `DraftAutoSaveManager`,
+ * each mounted app) captures its own resolved adapter instead, so multiple
+ * FlowDrop instances with different backends do not interfere.
+ */
+let activeAdapter = WEB_STORAGE_ADAPTERS.local;
+/**
+ * Resolve a {@link DraftStorageOption} to a concrete adapter.
+ *
+ * `'local'` / `'session'` map to the built-in Web Storage adapters, a custom
+ * adapter is returned as-is, and `undefined` resolves to the current
+ * module-level default (see {@link setDraftStorage}).
+ */
+export function resolveDraftStorage(option) {
+    if (option === undefined) {
+        return activeAdapter;
+    }
+    return typeof option === 'string' ? WEB_STORAGE_ADAPTERS[option] : option;
+}
+/**
+ * Configure the module-level default for where workflow drafts are persisted.
+ *
+ * - `'local'` (default): `localStorage` — drafts survive reloads and browser
+ *   restarts, and remain stored on the device even after the tab is closed,
+ *   until saved or cleared.
+ * - `'session'`: `sessionStorage` — drafts are scoped to the current tab and
+ *   removed when it closes. Note this also means drafts do not survive a
+ *   crash-and-reopen.
+ * - A custom {@link DraftStorageAdapter} for anything else.
+ *
+ * This sets the default used by the standalone helpers and by managers
+ * constructed without an explicit `storage` option. Mounted apps capture
+ * their own adapter at mount time, so calling this does not retarget
+ * already-running instances. With multiple mounts the most recent mount's
+ * backend wins *for the standalone helpers only*.
+ *
+ * Security note: neither built-in backend protects against same-origin
+ * script access (XSS) — both are readable by any script on the page. If
+ * workflows may contain secrets in node configs, disable drafts via
+ * `features.autoSaveDraft: false` or keep them off-disk with a custom
+ * in-memory adapter.
+ */
+export function setDraftStorage(option) {
+    activeAdapter = resolveDraftStorage(option);
+}
+/**
+ * Get the current module-level default draft storage adapter
+ */
+export function getDraftStorage() {
+    return activeAdapter;
+}
+/**
+ * Storage prefix of the page-default instance (`flowdrop:draft:default`).
+ *
+ * Every instance — including the default — uses an id-scoped prefix since
+ * v2.0. Standalone helper callers that don't pass a prefix get this one, so
+ * they keep addressing the default editor's drafts.
+ */
+export const DEFAULT_INSTANCE_DRAFT_PREFIX = `${STORAGE_KEY_PREFIX}:default`;
 /**
  * Generate a storage key for a workflow
  *
@@ -19,25 +110,58 @@ const STORAGE_KEY_PREFIX = 'flowdrop:draft';
  *
  * @param workflowId - The workflow ID (optional)
  * @param customKey - Custom storage key provided by enterprise (optional)
+ * @param prefix - Key namespace; pass a FlowDrop instance's `storagePrefix`
+ *   to scope drafts per instance. Defaults to the page-default instance's
+ *   prefix.
  * @returns The storage key to use
  */
-export function getDraftStorageKey(workflowId, customKey) {
+export function getDraftStorageKey(workflowId, customKey, prefix = DEFAULT_INSTANCE_DRAFT_PREFIX) {
     if (customKey) {
         return customKey;
     }
     if (workflowId) {
-        return `${STORAGE_KEY_PREFIX}:${workflowId}`;
+        return `${prefix}:${workflowId}`;
     }
-    return `${STORAGE_KEY_PREFIX}:new`;
+    return `${prefix}:new`;
 }
 /**
- * Save a workflow draft to localStorage
+ * One-time migration of a 1.x draft key to its 2.0 scoped equivalent.
+ *
+ * In 1.x the page-default instance stored drafts under the bare
+ * `flowdrop:draft:<workflowId>` key; since 2.0 it uses
+ * `flowdrop:draft:default:<workflowId>`. When the scoped key is empty and the
+ * legacy key holds a draft, the draft is moved (copied, then the legacy key
+ * removed) so users upgrading mid-edit don't lose work.
+ *
+ * @param legacyKey - The 1.x bare-prefix key
+ * @param scopedKey - The 2.0 instance-scoped key
+ * @param storage - Adapter to migrate within (defaults to the module-level default)
+ */
+export function migrateLegacyDraftKey(legacyKey, scopedKey, storage = activeAdapter) {
+    if (legacyKey === scopedKey)
+        return;
+    try {
+        if (storage.getItem(scopedKey) !== null)
+            return;
+        const legacy = storage.getItem(legacyKey);
+        if (legacy === null)
+            return;
+        storage.setItem(scopedKey, legacy);
+        storage.removeItem(legacyKey);
+    }
+    catch (error) {
+        logger.warn('Failed to migrate legacy draft key:', error);
+    }
+}
+/**
+ * Save a workflow draft to draft storage
  *
  * @param workflow - The workflow to save
  * @param storageKey - The storage key to use
+ * @param storage - Adapter to write to (defaults to the module-level default)
  * @returns true if saved successfully, false otherwise
  */
-export function saveDraft(workflow, storageKey) {
+export function saveDraft(workflow, storageKey, storage = activeAdapter) {
     try {
         const draft = {
             workflow,
@@ -47,62 +171,65 @@ export function saveDraft(workflow, storageKey) {
                 workflowName: workflow.name
             }
         };
-        localStorage.setItem(storageKey, JSON.stringify(draft));
+        storage.setItem(storageKey, JSON.stringify(draft));
         return true;
     }
     catch (error) {
-        // localStorage might be full or disabled
-        logger.warn('Failed to save draft to localStorage:', error);
+        // Storage might be full or disabled
+        logger.warn('Failed to save draft to storage:', error);
         return false;
     }
 }
 /**
- * Load a workflow draft from localStorage
+ * Load a workflow draft from draft storage
  *
  * @param storageKey - The storage key to load from
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns The stored draft, or null if not found
  */
-export function loadDraft(storageKey) {
+export function loadDraft(storageKey, storage = activeAdapter) {
     try {
-        const stored = localStorage.getItem(storageKey);
+        const stored = storage.getItem(storageKey);
         if (!stored) {
             return null;
         }
         const draft = JSON.parse(stored);
         // Validate the draft structure
         if (!draft.workflow || !draft.metadata) {
-            logger.warn('Invalid draft structure in localStorage');
+            logger.warn('Invalid draft structure in storage');
             return null;
         }
         return draft;
     }
     catch (error) {
-        logger.warn('Failed to load draft from localStorage:', error);
+        logger.warn('Failed to load draft from storage:', error);
         return null;
     }
 }
 /**
- * Delete a workflow draft from localStorage
+ * Delete a workflow draft from draft storage
  *
  * @param storageKey - The storage key to delete
+ * @param storage - Adapter to delete from (defaults to the module-level default)
  */
-export function deleteDraft(storageKey) {
+export function deleteDraft(storageKey, storage = activeAdapter) {
     try {
-        localStorage.removeItem(storageKey);
+        storage.removeItem(storageKey);
     }
     catch (error) {
-        logger.warn('Failed to delete draft from localStorage:', error);
+        logger.warn('Failed to delete draft from storage:', error);
     }
 }
 /**
  * Check if a draft exists for a given storage key
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to check (defaults to the module-level default)
  * @returns true if a draft exists
  */
-export function hasDraft(storageKey) {
+export function hasDraft(storageKey, storage = activeAdapter) {
     try {
-        return localStorage.getItem(storageKey) !== null;
+        return storage.getItem(storageKey) !== null;
     }
     catch {
         return false;
@@ -114,14 +241,15 @@ export function hasDraft(storageKey) {
  * Useful for displaying draft information without parsing the entire workflow.
  *
  * @param storageKey - The storage key to check
+ * @param storage - Adapter to read from (defaults to the module-level default)
  * @returns Draft metadata, or null if not found
  */
-export function getDraftMetadata(storageKey) {
-    const draft = loadDraft(storageKey);
+export function getDraftMetadata(storageKey, storage = activeAdapter) {
+    const draft = loadDraft(storageKey, storage);
     return draft?.metadata ?? null;
 }
 /**
- * Clear all FlowDrop drafts from localStorage
+ * Clear all FlowDrop drafts from draft storage
  *
  * Removes every key beginning with `flowdrop:draft:`. Intended to be called
  * from a host application's logout handler so workflow drafts do not persist
@@ -130,29 +258,29 @@ export function getDraftMetadata(storageKey) {
  * @param extraKeys - Additional explicit keys to remove. Pass any custom
  *   `draftStorageKey` values configured at mount time so they are cleared
  *   alongside the default-prefixed keys.
+ * @param storage - Adapter to clear (defaults to the module-level default)
  * @returns The number of entries removed.
  */
-export function clearAllDrafts(extraKeys = []) {
+export function clearAllDrafts(extraKeys = [], storage = activeAdapter) {
     try {
         const keysToRemove = new Set();
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.startsWith(`${STORAGE_KEY_PREFIX}:`)) {
+        for (const key of storage.keys()) {
+            if (key.startsWith(`${STORAGE_KEY_PREFIX}:`)) {
                 keysToRemove.add(key);
             }
         }
         for (const key of extraKeys) {
-            if (localStorage.getItem(key) !== null) {
+            if (storage.getItem(key) !== null) {
                 keysToRemove.add(key);
             }
         }
         for (const key of keysToRemove) {
-            localStorage.removeItem(key);
+            storage.removeItem(key);
         }
         return keysToRemove.size;
     }
     catch (error) {
-        logger.warn('Failed to clear drafts from localStorage:', error);
+        logger.warn('Failed to clear drafts from storage:', error);
         return 0;
     }
 }
@@ -175,6 +303,17 @@ export class DraftAutoSaveManager {
     getWorkflow;
     /** Function to check if workflow is dirty */
     isDirty;
+    /**
+     * Runtime gate for draft persistence (e.g. a user-facing opt-out setting).
+     * Checked on every save, so it can change after construction.
+     */
+    isPersistenceAllowed;
+    /**
+     * Storage adapter this instance writes to.
+     * Captured at construction, so a later `setDraftStorage()` call (e.g. from
+     * another FlowDrop mount on the same page) cannot retarget this manager.
+     */
+    storage;
     /** Last saved workflow hash (for change detection) */
     lastSavedHash = null;
     /**
@@ -188,6 +327,8 @@ export class DraftAutoSaveManager {
         this.enabled = options.enabled;
         this.getWorkflow = options.getWorkflow;
         this.isDirty = options.isDirty;
+        this.isPersistenceAllowed = options.isPersistenceAllowed ?? (() => true);
+        this.storage = resolveDraftStorage(options.storage);
     }
     /**
      * Start auto-save interval
@@ -217,7 +358,7 @@ export class DraftAutoSaveManager {
      * @returns true if a draft was saved
      */
     saveIfDirty() {
-        if (!this.enabled) {
+        if (!this.enabled || !this.isPersistenceAllowed()) {
             return false;
         }
         const workflow = this.getWorkflow();
@@ -233,7 +374,7 @@ export class DraftAutoSaveManager {
         if (currentHash === this.lastSavedHash) {
             return false;
         }
-        const saved = saveDraft(workflow, this.storageKey);
+        const saved = saveDraft(workflow, this.storageKey, this.storage);
         if (saved) {
             this.lastSavedHash = currentHash;
         }
@@ -247,11 +388,14 @@ export class DraftAutoSaveManager {
      * @returns true if saved successfully
      */
     forceSave() {
+        if (!this.isPersistenceAllowed()) {
+            return false;
+        }
         const workflow = this.getWorkflow();
         if (!workflow) {
             return false;
         }
-        const saved = saveDraft(workflow, this.storageKey);
+        const saved = saveDraft(workflow, this.storageKey, this.storage);
         if (saved) {
             this.lastSavedHash = this.hashWorkflow(workflow);
         }
@@ -261,7 +405,7 @@ export class DraftAutoSaveManager {
      * Clear the draft from storage
      */
     clearDraft() {
-        deleteDraft(this.storageKey);
+        deleteDraft(this.storageKey, this.storage);
         this.lastSavedHash = null;
     }
     /**
@@ -284,10 +428,14 @@ export class DraftAutoSaveManager {
      */
     updateStorageKey(newKey) {
         // If there's an existing draft with the old key, migrate it
-        const existingDraft = loadDraft(this.storageKey);
+        const existingDraft = loadDraft(this.storageKey, this.storage);
         if (existingDraft && this.storageKey !== newKey) {
-            deleteDraft(this.storageKey);
-            saveDraft(existingDraft.workflow, newKey);
+            deleteDraft(this.storageKey, this.storage);
+            // Migration is still a write — respect the user's opt-out. The old
+            // draft is deleted either way, which is in line with opting out.
+            if (this.isPersistenceAllowed()) {
+                saveDraft(existingDraft.workflow, newKey, this.storage);
+            }
         }
         this.storageKey = newKey;
     }

package/dist/services/dynamicSchemaService.d.ts

@@ -6,6 +6,7 @@
  * @module services/dynamicSchemaService
  */
 import type { ConfigSchema, DynamicSchemaEndpoint, ExternalEditLink, ConfigEditOptions, WorkflowNode } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
  * Result of a dynamic schema fetch operation
  */
@@ -41,7 +42,7 @@ export interface DynamicSchemaResult {
  * }
  * ```
  */
-export declare function fetchDynamicSchema(endpoint: DynamicSchemaEndpoint, node: WorkflowNode, workflowId?: string): Promise<DynamicSchemaResult>;
+export declare function fetchDynamicSchema(endpointConfig: EndpointConfig | null, endpoint: DynamicSchemaEndpoint, node: WorkflowNode, workflowId?: string): Promise<DynamicSchemaResult>;
 /**
  * Resolves an external edit link URL with template variables.
  *