type Root<Scheme extends BaseSchemes> =
  | { data: Scheme["Node"]; type: "nodecreate" }
  | { data: Scheme["Node"]; type: "nodecreated" }
  | { data: Scheme["Node"]; type: "noderemove" }
  | { data: Scheme["Node"]; type: "noderemoved" }
  | { data: Scheme["Connection"]; type: "connectioncreate" }
  | { data: Scheme["Connection"]; type: "connectioncreated" }
  | { data: Scheme["Connection"]; type: "connectionremove" }
  | { data: Scheme["Connection"]; type: "connectionremoved" }
  | { type: "clear" }
  | { type: "clearcancelled" }
  | { type: "cleared" };

class NodeEditor<Scheme extends BaseSchemes>

addConnection(data: Scheme["Connection"]): Promise<boolean>

addNode(data: Scheme["Node"]): Promise<boolean>

clear(): Promise<boolean>

getConnection(id: Scheme["Connection"]["id"]): Scheme["Connection"]

getConnections(): Scheme["Connection"][]

getNode(id: Scheme["Node"]["id"]): Scheme["Node"]

getNodes(): Scheme["Node"][]

removeConnection(id: Scheme["Connection"]["id"]): Promise<boolean>

removeNode(id: Scheme["Node"]["id"]): Promise<boolean>

class Node<Inputs extends { [key in string]?: Socket }, Outputs extends { [key in string]?: Socket }, Controls extends { [key in string]?: Control }>

new Node('math')

controls: Controls;

id: string;

inputs: { [key in string | number | symbol]?: Input<Exclude<Inputs[key], undefined>> }

outputs: { [key in string | number | symbol]?: Output<Exclude<Outputs[key], undefined>> }

selected: boolean;

class Connection<Source extends Node, Target extends Node>

constructor(source: Source, sourceOutput: keyof Source["outputs"], target: Target, targetInput: keyof Target["inputs"]): Connection<Source, Target>

id: string;

source: string;

sourceOutput: keyof Source["outputs"]

target: string;

targetInput: keyof Target["inputs"]

class Socket

constructor(name: string): Socket

name: string;

class Input<S extends Socket>

constructor(socket: S, label: string, multipleConnections: boolean): Input<S>

control: Control;

id: string;

index: number;

label: string;

multipleConnections: boolean;

showControl: boolean;

socket: S;

addControl(control: Control): void

removeControl(): void

class Control

id: string;

index: number;

class Output<S extends Socket>

constructor(socket: S, label: string, multipleConnections: boolean): Output<S>

id: string;

index: number;

label: string;

multipleConnections: boolean;

socket: S;

class InputControl<T extends "text" | "number", N extends unknown>

new InputControl('text', { readonly: true, initial: 'hello' })

constructor(type: T, options: InputControlOptions<N>): InputControl<T, N>

id: string;

index: number;

options: InputControlOptions<N>;

type: T;

setValue(value: N): void

class Port<S extends Socket>

constructor(socket: S, label: string, multipleConnections: boolean): Port<S>

id: string;

index: number;

label: string;

multipleConnections: boolean;

socket: S;

class Scope<Produces extends unknown, Parents extends unknown[]>

class Signal<T extends unknown>

type BaseSchemes = GetSchemes<NodeBase, ConnectionBase>;

type ConnectionBase = { id: ConnectionId; source: NodeId; target: NodeId };

type ConnectionId = string;

type GetSchemes<
  NodeData extends NodeBase,
  ConnectionData extends ConnectionBase,
> = { Connection: ConnectionData; Node: NodeData };

GetSchemes<Node & { myProp: number }, Connection>

type NestedScope<
  S extends Scope<any, any[]>,
  Current extends any[],
> = CanAssignEach<Current, S["__scope"]["parents"]>[number] extends true
  ? S
  : "Parent signals do not satisfy the connected scope. Please use `.debug($ => $) for detailed assignment error";

type NodeBase = { id: NodeId };

type NodeId = string;

type Pipe<T extends unknown> = (
  data: T,
) => Promise<undefined | T> | undefined | T;

getUID(): string