({ in: inputs, out, exec, category, ...rest }: { name: string; label: string; aliases?: string

(severity: LogSeverity, text: string)

(condition: boolean, msg = '')

(event: T)

({ inputVals = {}, triggeringSocketName }: { /** input values to simulate on the input sockets *

(x: number, y: number, z: number, w: number)

( definition: OmitFactoryAndType< IFlowNodeDefinition<TInput, TOutput, TConfig, TState> > )

( a: number, b: number, tolerance: number = EPSILON )

(importWildcard: { [key: string]: INodeDefinition; })

(elements: number[])

(x: number, y: number, z: number)

(text: string)

(text: string)

(elements: number[])

(listener: (t: T) => void)

(result = new Mat4())

(registry: IRegistry)

({ graphJson, registry }: { graphJson: GraphJSON; registry: IRegistry; })

( node: INode, outputFlowSocketName: string, fiberCompletedListener: (() => void) | undefined = un

(registry: IRegistry)

(x: number, y: number)

(text: string, fallback = 0)

(listener: (t: T) => void)

(start: number, end: number, step = 1)

(elements: number[])

(elements: number[])

( limitInSeconds = 100, limitInSteps = 100000000 )

()

( nodes: NodeSpecJSON[], nodeType: string | undefined, handleType: 'source' | 'target' | null )

(func: () => T)

({ nodeInputVals = {}, configuration = {}, exec, makeGraph = makeEmptyGraph }: { /** Exec function f

( { triggered, initialState, out }: { /** Triggered function from the node defintion */

(value: any)

( nodeType: NodeType, { typeName, in: inputs, out, otherTypeNames = [], category = Nod

( definition: OmitFactoryAndType< IEventNodeDefinition<TInput, TOutput, TConfig, TState> > )

( definition: OmitFactoryAndType<IFunctionNodeDefinition<TInput, TOutput>> )

({ variables = {}, customEvents = {}, values, dependencies = {} }: { customEvents?: GraphCustomEvent

(a: Mat4, b: Mat4, result = new Mat4())

(registry: IRegistry)

(a: Vec3)

( a: Vec3, b: Vec3, t: number, result = new Vec3() )

( a: Vec3, b: number, result = new Vec3() )

(text: string, result = new Vec3())

(registry: IRegistry)

()

(result = new Vec4())

({ graph, registry, nodeTypeName, nodeConfiguration = {} }: { graph: IGraph; registry: IRegistry;

( nodes: Node[], edges: Edge[], nodeSpecJSON: NodeSpecJSON[] )

( property: ResourceProperties | undefined, resource: Resource )

( { resource, index }: Pick<Path, 'resource' | 'index'>, properties: Properties )

(p: number, q: number, t: number)

( edges: Edge[], nodeId: string, handleId: string, type: 'source' | 'target' )

( socketConfigOrFactory: SocketsDefinition, nodeConfig: NodeConfiguration, graph: IGraph )

(jsonPath: string, short = false)

(text: string, fallback = 0)

( inputs: Socket[], inputName: string, nodeTypeName: string )

()

(nodes: GraphNodes)

(nodes: GraphNodes)

(values: ValueTypeMap)

(a: Vec3, b: Vec3, result = new Vec3())

( a: Vec3, b: Vec3, tolerance: number = EPSILON )

(a: Vec3, result = new Vec3())

(a: Vec4, b: Vec4)

( a: Vec4, b: number, result = new Vec4() )

(text: string, result = new Vec4())

( outputs: Socket[], outputName: string, value: T, nodeTypeName: string )

(graph: GraphJSON)

( node: INode, outputSocketName: string, fiberCompletedListener: (() => void) | undefined = undefi

()

()

(limitInSeconds = 100, limitInSteps = 100000000)

()

( nodes: Node[], params: OnConnectStartParams | undefined, specJSON: NodeSpecJSON[] | undefined )

()

(jsonPath: string, valueTypeName: string)

({ values, valueTypeName }: { values: ValueTypeMap; valueTypeName: string; })

(node: INode)

(node: INode)

(node: INode)

(node: INode)

( connection: Connection, instance: ReactFlowInstance, specJSON: NodeSpecJSON[] )

( key: string, { valueType, defaultValue, choices }: SocketDefinition )

(m: Mat3, result = new Vec3())

(a: Mat3, result = new Mat4())

(a: Mat4, result = new Mat3())

(q: Vec4, result = new Mat3())

( engine: Engine, inputSocket: Socket )

(jsonPath: string, valueTypeName: string, value: any)

(text: string)

(value: Vector3)

(fiber: Fiber, triggeringSocketName: string)

( key: string, callback: (e: KeyboardEvent) => void )

(a: Vec2, b: Vec2)

( array: Float32Array | number[], offset = 0, result: Vec2 = new Vec2() )

(a: Vec2)

( a: Vec2, b: number, result: Vec2 = new Vec2() )

(text: string, result = new Vec2())

(a: Vec3, b: Vec3)