@linkdlab/funcnodes_react_flow 0.4.3 → 0.4.4

package/dist/plugin/helper.d.ts

@@ -0,0 +1,2 @@
+declare function assertNever(x: never): void;
+export { assertNever };

package/dist/plugin/index.d.ts

@@ -0,0 +1,7 @@
+import { latest as latest_types } from '../types/versioned/versions.t';
+export interface PackedPlugin {
+    module: string;
+    js?: string[];
+    css?: string[];
+}
+export declare const upgradeFuncNodesReactPlugin: (plugin: latest_types.AnyFuncNodesReactPlugin) => latest_types.FuncNodesReactPlugin;

package/dist/plugin/v0/index.d.ts

@@ -0,0 +1,2 @@
+import { v0 as v0_types } from '../../types/versioned/versions.t';
+export declare const upgradePlugin_v0: (plugin: v0_types.FuncNodesReactPlugin) => v0_types.FuncNodesReactPlugin;

package/dist/plugin/v1/index.d.ts

@@ -0,0 +1,2 @@
+import { upgradePlugin_v1 } from './upgrader';
+export { upgradePlugin_v1 as upgradePlugin };

package/dist/plugin/v1/upgrader.d.ts

@@ -0,0 +1,34 @@
+import { v1 as v1_types, v0 as v0_types } from '../../types/versioned/versions.t';
+type olderPlugins_v1 = v0_types.FuncNodesReactPlugin;
+export declare class IOHelperClass implements v0_types.IOType {
+    constructor(iostore: v1_types.IOStore);
+    iostore: v1_types.IOStore;
+    get connected(): boolean;
+    set connected(v: boolean);
+    get does_trigger(): boolean;
+    set does_trigger(v: boolean);
+    get full_id(): string;
+    set full_id(v: string);
+    get id(): string;
+    set id(v: string);
+    get is_input(): boolean;
+    set is_input(v: boolean);
+    get name(): string;
+    set name(v: string);
+    get node(): string;
+    set node(v: string);
+    get type(): v0_types.SerializedType;
+    set type(v: v0_types.SerializedType);
+    get value(): any;
+    set value(v: any);
+    get fullvalue(): any;
+    set fullvalue(v: any);
+    get render_options(): v0_types.IORenderOptions;
+    set render_options(v: v0_types.IORenderOptions);
+    get hidden(): boolean;
+    set hidden(v: boolean);
+    get try_get_full_value(): undefined | (() => void);
+    get set_hidden(): undefined | ((v: boolean) => void);
+}
+declare const upgradePlugin_v1: (plugin: olderPlugins_v1 | v1_types.FuncNodesReactPlugin) => v1_types.FuncNodesReactPlugin;
+export { upgradePlugin_v1 };

package/dist/states/edge.d.ts

@@ -0,0 +1,7 @@
+declare const generate_edge_id: ({ src_nid, src_ioid, trg_nid, trg_ioid, }: {
+    src_nid: string;
+    src_ioid: string;
+    trg_nid: string;
+    trg_ioid: string;
+}) => string;
+export { generate_edge_id };

package/dist/states/edge.t.d.ts

@@ -0,0 +1,16 @@
+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;
+export type { EdgeAction, EdgeActionAdd, EdgeActionDelete };

package/dist/states/fnrfzst.d.ts

@@ -0,0 +1,9 @@
+import { default as LibZustand } from './lib';
+import { default as NodeSpaceZustand } from './nodespace';
+import { Node as RFNode } from '@xyflow/react';
+import { FuncNodesReactFlowZustandInterface, FuncnodesReactFlowProps } from './fnrfzst.t';
+import { latest } from '../types/versioned/versions.t';
+declare const assert_reactflow_node: (store: latest.NodeStore, fnrf_instance?: FuncNodesReactFlowZustandInterface) => latest.NodeType & RFNode;
+declare const FuncNodesReactFlowZustand: (props: FuncnodesReactFlowProps) => FuncNodesReactFlowZustandInterface;
+export default FuncNodesReactFlowZustand;
+export { LibZustand, NodeSpaceZustand, assert_reactflow_node };

package/dist/states/fnrfzst.t.d.ts

@@ -0,0 +1,182 @@
+import { StoreApi, UseBoundStore } from 'zustand';
+import { FuncNodesWorker, WorkerManager } from '../funcnodes';
+import { ExternalWorkerDependencies, LibType, LibZustandInterface } from './lib.t';
+import { NodeSpaceZustandInterface } from './nodespace.t';
+import { RFStore } from './reactflow.t';
+import { EdgeAction } from './edge.t';
+import { useReactFlow } from '@xyflow/react';
+import { Logger } from '../utils/logger';
+import { FuncNodesWorkerState } from '../funcnodes/funcnodesworker';
+import { latest } from '../types/versioned/versions.t';
+interface RenderOptions {
+    typemap?: {
+        [key: string]: string | undefined;
+    };
+    inputconverter?: {
+        [key: string]: string | undefined;
+    };
+}
+interface NodeViewState {
+    pos: [number, number];
+    size: [number, number];
+    collapsed: boolean;
+}
+interface ViewState {
+    nodes: {
+        [key: string]: NodeViewState | undefined;
+    };
+    renderoptions?: RenderOptions;
+}
+interface FullNodeSpaceJSON {
+    nodes: latest.SerializedNodeType[];
+    edges: [string, string, string, string][];
+    prop: {
+        [key: string]: any | undefined;
+    };
+    lib: LibType;
+}
+interface FullState {
+    backend: FullNodeSpaceJSON;
+    view: ViewState;
+    worker: {
+        [key: string]: string[] | undefined;
+    };
+    worker_dependencies: ExternalWorkerDependencies[];
+}
+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 | undefined;
+    };
+}
+interface WorkerEvent {
+    type: "workerevent";
+    event: string;
+    data: {
+        [key: string]: any | undefined;
+    };
+}
+interface LargeMessageHint {
+    type: "large_message";
+    msg_id: string;
+}
+interface PongMessage {
+    type: "pong";
+}
+type JSONMessage = ProgressStateMessage | ResultMessage | ErrorMessage | NodeSpaceEvent | WorkerEvent | LargeMessageHint | PongMessage;
+interface WorkerRepresentation {
+    uuid: string;
+    host: string;
+    port: number;
+    ssl: boolean;
+    active: boolean;
+    open: boolean;
+    name: string | null;
+}
+interface WorkersState {
+    [key: string]: WorkerRepresentation | undefined;
+}
+interface FuncnodesReactHeaderProps {
+    show: boolean;
+    showmenu: boolean;
+}
+interface ReactFlowLibraryProps {
+    show: boolean;
+}
+interface ReactFlowLayerProps {
+    minimap: boolean;
+    static: boolean;
+    minZoom: number;
+    maxZoom: number;
+    allowFullScreen: boolean;
+    allowExpand: boolean;
+    showNodeSettings: boolean;
+}
+interface FuncnodesReactFlowProps {
+    id: string;
+    debug: boolean;
+    on_sync_complete?: (worker: FuncNodesWorker) => Promise<void>;
+    useWorkerManager: boolean;
+    show_library: boolean;
+    load_worker?: string;
+    worker?: FuncNodesWorker;
+    header: FuncnodesReactHeaderProps;
+    flow: ReactFlowLayerProps;
+    library: ReactFlowLibraryProps;
+    worker_url?: string;
+    fnw_url?: string;
+    workermanager_url?: string;
+    on_ready?: ({ fnrf_zst, }: {
+        fnrf_zst: FuncNodesReactFlowZustandInterface;
+    }) => void;
+}
+interface DevSettings {
+    debug: boolean;
+}
+interface FuncnodesReactFlowViewSettings {
+    expand_node_props?: boolean;
+    expand_lib?: boolean;
+}
+interface FuncnodesReactFlowLocalSettings {
+    view_settings: FuncnodesReactFlowViewSettings;
+    update_view_settings: (settings: FuncnodesReactFlowViewSettings) => void;
+}
+interface FuncnodesReactFlowLocalState {
+    selected_nodes: string[];
+    selected_edges: string[];
+    funcnodescontainerRef: HTMLDivElement | null;
+}
+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: latest.NodeAction) => void;
+    on_edge_action: (edge: EdgeAction) => void;
+    set_progress: (progress: ProgressState) => void;
+    auto_progress: () => void;
+    plugins: UseBoundStore<StoreApi<{
+        [key: string]: latest.FuncNodesReactPlugin | undefined;
+    }>>;
+    add_plugin: (name: string, plugin: latest.FuncNodesReactPlugin) => void;
+    reactflowRef: HTMLDivElement | null;
+    clear_all: () => void;
+    center_node: (node_id: string | string[]) => void;
+    center_all: () => void;
+    dev_settings: DevSettings;
+    logger: Logger;
+}
+export type { FuncNodesReactFlowZustandInterface, WorkersState, WorkerRepresentation, JSONMessage, FullState, FullNodeSpaceJSON, ViewState, RenderOptions, ProgressState, ProgressStateMessage, ResultMessage, ErrorMessage, NodeSpaceEvent, WorkerEvent, LargeMessageHint, NodeViewState, FuncnodesReactFlowProps, FuncnodesReactHeaderProps, ReactFlowLayerProps, FuncnodesReactFlowLocalSettings, FuncnodesReactFlowLocalState, FuncnodesReactFlowViewSettings, ReactFlowLibraryProps, };

package/dist/states/index.d.ts

@@ -0,0 +1,7 @@
+import { default as LibZustand } from './lib';
+import { default as NodeSpaceZustand } from './nodespace';
+import { WorkersState } from './fnrfzst.t';
+import { default as FuncNodesReactFlowZustand } from './fnrfzst';
+export default FuncNodesReactFlowZustand;
+export { LibZustand, NodeSpaceZustand };
+export type { WorkersState };

package/dist/states/lib.d.ts

@@ -0,0 +1,3 @@
+import { LibZustandInterface } from './lib.t';
+declare const LibZustand: () => LibZustandInterface;
+export default LibZustand;

package/dist/states/lib.t.d.ts

@@ -0,0 +1,45 @@
+import { UseBoundStore, StoreApi } from 'zustand';
+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>>;
+}
+export type { LibZustandInterface, LibState, LibType, Shelf, LibNode, ExternalWorkerClassDep, ExternalWorkerDependencies, ExternalWorkerInstance, };

package/dist/states/node/newnode.d.ts

@@ -0,0 +1,4 @@
+import { FuncNodesReactFlowZustandInterface } from '../fnrfzst.t';
+import { latest } from '../../types/versioned/versions.t';
+declare const createNodeStore: (fnrfz: FuncNodesReactFlowZustandInterface, node: latest.SerializedNodeType) => latest.NodeStore;
+export { createNodeStore };

package/dist/states/node/update_funcs.d.ts

@@ -0,0 +1,9 @@
+import { latest } from '../../types/versioned/versions.t';
+declare const simple_updater: <U extends string | number | boolean, T extends U | undefined>(oldvalue: U, newvalue: T) => [U, boolean];
+declare function assertNever(x: never, y: any): never;
+interface NormalizedPartialSerializedNodeType extends latest.PartialSerializedNodeType {
+    io_order: string[];
+}
+declare const normalize_node: (node: latest.PartialSerializedNodeType) => NormalizedPartialSerializedNodeType;
+export { simple_updater, assertNever, normalize_node };
+export type { NormalizedPartialSerializedNodeType };

package/dist/states/node/update_io.d.ts

@@ -0,0 +1,3 @@
+import { latest } from '../../types/versioned/versions.t';
+declare const update_io: (iostore: latest.IOStore, new_state: latest.PartialSerializedIOType) => void;
+export { update_io };

package/dist/states/node/update_node.d.ts

@@ -0,0 +1,6 @@
+import { NodeViewState } from '../fnrfzst.t';
+import { UseBoundStore, StoreApi } from 'zustand';
+import { latest } from '../../types/versioned/versions.t';
+declare const update_node: (old_store: UseBoundStore<StoreApi<latest.NodeType>>, new_state: latest.PartialSerializedNodeType) => void;
+declare const update_nodeview: (node: latest.PartialSerializedNodeType, view: Partial<NodeViewState>) => void;
+export { update_node, update_nodeview };

package/dist/states/nodespace.d.ts

@@ -0,0 +1,3 @@
+import { NodeSpaceZustandInterface, NodeSpaceZustandProps } from './nodespace.t';
+declare const NodeSpaceZustand: ({}: NodeSpaceZustandProps) => NodeSpaceZustandInterface;
+export default NodeSpaceZustand;

package/dist/states/nodespace.t.d.ts

@@ -0,0 +1,16 @@
+import { latest } from '../types/versioned/versions.t';
+/**
+ * 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, latest.NodeStore>;
+    get_node: (nid: string, raise?: boolean) => latest.NodeStore | undefined;
+}
+/**
+ * Interface for the NodeSpaceZustandProps.
+ * This interface is used to define the properties that can be passed to the NodeSpaceZustand component.
+ */
+interface NodeSpaceZustandProps {
+}
+export type { NodeSpaceZustandProps, NodeSpaceZustandInterface };

package/dist/states/reactflow.d.ts

@@ -0,0 +1,8 @@
+import { Connection, EdgeChange, NodeChange } from '@xyflow/react';
+import { RFStore } from './reactflow.t';
+declare const reactflowstore: ({ on_node_change, on_edge_change, on_connect, }: {
+    on_node_change?: (changes: NodeChange[]) => void;
+    on_edge_change?: (changes: EdgeChange[]) => void;
+    on_connect?: (connection: Connection) => void;
+}) => RFStore;
+export default reactflowstore;

package/dist/states/reactflow.t.d.ts

@@ -0,0 +1,11 @@
+import { UseBoundStore, StoreApi } from 'zustand';
+import { Edge, Node, OnNodesChange, OnEdgesChange, OnConnect } from '@xyflow/react';
+type RFState = {
+    nodes: Node[];
+    edges: Edge[];
+    onNodesChange: OnNodesChange;
+    onEdgesChange: OnEdgesChange;
+    onConnect: OnConnect;
+};
+type RFStore = UseBoundStore<StoreApi<RFState>>;
+export type { RFState, RFStore };

package/dist/types/versioned/v0/index.d.ts

@@ -0,0 +1,5 @@
+export * from './io.t';
+export * from './node.t';
+export * from './rendering.t';
+export * from './rendermappings.t';
+export * from './plugins.t';

package/dist/types/versioned/v0/io.t.d.ts

@@ -0,0 +1,29 @@
+import { BaseRenderOptions, EnumOf, SerializedType } from './rendering.t';
+export interface IORenderOptions extends BaseRenderOptions {
+    set_default: boolean;
+}
+export interface IOValueOptions {
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: (string | number)[] | EnumOf;
+    colorspace?: string;
+}
+export 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);
+}

package/dist/types/versioned/v0/node.t.d.ts

@@ -0,0 +1,75 @@
+import { UseBoundStore, StoreApi } from 'zustand';
+import { DataRenderOptions } from './rendering.t';
+import { DeepPartial } from '../../../utils/objects';
+import { IOType } from './io.t';
+import { TqdmState } from '../../../frontend/utils/progressbar';
+/**
+ * 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.
+ */
+export interface BaseNodeAction {
+    type: string;
+    from_remote: boolean;
+    id: string;
+    immediate?: boolean;
+}
+export 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.
+ */
+export 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.
+ */
+export interface NodeActionDelete extends BaseNodeAction {
+    type: "delete";
+}
+export interface NodeActionError extends BaseNodeAction {
+    type: "error";
+    errortype: string;
+    error: string;
+    tb?: string;
+}
+export interface NodeActionTrigger extends BaseNodeAction {
+    type: "trigger";
+}
+/**
+ * Type alias for NodeAction.
+ * A NodeAction can be either a NodeActionAdd, NodeActionUpdate, or NodeActionDelete.
+ */
+export type NodeAction = NodeActionAdd | NodeActionUpdate | NodeActionDelete | NodeActionError | NodeActionTrigger;
+export type NodeStore = UseBoundStore<StoreApi<NodeType>>;
+export interface NodeRenderOptions {
+    data?: DataRenderOptions;
+}
+export interface NodeType {
+    id: string;
+    node_name: string;
+    io: {
+        [key: string]: IOType | undefined;
+    };
+    frontend: {
+        pos: [number, number];
+        size: [number, number];
+        collapsed: boolean;
+    };
+    name: string;
+    in_trigger: boolean;
+    error?: string;
+    render_options?: NodeRenderOptions;
+    io_order: string[];
+    progress: TqdmState;
+}
+export type PartialNodeType = DeepPartial<NodeType>;

package/dist/types/versioned/v0/plugins.t.d.ts

@@ -0,0 +1,37 @@
+import { FuncNodesReactFlowZustandInterface } from '../../../states/fnrfzst.t';
+import { NodeContextType } from '../../../frontend/node/node';
+import { DataOverlayRendererType, DataPreviewViewRendererType, DataViewRendererType, HandlePreviewRendererType, InputRendererType, OutputRendererType } from './rendermappings.t';
+import * as React from "react";
+export type RenderPluginFactoryProps = {
+    React: typeof React;
+    fnrf_zst: FuncNodesReactFlowZustandInterface;
+    NodeContext: React.Context<NodeContextType | null>;
+};
+export interface RendererPlugin {
+    input_renderers?: {
+        [key: string]: InputRendererType | undefined;
+    };
+    output_renderers?: {
+        [key: string]: OutputRendererType | undefined;
+    };
+    handle_preview_renderers?: {
+        [key: string]: HandlePreviewRendererType | undefined;
+    };
+    data_overlay_renderers?: {
+        [key: string]: DataOverlayRendererType | undefined;
+    };
+    data_preview_renderers?: {
+        [key: string]: DataPreviewViewRendererType | undefined;
+    };
+    data_view_renderers?: {
+        [key: string]: DataViewRendererType | undefined;
+    };
+}
+export interface FuncNodesReactPlugin {
+    RendererPlugin?: RendererPlugin;
+    renderpluginfactory?: (props: RenderPluginFactoryProps) => RendererPlugin;
+    v?: 0 | "0";
+}
+export type AnyFuncNodesReactPlugin = FuncNodesReactPlugin;
+export type AnyRendererPlugin = RendererPlugin;
+export type AnyRenderPluginFactoryProps = RenderPluginFactoryProps;

package/dist/types/versioned/v0/rendering.t.d.ts

@@ -0,0 +1,42 @@
+export interface AllOf {
+    allOf: SerializedType[];
+}
+export interface AnyOf {
+    anyOf: SerializedType[];
+}
+export interface ArrayOf {
+    type: "array";
+    items: SerializedType;
+    uniqueItems: boolean;
+}
+export interface DictOf {
+    type: "object";
+    keys: SerializedType;
+    values: SerializedType;
+}
+export interface EnumOf {
+    type: "enum";
+    values: (number | string | boolean | null)[];
+    keys: string[];
+    nullable: boolean;
+}
+export interface TypeOf {
+    type: "type";
+    value: SerializedType;
+}
+export type SerializedType = string | AllOf | AnyOf | ArrayOf | DictOf | EnumOf | TypeOf;
+export type RenderType = "string" | "number" | "boolean" | "image" | SerializedType;
+export interface BaseRenderOptions {
+    type: RenderType;
+}
+export interface DataRenderOptions extends BaseRenderOptions {
+    src?: string;
+    preview_type?: string;
+}
+export interface StringRenderOptions extends BaseRenderOptions {
+    max_length?: number;
+}
+export interface ImageRenderOptions extends BaseRenderOptions {
+    format?: "png" | "jpeg";
+}
+export type RenderOptions = BaseRenderOptions | ImageRenderOptions | StringRenderOptions;

package/dist/types/versioned/v0/rendermappings.t.d.ts

@@ -0,0 +1,27 @@
+import { JSX } from 'react';
+import { IOType } from './io.t';
+export interface InputRendererProps {
+    io: IOType;
+    inputconverter: [(v: any) => any, (v: any) => any];
+}
+export type InputRendererType = ({ io, inputconverter, }: InputRendererProps) => JSX.Element;
+export type OutputRendererProps = {
+    io: IOType;
+};
+export type OutputRendererType = ({ io }: OutputRendererProps) => JSX.Element;
+export type DataViewRendererProps = {
+    io: IOType;
+};
+export type DataViewRendererType = ({ io, }: DataViewRendererProps) => JSX.Element;
+export type HandlePreviewRendererProps = {
+    io: IOType;
+};
+export type HandlePreviewRendererType = ({ io, }: HandlePreviewRendererProps) => JSX.Element;
+export type DataOverlayRendererProps = {
+    io: IOType;
+};
+export type DataOverlayRendererType = ({ io, }: DataOverlayRendererProps) => JSX.Element;
+export type DataPreviewViewRendererProps = {
+    io: IOType;
+};
+export type DataPreviewViewRendererType = ({ io, }: DataPreviewViewRendererProps) => JSX.Element;

package/dist/types/versioned/v1/index.d.ts

@@ -0,0 +1,5 @@
+export * from './io.t';
+export * from './node.t';
+export * from './rendering.t';
+export * from './rendermappings.t';
+export * from './plugins.t';