@linkdlab/funcnodes_react_flow 0.3.11 → 0.3.13

package/dist/index.d.ts

@@ -0,0 +1,722 @@
+import * as React from 'react';
+import React__default, { JSX, ReactElement } from 'react';
+import { UseBoundStore, StoreApi } from 'zustand';
+import { Node, Edge, OnNodesChange, OnEdgesChange, OnConnect, useReactFlow } from 'reactflow';
+
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+type LimitedDeepPartial<T, D extends number = 10> = D extends 0 ? T : T extends object ? {
+    [K in keyof T]?: LimitedDeepPartial<T[K], Prev[D]>;
+} : T;
+/**
+ * Deeply updates the target object with missing keys from the source object.
+ * @param target The target object to be updated.
+ * @param source The source object containing keys to add to the target.
+ * @returns An object containing the updated target object (new_obj) and a boolean indicating if there was a change (change).
+ */
+declare const deep_update: <T extends {}>(target: LimitedDeepPartial<T>, source: T) => {
+    new_obj: T;
+    change: boolean;
+};
+
+type RenderType = "string" | "number" | "boolean" | "image" | SerializedType;
+interface BaseRenderOptions {
+    type: RenderType;
+}
+interface DataRenderOptions extends BaseRenderOptions {
+    src?: string;
+    preview_type?: string;
+}
+
+interface AllOf {
+    allOf: SerializedType[];
+}
+interface AnyOf {
+    anyOf: SerializedType[];
+}
+interface ArrayOf {
+    type: "array";
+    items: SerializedType;
+    uniqueItems: boolean;
+}
+interface DictOf {
+    type: "object";
+    keys: SerializedType;
+    values: SerializedType;
+}
+interface EnumOf {
+    type: "enum";
+    values: (number | string | boolean | null)[];
+    keys: string[];
+    nullable: boolean;
+}
+interface TypeOf {
+    type: "type";
+    value: SerializedType;
+}
+type SerializedType = string | AllOf | AnyOf | ArrayOf | DictOf | EnumOf | TypeOf;
+interface IORenderOptions extends BaseRenderOptions {
+    step?: number;
+    set_default: boolean;
+}
+interface IOValueOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: (string | number)[] | EnumOf;
+    colorspace?: string;
+}
+interface IOType {
+    connected: boolean;
+    does_trigger: boolean;
+    full_id: string;
+    id: string;
+    is_input: boolean;
+    name: string;
+    node: string;
+    type: SerializedType;
+    value: any;
+    fullvalue?: any;
+    render_options: IORenderOptions;
+    value_options?: IOValueOptions;
+    valuepreview_type?: string;
+    try_get_full_value: undefined | (() => void);
+    hidden: boolean;
+    set_hidden: undefined | ((v: boolean) => void);
+}
+interface UpdateableIOOptions {
+    name?: string;
+    hidden?: boolean;
+}
+type OutputRendererProps = {
+    io: IOType;
+};
+type OutputRendererType = ({ io }: OutputRendererProps) => JSX.Element;
+interface InputRendererProps {
+    io: IOType;
+    inputconverter: [(v: any) => any, (v: any) => any];
+}
+type InputRendererType = ({ io, inputconverter, }: InputRendererProps) => JSX.Element;
+
+/**
+ * Interface representing the state of a tqdm progress bar.
+ *
+ * Notes on each field:
+ * - `n`: Current iteration count.
+ * - `total`: Total number of iterations if known, `null` otherwise.
+ * - `elapsed`: Time elapsed in seconds since the start of iteration.
+ * - `ncols`: Number of columns for the progress bar. If `null`, not dynamically determined.
+ * - `nrows`: Number of rows. Usually `null` as `tqdm` typically focuses on columns.
+ * - `prefix`: Description string provided to `tqdm` via `desc`.
+ * - `ascii`: Whether to use ASCII characters for the bar or a custom set of ASCII characters.
+ *            Can be `true`, `false`, or a string specifying the characters.
+ * - `unit`: Iteration unit (e.g., 'it', 'steps', 'items').
+ * - `unit_scale`: If `true`, `tqdm` scales the iteration values.
+ *                If a number, `tqdm` uses it as a scaling factor.
+ * - `rate`: Current rate of iteration (iterations/second). `null` if rate cannot be computed.
+ * - `bar_format`: Custom format string for the bar. If `null`, the default format is used.
+ * - `postfix`: Additional data appended to the bar. Could be a string or an object passed via `set_postfix()`.
+ * - `unit_divisor`: Divisor used when scaling units (e.g., 1000 or 1024).
+ * - `initial`: Initial counter value if specified, else `null`.
+ * - `colour`: Colour for the progress bar if supported, else `null`.
+ */
+interface TqdmState {
+    n: number;
+    total?: number;
+    elapsed: number;
+    ncols?: number;
+    nrows?: number;
+    prefix?: string;
+    ascii: boolean | string;
+    unit: string;
+    unit_scale: boolean | number;
+    rate?: number;
+    bar_format?: string;
+    postfix?: string | Record<string, unknown>;
+    unit_divisor: number;
+    initial?: number;
+    colour?: string;
+}
+
+/**
+ * Interface for the NodeActionAdd.
+ * This interface is used when a new node is being added.
+ * It has a type property set to "add" and a node property of NodeType.
+ */
+interface BaseNodeAction {
+    type: string;
+    from_remote: boolean;
+    id: string;
+    immediate?: boolean;
+}
+interface NodeActionAdd extends BaseNodeAction {
+    type: "add";
+    node: NodeType;
+}
+/**
+ * Interface for the NodeActionUpdate.
+ * This interface is used when an existing node is being updated.
+ * It has a type property set to "update", an id property for the node to be updated,
+ * and a node property of PartialNodeType which contains the properties to be updated.
+ */
+interface NodeActionUpdate extends BaseNodeAction {
+    type: "update";
+    node: PartialNodeType;
+}
+/**
+ * Interface for the NodeActionDelete.
+ * This interface is used when a node is being deleted.
+ * It has a type property set to "delete" and an id property for the node to be deleted.
+ */
+interface NodeActionDelete extends BaseNodeAction {
+    type: "delete";
+}
+interface NodeActionError extends BaseNodeAction {
+    type: "error";
+    errortype: string;
+    error: string;
+    tb?: string;
+}
+interface NodeActionTrigger extends BaseNodeAction {
+    type: "trigger";
+}
+/**
+ * Type alias for NodeAction.
+ * A NodeAction can be either a NodeActionAdd, NodeActionUpdate, or NodeActionDelete.
+ */
+type NodeAction = NodeActionAdd | NodeActionUpdate | NodeActionDelete | NodeActionError | NodeActionTrigger;
+type NodeStore = UseBoundStore<StoreApi<NodeType>>;
+interface NodeRenderOptions {
+    data?: DataRenderOptions;
+}
+interface NodeType {
+    id: string;
+    node_name: string;
+    io: {
+        [key: string]: IOType;
+    };
+    frontend: {
+        pos: [number, number];
+        size: [number, number];
+        collapsed: boolean;
+    };
+    name: string;
+    in_trigger: boolean;
+    error?: string;
+    render_options?: NodeRenderOptions;
+    io_order: string[];
+    progress: TqdmState;
+    description?: string;
+}
+type PartialNodeType = DeepPartial<NodeType>;
+
+interface WorkerProps {
+    zustand?: FuncNodesReactFlowZustandInterface;
+    uuid: string;
+    on_error?: (error: string | Error) => void;
+    on_sync_complete?: (worker: FuncNodesWorker) => Promise<void>;
+}
+interface FuncNodesWorkerState {
+    is_open: boolean;
+}
+declare class FuncNodesWorker {
+    messagePromises: Map<string, any>;
+    _zustand?: FuncNodesReactFlowZustandInterface;
+    _local_nodeupdates: Map<string, PartialNodeType>;
+    _nodeupdatetimer: ReturnType<typeof setTimeout>;
+    uuid: string;
+    state: UseBoundStore<StoreApi<FuncNodesWorkerState>>;
+    on_sync_complete: (worker: FuncNodesWorker) => Promise<void>;
+    on_error: (error: any) => void;
+    constructor(data: WorkerProps);
+    set_zustand(zustand: FuncNodesReactFlowZustandInterface): void;
+    get is_open(): boolean;
+    set is_open(v: boolean);
+    stepwise_fullsync(): Promise<void>;
+    sync_lib(): Promise<void>;
+    sync_external_worker(): Promise<void>;
+    sync_funcnodes_plugins(): Promise<void>;
+    sync_view_state(): Promise<void>;
+    sync_nodespace(): Promise<void>;
+    fullsync(): Promise<void>;
+    _receive_edge_added(src_nid: string, src_ioid: string, trg_nid: string, trg_ioid: string): Promise<void>;
+    trigger_node(node_id: string): Promise<void>;
+    add_node(node_id: string): Promise<void>;
+    remove_node(node_id: string): Promise<void>;
+    _receive_node_added(data: NodeType): Promise<void>;
+    add_edge({ src_nid, src_ioid, trg_nid, trg_ioid, replace, }: {
+        src_nid: string;
+        src_ioid: string;
+        trg_nid: string;
+        trg_ioid: string;
+        replace?: boolean;
+    }): Promise<any>;
+    remove_edge({ src_nid, src_ioid, trg_nid, trg_ioid, }: {
+        src_nid: string;
+        src_ioid: string;
+        trg_nid: string;
+        trg_ioid: string;
+    }): Promise<any>;
+    add_external_worker({ module, cls_module, cls_name, }: {
+        module: string;
+        cls_module: string;
+        cls_name: string;
+    }): Promise<any>;
+    sync_local_node_updates(): void;
+    locally_update_node(action: NodeActionUpdate): void;
+    get_remote_node_state(nid: string): Promise<void>;
+    set_io_value({ nid, ioid, value, set_default, }: {
+        nid: string;
+        ioid: string;
+        value: any;
+        set_default: boolean;
+    }): Promise<any>;
+    clear(): Promise<any>;
+    save(): Promise<any>;
+    load(data: any): Promise<void>;
+    get_io_value({ nid, ioid }: {
+        nid: string;
+        ioid: string;
+    }): Promise<any>;
+    get_ios_values({ nid }: {
+        nid: string;
+    }): Promise<{
+        [ioid: string]: any;
+    }>;
+    _send_cmd({ cmd, kwargs, wait_for_response, response_timeout, retries, }: {
+        cmd: string;
+        kwargs?: any;
+        wait_for_response?: boolean;
+        response_timeout?: number;
+        retries?: number;
+    }): Promise<any>;
+    send(_data: any): Promise<void>;
+    upload_file({ files: _files, onProgressCallback: _onProgressCallback, root: _root, }: {
+        files: File[] | FileList;
+        onProgressCallback?: (loaded: number, total?: number) => void;
+        root?: string;
+    }): Promise<string[]>;
+    handle_large_message_hint({}: LargeMessageHint): Promise<void>;
+    receive_workerevent({ event, data }: WorkerEvent): Promise<void>;
+    receive_nodespace_event({ event, data }: NodeSpaceEvent): Promise<void>;
+    add_lib(lib: string, release: string): Promise<any>;
+    remove_lib(lib: string): Promise<any>;
+    receive(data: JSONMessage): Promise<any>;
+    disconnect(): void;
+    onclose(): void;
+    reconnect(): Promise<void>;
+    stop(): Promise<void>;
+    get_io_full_value({ nid, ioid }: {
+        nid: string;
+        ioid: string;
+    }): Promise<any>;
+    update_io_options({ nid, ioid, options, }: {
+        nid: string;
+        ioid: string;
+        options: UpdateableIOOptions;
+    }): Promise<any>;
+    get_node_status(nid: string): Promise<any>;
+    get_available_modules(): Promise<any>;
+    update_external_worker(worker_id: string, class_id: string, data: {
+        name?: string;
+    }): Promise<any>;
+    remove_external_worker(worker_id: string, class_id: string): Promise<any>;
+    export({ withFiles }: {
+        withFiles: boolean;
+    }): Promise<any>;
+    update_from_export(data: string): Promise<any>;
+}
+
+interface WebSocketWorkerProps extends WorkerProps {
+    url: string;
+}
+declare class WebSocketWorker extends FuncNodesWorker {
+    private _url;
+    private _websocket;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private initialTimeout;
+    private maxTimeout;
+    private _reconnect;
+    constructor(data: WebSocketWorkerProps);
+    private connect;
+    private calculateReconnectTimeout;
+    private auto_reconnect;
+    onmessage(data: string): Promise<void>;
+    get http_protocol(): string;
+    get secure_url(): boolean;
+    get url_wo_protocol(): string;
+    get http_url(): string;
+    upload_file({ files, onProgressCallback, root, }: {
+        files: File[] | FileList;
+        onProgressCallback?: (loaded: number, total?: number) => void;
+        root?: string;
+    }): Promise<string[]>;
+    handle_large_message_hint({ msg_id }: LargeMessageHint): Promise<void>;
+    onopen(): void;
+    onclose(): void;
+    on_ws_error(): void;
+    send_large_message(jsondata: string): Promise<void>;
+    send(data: any): Promise<void>;
+    stop(): Promise<void>;
+    close(): void;
+    disconnect(): void;
+    reconnect(): Promise<void>;
+}
+
+declare class WorkerManager {
+    private wsuri;
+    private workers;
+    private ws;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private initialTimeout;
+    private maxTimeout;
+    private zustand;
+    private connectionTimeout?;
+    on_setWorker: (worker: FuncNodesWorker | undefined) => void;
+    constructor(wsuri: string, zustand: FuncNodesReactFlowZustandInterface);
+    get open(): boolean;
+    private connect;
+    on_ws_error(): void;
+    onopen(): void;
+    onmessage(event: string): void;
+    setWorker(worker: FuncNodesWorker | undefined): void;
+    restart_worker(workerid: string): Promise<void>;
+    private calculateReconnectTimeout;
+    private reconnect;
+    onclose(): void;
+    set_active(workerid: string): void;
+    new_worker({ name, reference, copyLib, copyNS, }: {
+        name?: string;
+        reference?: string;
+        copyLib?: boolean;
+        copyNS?: boolean;
+    }): void;
+}
+
+type LibNode = {
+    node_id: string;
+    description?: string;
+    node_name?: string;
+};
+type Shelf = {
+    name: string;
+    description?: string;
+    nodes: LibNode[];
+    subshelves: Shelf[];
+};
+type LibType = {
+    shelves: Shelf[];
+};
+interface ExternalWorkerInstance {
+    uuid: string;
+    nodeclassid: string;
+    running: boolean;
+    name: string;
+}
+interface ExternalWorkerClassDep {
+    module: string;
+    class_name: string;
+    name: string;
+    instances: ExternalWorkerInstance[];
+}
+interface ExternalWorkerDependencies {
+    module: string;
+    worker_classes: ExternalWorkerClassDep[];
+}
+interface LibState {
+    lib: LibType;
+    external_worker?: ExternalWorkerDependencies[];
+    set: (state: {
+        lib?: LibType;
+        external_worker?: ExternalWorkerDependencies[];
+    }) => void;
+    get_lib: () => LibType;
+    get_external_worker: () => ExternalWorkerDependencies[] | undefined;
+}
+interface LibZustandInterface {
+    libstate: UseBoundStore<StoreApi<LibState>>;
+}
+
+/**
+ * Interface for the NodeSpaceZustand state management.
+ * This interface is used to define the shape of the state and the actions that can be performed on it.
+ */
+interface NodeSpaceZustandInterface {
+    nodesstates: Map<string, NodeStore>;
+    get_node: (nid: string, raise?: boolean) => NodeStore | undefined;
+}
+
+type RFState = {
+    nodes: Node[];
+    edges: Edge[];
+    onNodesChange: OnNodesChange;
+    onEdgesChange: OnEdgesChange;
+    onConnect: OnConnect;
+};
+type RFStore = UseBoundStore<StoreApi<RFState>>;
+
+interface BaseEdgeAction {
+    type: string;
+    src_nid: string;
+    src_ioid: string;
+    trg_nid: string;
+    trg_ioid: string;
+    from_remote: boolean;
+}
+interface EdgeActionAdd extends BaseEdgeAction {
+    type: "add";
+}
+interface EdgeActionDelete extends BaseEdgeAction {
+    type: "delete";
+}
+type EdgeAction = EdgeActionAdd | EdgeActionDelete;
+
+type HandlePreviewRendererType = ({ io }: {
+    io: IOType;
+}) => JSX.Element;
+type DataOverlayRendererType = ({ io }: {
+    io: IOType;
+}) => JSX.Element;
+type DataPreviewViewRendererType = ({ io }: {
+    io: IOType;
+}) => JSX.Element;
+type DataViewRendererType = ({ io }: {
+    io: IOType;
+}) => JSX.Element;
+/**
+ * RenderMappingProvider is a React component that provides a context for managing and extending the mappings of input renderers, handle preview renderers, data overlay renderers, data preview view renderers, and data view renderers. These mappings are used throughout the application to render various types of inputs, previews, and data views dynamically.
+
+ * The provider initializes with a set of default mappings and allows these mappings to be extended or overwritten via actions dispatched within the component's reducer. Additionally, it can automatically integrate renderer plugins, extending the functionality based on the provided plugins.
+
+ * @param {object} props - The props object for the RenderMappingProvider component.
+ * @param {ReactElement} props.children - The child components that will be wrapped by the provider.
+ * @param {object} props.plugins - An object containing various FuncNodesReactPlugin instances, which may include renderer plugins to be integrated into the render mappings.
+
+ * @returns {JSX.Element} A JSX element that provides the render mapping context to its children.
+
+ * Context Value:
+ * The context value provided by this component includes the following properties and functions:
+ * - Inputrenderer: A mapping of input types to their corresponding renderer components.
+ * - Outputrenderer: A mapping of output types to their corresponding renderer components.
+ * - HandlePreviewRenderer: A mapping of handle preview types to their corresponding renderer components.
+ * - DataOverlayRenderer: A mapping of data overlay types to their corresponding renderer components.
+ * - DataPreviewViewRenderer: A mapping of data preview view types to their corresponding renderer components.
+ * - DataViewRenderer: A mapping of data view types to their corresponding renderer components.
+ * - extendInputRenderMapping: A function to extend the input renderer mapping.
+ * - extendOutputRenderMapping: A function to extend the output renderer mapping.
+ * - extendHandlePreviewRenderMapping: A function to extend the handle preview renderer mapping.
+ * - extendDataOverlayRenderMapping: A function to extend the data overlay renderer mapping.
+ * - extendDataPreviewRenderMapping: A function to extend the data preview view renderer mapping.
+ * - extendDataViewRenderMapping: A function to extend the data view renderer mapping.
+ * - extendFromPlugin: A function to extend all relevant mappings from a given renderer plugin.
+
+ * Example usage:
+ * ```jsx
+ * <RenderMappingProvider plugins={myPlugins}>
+ *   <MyComponent />
+ * </RenderMappingProvider>
+ * ```
+ */
+declare const RenderMappingProvider: ({ children, plugins, fnrf_zst, }: {
+    children: ReactElement;
+    plugins: {
+        [key: string]: FuncNodesReactPlugin;
+    };
+    fnrf_zst: FuncNodesReactFlowZustandInterface;
+}) => JSX.Element;
+
+interface RendererPlugin {
+    input_renderers?: {
+        [key: string]: InputRendererType;
+    };
+    output_renderers?: {
+        [key: string]: OutputRendererType;
+    };
+    handle_preview_renderers?: {
+        [key: string]: HandlePreviewRendererType;
+    };
+    data_overlay_renderers?: {
+        [key: string]: DataOverlayRendererType;
+    };
+    data_preview_renderers?: {
+        [key: string]: DataPreviewViewRendererType;
+    };
+    data_view_renderers?: {
+        [key: string]: DataViewRendererType;
+    };
+}
+
+type RenderPluginFactoryProps = {
+    React: typeof React;
+    fnrf_zst: FuncNodesReactFlowZustandInterface;
+};
+interface FuncNodesReactPlugin {
+    RendererPlugin?: RendererPlugin;
+    renderpluginfactory?: (props: RenderPluginFactoryProps) => RendererPlugin;
+}
+
+interface Logger {
+    level: number;
+    set_level: (level: number) => void;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+}
+
+interface RenderOptions {
+    typemap?: {
+        [key: string]: string;
+    };
+    inputconverter?: {
+        [key: string]: string;
+    };
+}
+interface ProgressState {
+    message: string;
+    status: string;
+    progress: number;
+    blocking: boolean;
+}
+interface ProgressStateMessage extends ProgressState {
+    type: "progress";
+}
+interface ResultMessage {
+    type: "result";
+    id?: string;
+    result: any;
+}
+interface ErrorMessage {
+    type: "error";
+    error: string;
+    tb: string[];
+    id?: string;
+}
+interface NodeSpaceEvent {
+    type: "nsevent";
+    event: string;
+    data: {
+        [key: string]: any;
+    };
+}
+interface WorkerEvent {
+    type: "workerevent";
+    event: string;
+    data: {
+        [key: string]: any;
+    };
+}
+interface LargeMessageHint {
+    type: "large_message";
+    msg_id: string;
+}
+type JSONMessage = ProgressStateMessage | ResultMessage | ErrorMessage | NodeSpaceEvent | WorkerEvent | LargeMessageHint;
+interface WorkerRepresentation {
+    uuid: string;
+    host: string;
+    port: number;
+    ssl: boolean;
+    active: boolean;
+    open: boolean;
+    name: string | null;
+}
+interface WorkersState {
+    [key: string]: WorkerRepresentation;
+}
+interface FuncnodesReactHeaderProps {
+    show: boolean;
+    showmenu: boolean;
+}
+interface ReactFlowLibraryProps {
+    show: boolean;
+}
+interface ReactFlowLayerProps {
+    minimap: boolean;
+    static: boolean;
+    minZoom: number;
+    maxZoom: number;
+}
+interface FuncnodesReactFlowProps {
+    id: string;
+    debug: boolean;
+    on_sync_complete?: (worker: FuncNodesWorker) => Promise<void>;
+    useWorkerManager: boolean;
+    show_library: boolean;
+    worker?: FuncNodesWorker;
+    header: FuncnodesReactHeaderProps;
+    flow: ReactFlowLayerProps;
+    library: ReactFlowLibraryProps;
+    worker_url?: string;
+    fnw_url?: string;
+    workermanager_url?: string;
+}
+interface DevSettings {
+    debug: boolean;
+}
+interface FuncnodesReactFlowViewSettings {
+    expand_node_props: boolean;
+}
+interface FuncnodesReactFlowLocalSettings {
+    view_settings: FuncnodesReactFlowViewSettings;
+    update_view_settings: (settings: FuncnodesReactFlowViewSettings) => void;
+}
+interface FuncnodesReactFlowLocalState {
+    selected_nodes: string[];
+    selected_edges: string[];
+}
+interface FuncNodesReactFlowZustandInterface {
+    options: FuncnodesReactFlowProps;
+    local_settings: UseBoundStore<StoreApi<FuncnodesReactFlowLocalSettings>>;
+    local_state: UseBoundStore<StoreApi<FuncnodesReactFlowLocalState>>;
+    lib: LibZustandInterface;
+    workermanager: WorkerManager | undefined;
+    workers: UseBoundStore<StoreApi<WorkersState>>;
+    workerstate: UseBoundStore<StoreApi<FuncNodesWorkerState>>;
+    worker: FuncNodesWorker | undefined;
+    set_worker: (worker: FuncNodesWorker | undefined) => void;
+    _unsubscribeFromWorker: (() => void) | undefined;
+    nodespace: NodeSpaceZustandInterface;
+    useReactFlowStore: RFStore;
+    render_options: UseBoundStore<StoreApi<RenderOptions>>;
+    progress_state: UseBoundStore<StoreApi<ProgressState>>;
+    update_render_options: (options: RenderOptions) => void;
+    rf_instance?: ReturnType<typeof useReactFlow>;
+    on_node_action: (action: NodeAction) => void;
+    on_edge_action: (edge: EdgeAction) => void;
+    set_progress: (progress: ProgressState) => void;
+    auto_progress: () => void;
+    plugins: UseBoundStore<StoreApi<{
+        [key: string]: FuncNodesReactPlugin;
+    }>>;
+    add_plugin: (name: string, plugin: FuncNodesReactPlugin) => void;
+    reactflowRef: HTMLDivElement | null;
+    clear_all: () => void;
+    dev_settings: DevSettings;
+    logger: Logger;
+}
+
+declare const FuncNodesContext: React__default.Context<FuncNodesReactFlowZustandInterface>;
+declare const FuncnodesReactFlow: (fnprops: Partial<FuncnodesReactFlowProps>) => React__default.JSX.Element;
+
+declare const helperfunctions: {
+    set_io_value: ({ nid, ioid, value, set_default, }: {
+        nid: string;
+        ioid: string;
+        value: any;
+        set_default?: boolean;
+    }) => void;
+};
+
+declare const FuncNodesReactFlowZustand: (props: FuncnodesReactFlowProps) => FuncNodesReactFlowZustandInterface;
+
+declare const ReactFlowLayer: (props: ReactFlowLayerProps) => React__default.JSX.Element;
+
+declare const assert_full_node: (node: PartialNodeType) => NodeType;
+
+declare const FuncNodes: (props: Partial<FuncnodesReactFlowProps>) => React__default.JSX.Element;
+
+export { type DataOverlayRendererType, type DataPreviewViewRendererType, type DataViewRendererType, FuncNodesContext, FuncNodesReactFlowZustand, type FuncNodesReactFlowZustandInterface, type FuncNodesReactPlugin, FuncNodesWorker, FuncnodesReactFlow, type FuncnodesReactFlowProps, type HandlePreviewRendererType, type IOType, type InputRendererProps, type NodeType, type OutputRendererProps, type PartialNodeType, type ProgressState, ReactFlowLayer, RenderMappingProvider, type RenderPluginFactoryProps, type RendererPlugin, WebSocketWorker, type WorkerProps, assert_full_node, deep_update, FuncNodes as default, helperfunctions };