@codebolt/litegraph 0.0.1

package/dist/LGraphNode.d.ts

@@ -0,0 +1,883 @@
+import { DragAndScale } from './DragAndScale';
+import { IDrawBoundingOptions } from './draw';
+import { ReadOnlyRectangle } from './infrastructure/Rectangle';
+import { ColorOption, CompassCorners, DefaultConnectionColors, Dictionary, IColorable, IContextMenuValue, IFoundSlot, INodeFlags, INodeInputSlot, INodeOutputSlot, INodeSlotContextItem, IPinnable, ISlotType, Point, Positionable, ReadOnlyPoint, ReadOnlyRect, Rect, Size } from './interfaces';
+import { LGraph } from './LGraph';
+import { Reroute, RerouteId } from './Reroute';
+import { SubgraphInputNode } from './subgraph/SubgraphInputNode';
+import { SubgraphOutputNode } from './subgraph/SubgraphOutputNode';
+import { CanvasPointerEvent } from './types/events';
+import { NodeLike } from './types/NodeLike';
+import { ISerialisedNode, SubgraphIO } from './types/serialisation';
+import { IBaseWidget, IWidgetOptions, TWidgetType, TWidgetValue } from './types/widgets';
+import { BadgePosition, LGraphBadge } from './LGraphBadge';
+import { LGraphButton, LGraphButtonOptions } from './LGraphButton';
+import { LGraphCanvas } from './LGraphCanvas';
+import { LGraphNodeConstructor, Subgraph, SubgraphNode } from './litegraph';
+import { LLink } from './LLink';
+import { LGraphEventMode, RenderShape, TitleMode } from './types/globalEnums';
+import { WidgetTypeMap } from './widgets/widgetMap';
+export type NodeId = number | string;
+export type NodeProperty = string | number | boolean | object;
+export interface INodePropertyInfo {
+    name: string;
+    type?: string;
+    default_value: NodeProperty | undefined;
+}
+export interface IMouseOverData {
+    inputId?: number;
+    outputId?: number;
+    overWidget?: IBaseWidget;
+}
+export interface ConnectByTypeOptions {
+    /** @deprecated Events */
+    createEventInCase?: boolean;
+    /** Allow our wildcard slot to connect to typed slots on remote node. Default: true */
+    wildcardToTyped?: boolean;
+    /** Allow our typed slot to connect to wildcard slots on remote node. Default: true */
+    typedToWildcard?: boolean;
+    /** The {@link Reroute.id} that the connection is being dragged from. */
+    afterRerouteId?: RerouteId;
+}
+/** Internal type used for type safety when implementing generic checks for inputs & outputs */
+export interface IGenericLinkOrLinks {
+    links?: INodeOutputSlot["links"];
+    link?: INodeInputSlot["link"];
+}
+export interface FindFreeSlotOptions {
+    /** Slots matching these types will be ignored.  Default: [] */
+    typesNotAccepted?: ISlotType[];
+    /** If true, the slot itself is returned instead of the index.  Default: false */
+    returnObj?: boolean;
+}
+interface DrawSlotsOptions {
+    fromSlot?: INodeInputSlot | INodeOutputSlot;
+    colorContext: DefaultConnectionColors;
+    editorAlpha: number;
+    lowQuality: boolean;
+}
+interface DrawWidgetsOptions {
+    lowQuality?: boolean;
+    editorAlpha?: number;
+}
+interface DrawTitleOptions {
+    scale: number;
+    title_height?: number;
+    low_quality?: boolean;
+}
+interface DrawTitleTextOptions extends DrawTitleOptions {
+    default_title_color: string;
+}
+interface DrawTitleBoxOptions extends DrawTitleOptions {
+    box_size?: number;
+}
+export interface LGraphNode {
+    constructor: LGraphNodeConstructor;
+}
+/**
+ * Base class for all nodes
+ * @param title a name for the node
+ * @param type a type for the node
+ */
+export declare class LGraphNode implements NodeLike, Positionable, IPinnable, IColorable {
+    #private;
+    static title?: string;
+    static MAX_CONSOLE?: number;
+    static type?: string;
+    static category?: string;
+    static filter?: string;
+    static skip_list?: boolean;
+    static resizeHandleSize: number;
+    static resizeEdgeSize: number;
+    /** Default setting for {@link LGraphNode.connectInputToOutput}. @see {@link INodeFlags.keepAllLinksOnBypass} */
+    static keepAllLinksOnBypass: boolean;
+    /** The title text of the node. */
+    title: string;
+    /**
+     * The font style used to render the node's title text.
+     */
+    get titleFontStyle(): string;
+    get innerFontStyle(): string;
+    get displayType(): string;
+    graph: LGraph | Subgraph | null;
+    id: NodeId;
+    type: string;
+    inputs: INodeInputSlot[];
+    outputs: INodeOutputSlot[];
+    properties: Dictionary<NodeProperty | undefined>;
+    properties_info: INodePropertyInfo[];
+    flags: INodeFlags;
+    widgets?: IBaseWidget[];
+    /**
+     * The amount of space available for widgets to grow into.
+     * @see {@link layoutWidgets}
+     */
+    freeWidgetSpace?: number;
+    locked?: boolean;
+    /** Execution order, automatically computed during run @see {@link LGraph.computeExecutionOrder} */
+    order: number;
+    mode: LGraphEventMode;
+    last_serialization?: ISerialisedNode;
+    serialize_widgets?: boolean;
+    /**
+     * The overridden fg color used to render the node.
+     * @see {@link renderingColor}
+     */
+    color?: string;
+    /**
+     * The overridden bg color used to render the node.
+     * @see {@link renderingBgColor}
+     */
+    bgcolor?: string;
+    /**
+     * The overridden box color used to render the node.
+     * @see {@link renderingBoxColor}
+     */
+    boxcolor?: string;
+    /** The fg color used to render the node. */
+    get renderingColor(): string;
+    /** The bg color used to render the node. */
+    get renderingBgColor(): string;
+    /** The box color used to render the node. */
+    get renderingBoxColor(): string;
+    /** @inheritdoc {@link IColorable.setColorOption} */
+    setColorOption(colorOption: ColorOption | null): void;
+    /** @inheritdoc {@link IColorable.getColorOption} */
+    getColorOption(): ColorOption | null;
+    /**
+     * The stroke styles that should be applied to the node.
+     */
+    strokeStyles: Record<string, (this: LGraphNode) => IDrawBoundingOptions | undefined>;
+    /**
+     * The progress of node execution. Used to render a progress bar. Value between 0 and 1.
+     */
+    progress?: number;
+    exec_version?: number;
+    action_call?: string;
+    execute_triggered?: number;
+    action_triggered?: number;
+    widgets_up?: boolean;
+    widgets_start_y?: number;
+    lostFocusAt?: number;
+    gotFocusAt?: number;
+    badges: (LGraphBadge | (() => LGraphBadge))[];
+    title_buttons: LGraphButton[];
+    badgePosition: BadgePosition;
+    onOutputRemoved?(this: LGraphNode, slot: number): void;
+    onInputRemoved?(this: LGraphNode, slot: number, input: INodeInputSlot): void;
+    /**
+     * The width of the node when collapsed.
+     * Updated by {@link LGraphCanvas.drawNode}
+     */
+    _collapsed_width?: number;
+    /**
+     * Called once at the start of every frame.  Caller may change the values in {@link out}, which will be reflected in {@link boundingRect}.
+     * WARNING: Making changes to boundingRect via onBounding is poorly supported, and will likely result in strange behaviour.
+     */
+    onBounding?(this: LGraphNode, out: Rect): void;
+    console?: string[];
+    _level?: number;
+    _shape?: RenderShape;
+    mouseOver?: IMouseOverData;
+    redraw_on_mouse?: boolean;
+    resizable?: boolean;
+    clonable?: boolean;
+    _relative_id?: number;
+    clip_area?: boolean;
+    ignore_remove?: boolean;
+    has_errors?: boolean;
+    removable?: boolean;
+    block_delete?: boolean;
+    selected?: boolean;
+    showAdvanced?: boolean;
+    comfyClass?: string;
+    isVirtualNode?: boolean;
+    applyToGraph?(extraLinks?: LLink[]): void;
+    isSubgraphNode(): this is SubgraphNode;
+    /**
+     * Rect describing the node area, including shadows and any protrusions.
+     * Determines if the node is visible.  Calculated once at the start of every frame.
+     */
+    get renderArea(): ReadOnlyRect;
+    /**
+     * Cached node position & area as `x, y, width, height`.  Includes changes made by {@link onBounding}, if present.
+     *
+     * Determines the node hitbox and other rendering effects.  Calculated once at the start of every frame.
+     */
+    get boundingRect(): ReadOnlyRectangle;
+    /** The offset from {@link pos} to the top-left of {@link boundingRect}. */
+    get boundingOffset(): ReadOnlyPoint;
+    /** {@link pos} and {@link size} values are backed by this {@link Rect}. */
+    _posSize: Float32Array;
+    _pos: Point;
+    _size: Size;
+    get pos(): Point;
+    /** Node position does not necessarily correlate to the top-left corner. */
+    set pos(value: Point);
+    get size(): Size;
+    set size(value: Size);
+    /**
+     * The size of the node used for rendering.
+     */
+    get renderingSize(): Size;
+    get shape(): RenderShape | undefined;
+    set shape(v: RenderShape | "default" | "box" | "round" | "circle" | "card");
+    /**
+     * The shape of the node used for rendering. @see {@link RenderShape}
+     */
+    get renderingShape(): RenderShape;
+    get is_selected(): boolean | undefined;
+    set is_selected(value: boolean);
+    get title_mode(): TitleMode;
+    onConnectInput?(this: LGraphNode, target_slot: number, type: unknown, output: INodeOutputSlot | SubgraphIO, node: LGraphNode | SubgraphInputNode, slot: number): boolean;
+    onConnectOutput?(this: LGraphNode, slot: number, type: unknown, input: INodeInputSlot | SubgraphIO, target_node: number | LGraphNode | SubgraphOutputNode, target_slot: number): boolean;
+    onResize?(this: LGraphNode, size: Size): void;
+    onPropertyChanged?(this: LGraphNode, name: string, value: unknown, prev_value?: unknown): boolean;
+    /** Called for each connection that is created, updated, or removed. This includes "restored" connections when deserialising. */
+    onConnectionsChange?(this: LGraphNode, type: ISlotType, index: number, isConnected: boolean, link_info: LLink | null | undefined, inputOrOutput: INodeInputSlot | INodeOutputSlot | SubgraphIO): void;
+    onInputAdded?(this: LGraphNode, input: INodeInputSlot): void;
+    onOutputAdded?(this: LGraphNode, output: INodeOutputSlot): void;
+    onConfigure?(this: LGraphNode, serialisedNode: ISerialisedNode): void;
+    onSerialize?(this: LGraphNode, serialised: ISerialisedNode): any;
+    onExecute?(this: LGraphNode, param?: unknown, options?: {
+        action_call?: any;
+    }): void;
+    onAction?(this: LGraphNode, action: string, param: unknown, options: {
+        action_call?: string;
+    }): void;
+    onDrawBackground?(this: LGraphNode, ctx: CanvasRenderingContext2D): void;
+    onNodeCreated?(this: LGraphNode): void;
+    /**
+     * Callback invoked by {@link connect} to override the target slot index.
+     * Its return value overrides the target index selection.
+     * @param target_slot The current input slot index
+     * @param requested_slot The originally requested slot index - could be negative, or if using (deprecated) name search, a string
+     * @returns {number | null} If a number is returned, the connection will be made to that input index.
+     * If an invalid index or non-number (false, null, NaN etc) is returned, the connection will be cancelled.
+     */
+    onBeforeConnectInput?(this: LGraphNode, target_slot: number, requested_slot?: number | string): number | false | null;
+    onShowCustomPanelInfo?(this: LGraphNode, panel: any): void;
+    onAddPropertyToPanel?(this: LGraphNode, pName: string, panel: any): boolean;
+    onWidgetChanged?(this: LGraphNode, name: string, value: unknown, old_value: unknown, w: IBaseWidget): void;
+    onDeselected?(this: LGraphNode): void;
+    onKeyUp?(this: LGraphNode, e: KeyboardEvent): void;
+    onKeyDown?(this: LGraphNode, e: KeyboardEvent): void;
+    onSelected?(this: LGraphNode): void;
+    getExtraMenuOptions?(this: LGraphNode, canvas: LGraphCanvas, options: (IContextMenuValue<unknown> | null)[]): (IContextMenuValue<unknown> | null)[];
+    getMenuOptions?(this: LGraphNode, canvas: LGraphCanvas): IContextMenuValue[];
+    onAdded?(this: LGraphNode, graph: LGraph): void;
+    onDrawCollapsed?(this: LGraphNode, ctx: CanvasRenderingContext2D, cavnas: LGraphCanvas): boolean;
+    onDrawForeground?(this: LGraphNode, ctx: CanvasRenderingContext2D, canvas: LGraphCanvas, canvasElement: HTMLCanvasElement): void;
+    onMouseLeave?(this: LGraphNode, e: CanvasPointerEvent): void;
+    /**
+     * Override the default slot menu options.
+     */
+    getSlotMenuOptions?(this: LGraphNode, slot: IFoundSlot): IContextMenuValue[];
+    /**
+     * Add extra menu options to the slot context menu.
+     */
+    getExtraSlotMenuOptions?(this: LGraphNode, slot: IFoundSlot): IContextMenuValue[];
+    onDropItem?(this: LGraphNode, event: Event): boolean;
+    onDropData?(this: LGraphNode, data: string | ArrayBuffer, filename: any, file: any): void;
+    onDropFile?(this: LGraphNode, file: any): void;
+    onInputClick?(this: LGraphNode, index: number, e: CanvasPointerEvent): void;
+    onInputDblClick?(this: LGraphNode, index: number, e: CanvasPointerEvent): void;
+    onOutputClick?(this: LGraphNode, index: number, e: CanvasPointerEvent): void;
+    onOutputDblClick?(this: LGraphNode, index: number, e: CanvasPointerEvent): void;
+    onGetPropertyInfo?(this: LGraphNode, property: string): any;
+    onNodeOutputAdd?(this: LGraphNode, value: unknown): void;
+    onNodeInputAdd?(this: LGraphNode, value: unknown): void;
+    onMenuNodeInputs?(this: LGraphNode, entries: (IContextMenuValue<INodeSlotContextItem> | null)[]): (IContextMenuValue<INodeSlotContextItem> | null)[];
+    onMenuNodeOutputs?(this: LGraphNode, entries: (IContextMenuValue<INodeSlotContextItem> | null)[]): (IContextMenuValue<INodeSlotContextItem> | null)[];
+    onMouseUp?(this: LGraphNode, e: CanvasPointerEvent, pos: Point): void;
+    onMouseEnter?(this: LGraphNode, e: CanvasPointerEvent): void;
+    /** Blocks drag if return value is truthy. @param pos Offset from {@link LGraphNode.pos}. */
+    onMouseDown?(this: LGraphNode, e: CanvasPointerEvent, pos: Point, canvas: LGraphCanvas): boolean;
+    /** @param pos Offset from {@link LGraphNode.pos}. */
+    onDblClick?(this: LGraphNode, e: CanvasPointerEvent, pos: Point, canvas: LGraphCanvas): void;
+    /** @param pos Offset from {@link LGraphNode.pos}. */
+    onNodeTitleDblClick?(this: LGraphNode, e: CanvasPointerEvent, pos: Point, canvas: LGraphCanvas): void;
+    onDrawTitle?(this: LGraphNode, ctx: CanvasRenderingContext2D): void;
+    onDrawTitleText?(this: LGraphNode, ctx: CanvasRenderingContext2D, title_height: number, size: Size, scale: number, title_text_font: string, selected?: boolean): void;
+    onDrawTitleBox?(this: LGraphNode, ctx: CanvasRenderingContext2D, title_height: number, size: Size, scale: number): void;
+    onDrawTitleBar?(this: LGraphNode, ctx: CanvasRenderingContext2D, title_height: number, size: Size, scale: number, fgcolor: any): void;
+    onRemoved?(this: LGraphNode): void;
+    onMouseMove?(this: LGraphNode, e: CanvasPointerEvent, pos: Point, arg2: LGraphCanvas): void;
+    onPropertyChange?(this: LGraphNode): void;
+    updateOutputData?(this: LGraphNode, origin_slot: number): void;
+    constructor(title: string, type?: string);
+    /** Internal callback for subgraph nodes. Do not implement externally. */
+    _internalConfigureAfterSlots?(): void;
+    /**
+     * configure a node from an object containing the serialized info
+     */
+    configure(info: ISerialisedNode): void;
+    /**
+     * serialize the content
+     */
+    serialize(): ISerialisedNode;
+    clone(): LGraphNode | null;
+    /**
+     * serialize and stringify
+     */
+    toString(): string;
+    /**
+     * get the title string
+     */
+    getTitle(): string;
+    /**
+     * sets the value of a property
+     * @param name
+     * @param value
+     */
+    setProperty(name: string, value: TWidgetValue): void;
+    /**
+     * sets the output data
+     * @param slot
+     * @param data
+     */
+    setOutputData(slot: number, data: number | string | boolean | {
+        toToolTip?(): string;
+    }): void;
+    /**
+     * sets the output data type, useful when you want to be able to overwrite the data type
+     */
+    setOutputDataType(slot: number, type: ISlotType): void;
+    /**
+     * Retrieves the input data (data traveling through the connection) from one slot
+     * @param slot
+     * @param force_update if set to true it will force the connected node of this slot to output data into this link
+     * @returns data or if it is not connected returns undefined
+     */
+    getInputData(slot: number, force_update?: boolean): unknown;
+    /**
+     * Retrieves the input data type (in case this supports multiple input types)
+     * @param slot
+     * @returns datatype in string format
+     */
+    getInputDataType(slot: number): ISlotType | null;
+    /**
+     * Retrieves the input data from one slot using its name instead of slot number
+     * @param slot_name
+     * @param force_update if set to true it will force the connected node of this slot to output data into this link
+     * @returns data or if it is not connected returns null
+     */
+    getInputDataByName(slot_name: string, force_update: boolean): unknown;
+    /**
+     * tells you if there is a connection in one input slot
+     * @param slot The 0-based index of the input to check
+     * @returns `true` if the input slot has a link ID (does not perform validation)
+     */
+    isInputConnected(slot: number): boolean;
+    /**
+     * tells you info about an input connection (which node, type, etc)
+     * @returns object or null { link: id, name: string, type: string or 0 }
+     */
+    getInputInfo(slot: number): INodeInputSlot | null;
+    /**
+     * Returns the link info in the connection of an input slot
+     * @returns object or null
+     */
+    getInputLink(slot: number): LLink | null;
+    /**
+     * returns the node connected in the input slot
+     * @returns node or null
+     */
+    getInputNode(slot: number): LGraphNode | null;
+    /**
+     * returns the value of an input with this name, otherwise checks if there is a property with that name
+     * @returns value
+     */
+    getInputOrProperty(name: string): unknown;
+    /**
+     * tells you the last output data that went in that slot
+     * @returns object or null
+     */
+    getOutputData(slot: number): unknown;
+    /**
+     * tells you info about an output connection (which node, type, etc)
+     * @returns object or null { name: string, type: string, links: [ ids of links in number ] }
+     */
+    getOutputInfo(slot: number): INodeOutputSlot | null;
+    /**
+     * tells you if there is a connection in one output slot
+     */
+    isOutputConnected(slot: number): boolean;
+    /**
+     * tells you if there is any connection in the output slots
+     */
+    isAnyOutputConnected(): boolean;
+    /**
+     * retrieves all the nodes connected to this output slot
+     */
+    getOutputNodes(slot: number): LGraphNode[] | null;
+    addOnTriggerInput(): number;
+    addOnExecutedOutput(): number;
+    onAfterExecuteNode(param: unknown, options?: {
+        action_call?: any;
+    }): void;
+    changeMode(modeTo: number): boolean;
+    /**
+     * Triggers the node code execution, place a boolean/counter to mark the node as being executed
+     */
+    doExecute(param?: unknown, options?: {
+        action_call?: any;
+    }): void;
+    /**
+     * Triggers an action, wrapped by logics to control execution flow
+     * @param action name
+     */
+    actionDo(action: string, param: unknown, options: {
+        action_call?: string;
+    }): void;
+    /**
+     * Triggers an event in this node, this will trigger any output with the same name
+     * @param action name ( "on_play", ... ) if action is equivalent to false then the event is send to all
+     */
+    trigger(action: string, param: unknown, options: {
+        action_call?: any;
+    }): void;
+    /**
+     * Triggers a slot event in this node: cycle output slots and launch execute/action on connected nodes
+     * @param slot the index of the output slot
+     * @param link_id [optional] in case you want to trigger and specific output link in a slot
+     */
+    triggerSlot(slot: number, param: unknown, link_id: number | null, options?: {
+        action_call?: any;
+    }): void;
+    /**
+     * clears the trigger slot animation
+     * @param slot the index of the output slot
+     * @param link_id [optional] in case you want to trigger and specific output link in a slot
+     */
+    clearTriggeredSlot(slot: number, link_id: number): void;
+    /**
+     * changes node size and triggers callback
+     */
+    setSize(size: Size): void;
+    /**
+     * Expands the node size to fit its content.
+     */
+    expandToFitContent(): void;
+    /**
+     * add a new property to this node
+     * @param type string defining the output type ("vec3","number",...)
+     * @param extra_info this can be used to have special properties of the property (like values, etc)
+     */
+    addProperty(name: string, default_value: NodeProperty | undefined, type?: string, extra_info?: Partial<INodePropertyInfo>): INodePropertyInfo;
+    /**
+     * add a new output slot to use in this node
+     * @param type string defining the output type ("vec3","number",...)
+     * @param extra_info this can be used to have special properties of an output (label, special color, position, etc)
+     */
+    addOutput<TProperties extends Partial<INodeOutputSlot>>(name: string, type: ISlotType, extra_info?: TProperties): INodeOutputSlot & TProperties;
+    /**
+     * remove an existing output slot
+     */
+    removeOutput(slot: number): void;
+    /**
+     * add a new input slot to use in this node
+     * @param type string defining the input type ("vec3","number",...), it its a generic one use 0
+     * @param extra_info this can be used to have special properties of an input (label, color, position, etc)
+     */
+    addInput<TProperties extends Partial<INodeInputSlot>>(name: string, type: ISlotType, extra_info?: TProperties): INodeInputSlot & TProperties;
+    /**
+     * remove an existing input slot
+     */
+    removeInput(slot: number): void;
+    /**
+     * computes the minimum size of a node according to its inputs and output slots
+     * @returns the total size
+     */
+    computeSize(out?: Size): Size;
+    inResizeCorner(canvasX: number, canvasY: number): boolean;
+    /**
+     * Returns which resize corner the point is over, if any.
+     * @param canvasX X position in canvas coordinates
+     * @param canvasY Y position in canvas coordinates
+     * @returns The compass corner the point is in, otherwise `undefined`.
+     */
+    findResizeDirection(canvasX: number, canvasY: number): CompassCorners | undefined;
+    /**
+     * returns all the info available about a property of this node.
+     * @param property name of the property
+     * @returns the object with all the available info
+     */
+    getPropertyInfo(property: string): any;
+    /**
+     * Defines a widget inside the node, it will be rendered on top of the node, you can control lots of properties
+     * @param type the widget type
+     * @param name the text to show on the widget
+     * @param value the default value
+     * @param callback function to call when it changes (optionally, it can be the name of the property to modify)
+     * @param options the object that contains special properties of this widget
+     * @returns the created widget object
+     */
+    addWidget<Type extends TWidgetType, TValue extends WidgetTypeMap[Type]["value"]>(type: Type, name: string, value: TValue, callback: IBaseWidget["callback"] | string | null, options?: IWidgetOptions | string): WidgetTypeMap[Type] | IBaseWidget;
+    addCustomWidget<TPlainWidget extends IBaseWidget>(custom_widget: TPlainWidget): TPlainWidget | WidgetTypeMap[TPlainWidget["type"]];
+    addTitleButton(options: LGraphButtonOptions): LGraphButton;
+    onTitleButtonClick(button: LGraphButton, canvas: LGraphCanvas): void;
+    removeWidgetByName(name: string): void;
+    removeWidget(widget: IBaseWidget): void;
+    ensureWidgetRemoved(widget: IBaseWidget): void;
+    move(deltaX: number, deltaY: number): void;
+    /**
+     * Internal method to measure the node for rendering.  Prefer {@link boundingRect} where possible.
+     *
+     * Populates {@link out} with the results in graph space.
+     * Populates {@link _collapsed_width} with the collapsed width if the node is collapsed.
+     * Adjusts for title and collapsed status, but does not call {@link onBounding}.
+     * @param out `x, y, width, height` are written to this array.
+     * @param ctx The canvas context to use for measuring text.
+     */
+    measure(out: Rect, ctx: CanvasRenderingContext2D): void;
+    /**
+     * returns the bounding of the object, used for rendering purposes
+     * @param out {Float32Array[4]?} [optional] a place to store the output, to free garbage
+     * @param includeExternal {boolean?} [optional] set to true to
+     * include the shadow and connection points in the bounding calculation
+     * @returns the bounding box in format of [topleft_cornerx, topleft_cornery, width, height]
+     */
+    getBounding(out?: Rect, includeExternal?: boolean): Rect;
+    /**
+     * Calculates the render area of this node, populating both {@link boundingRect} and {@link renderArea}.
+     * Called automatically at the start of every frame.
+     */
+    updateArea(ctx: CanvasRenderingContext2D): void;
+    /**
+     * checks if a point is inside the shape of a node
+     */
+    isPointInside(x: number, y: number): boolean;
+    /**
+     * Checks if the provided point is inside this node's collapse button area.
+     * @param x X co-ordinate to check
+     * @param y Y co-ordinate to check
+     * @returns true if the x,y point is in the collapse button area, otherwise false
+     */
+    isPointInCollapse(x: number, y: number): boolean;
+    /**
+     * Returns the input slot at the given position. Uses full 20 height, and approximates the label length.
+     * @param pos The graph co-ordinates to check
+     * @returns The input slot at the given position if found, otherwise `undefined`.
+     */
+    getInputOnPos(pos: Point): INodeInputSlot | undefined;
+    /**
+     * Returns the output slot at the given position. Uses full 20x20 box for the slot.
+     * @param pos The graph co-ordinates to check
+     * @returns The output slot at the given position if found, otherwise `undefined`.
+     */
+    getOutputOnPos(pos: Point): INodeOutputSlot | undefined;
+    /**
+     * Returns the input or output slot at the given position.
+     *
+     * Tries {@link getNodeInputOnPos} first, then {@link getNodeOutputOnPos}.
+     * @param pos The graph co-ordinates to check
+     * @returns The input or output slot at the given position if found, otherwise `undefined`.
+     */
+    getSlotOnPos(pos: Point): INodeInputSlot | INodeOutputSlot | undefined;
+    /**
+     * @deprecated Use {@link getSlotOnPos} instead.
+     * checks if a point is inside a node slot, and returns info about which slot
+     * @param x
+     * @param y
+     * @returns if found the object contains { input|output: slot object, slot: number, link_pos: [x,y] }
+     */
+    getSlotInPosition(x: number, y: number): IFoundSlot | null;
+    /**
+     * Gets the widget on this node at the given co-ordinates.
+     * @param canvasX X co-ordinate in graph space
+     * @param canvasY Y co-ordinate in graph space
+     * @returns The widget found, otherwise `null`
+     */
+    getWidgetOnPos(canvasX: number, canvasY: number, includeDisabled?: boolean): IBaseWidget | undefined;
+    /**
+     * Returns the input slot with a given name (used for dynamic slots), -1 if not found
+     * @param name the name of the slot to find
+     * @param returnObj if the obj itself wanted
+     * @returns the slot (-1 if not found)
+     */
+    findInputSlot<TReturn extends false>(name: string, returnObj?: TReturn): number;
+    findInputSlot<TReturn extends true>(name: string, returnObj?: TReturn): INodeInputSlot;
+    /**
+     * returns the output slot with a given name (used for dynamic slots), -1 if not found
+     * @param name the name of the slot to find
+     * @param returnObj if the obj itself wanted
+     * @returns the slot (-1 if not found)
+     */
+    findOutputSlot<TReturn extends false>(name: string, returnObj?: TReturn): number;
+    findOutputSlot<TReturn extends true>(name: string, returnObj?: TReturn): INodeOutputSlot;
+    /**
+     * Finds the first free input slot.
+     * @param optsIn
+     * @returns The index of the first matching slot, the slot itself if returnObj is true, or -1 if not found.
+     */
+    findInputSlotFree<TReturn extends false>(optsIn?: FindFreeSlotOptions & {
+        returnObj?: TReturn;
+    }): number;
+    findInputSlotFree<TReturn extends true>(optsIn?: FindFreeSlotOptions & {
+        returnObj?: TReturn;
+    }): INodeInputSlot | -1;
+    /**
+     * Finds the first free output slot.
+     * @param optsIn
+     * @returns The index of the first matching slot, the slot itself if returnObj is true, or -1 if not found.
+     */
+    findOutputSlotFree<TReturn extends false>(optsIn?: FindFreeSlotOptions & {
+        returnObj?: TReturn;
+    }): number;
+    findOutputSlotFree<TReturn extends true>(optsIn?: FindFreeSlotOptions & {
+        returnObj?: TReturn;
+    }): INodeOutputSlot | -1;
+    /**
+     * findSlotByType for INPUTS
+     */
+    findInputSlotByType<TReturn extends false>(type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): number;
+    findInputSlotByType<TReturn extends true>(type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): INodeInputSlot;
+    /**
+     * findSlotByType for OUTPUTS
+     */
+    findOutputSlotByType<TReturn extends false>(type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): number;
+    findOutputSlotByType<TReturn extends true>(type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): INodeOutputSlot;
+    /**
+     * returns the output (or input) slot with a given type, -1 if not found
+     * @param input uise inputs instead of outputs
+     * @param type the type of the slot to find
+     * @param returnObj if the obj itself wanted
+     * @param preferFreeSlot if we want a free slot (if not found, will return the first of the type anyway)
+     * @returns the slot (-1 if not found)
+     */
+    findSlotByType<TSlot extends true | false, TReturn extends false>(input: TSlot, type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): number;
+    findSlotByType<TSlot extends true, TReturn extends true>(input: TSlot, type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): INodeInputSlot | -1;
+    findSlotByType<TSlot extends false, TReturn extends true>(input: TSlot, type: ISlotType, returnObj?: TReturn, preferFreeSlot?: boolean, doNotUseOccupied?: boolean): INodeOutputSlot | -1;
+    /**
+     * Determines the slot index to connect to when attempting to connect by type.
+     * @param findInputs If true, searches for an input.  Otherwise, an output.
+     * @param node The node at the other end of the connection.
+     * @param slotType The type of slot at the other end of the connection.
+     * @param options Search restrictions to adhere to.
+     * @see {connectByType}
+     * @see {connectByTypeOutput}
+     */
+    findConnectByTypeSlot(findInputs: boolean, node: LGraphNode, slotType: ISlotType, options?: ConnectByTypeOptions): number | undefined;
+    /**
+     * Finds the first free output slot with any of the comma-delimited types in {@link type}.
+     *
+     * If no slots are free, falls back in order to:
+     * - The first free wildcard slot
+     * - The first occupied slot
+     * - The first occupied wildcard slot
+     * @param type The {@link ISlotType type} of slot to find
+     * @returns The index and slot if found, otherwise `undefined`.
+     */
+    findOutputByType(type: ISlotType): {
+        index: number;
+        slot: INodeOutputSlot;
+    } | undefined;
+    /**
+     * Finds the first free input slot with any of the comma-delimited types in {@link type}.
+     *
+     * If no slots are free, falls back in order to:
+     * - The first free wildcard slot
+     * - The first occupied slot
+     * - The first occupied wildcard slot
+     * @param type The {@link ISlotType type} of slot to find
+     * @returns The index and slot if found, otherwise `undefined`.
+     */
+    findInputByType(type: ISlotType): {
+        index: number;
+        slot: INodeInputSlot;
+    } | undefined;
+    /**
+     * connect this node output to the input of another node BY TYPE
+     * @param slot (could be the number of the slot or the string with the name of the slot)
+     * @param target_node the target node
+     * @param target_slotType the input slot type of the target node
+     * @returns the link_info is created, otherwise null
+     */
+    connectByType(slot: number | string, target_node: LGraphNode, target_slotType: ISlotType, optsIn?: ConnectByTypeOptions): LLink | null;
+    /**
+     * connect this node input to the output of another node BY TYPE
+     * @param slot (could be the number of the slot or the string with the name of the slot)
+     * @param source_node the target node
+     * @param source_slotType the output slot type of the target node
+     * @returns the link_info is created, otherwise null
+     */
+    connectByTypeOutput(slot: number | string, source_node: LGraphNode, source_slotType: ISlotType, optsIn?: ConnectByTypeOptions): LLink | null;
+    canConnectTo(node: NodeLike, toSlot: INodeInputSlot | SubgraphIO, fromSlot: INodeOutputSlot | SubgraphIO): boolean;
+    /**
+     * Connect an output of this node to an input of another node
+     * @param slot (could be the number of the slot or the string with the name of the slot)
+     * @param target_node the target node
+     * @param target_slot the input slot of the target node (could be the number of the slot or the string with the name of the slot, or -1 to connect a trigger)
+     * @returns the link_info is created, otherwise null
+     */
+    connect(slot: number | string, target_node: LGraphNode, target_slot: ISlotType, afterRerouteId?: RerouteId): LLink | null;
+    /**
+     * Connect two slots between two nodes
+     * @param output The output slot to connect
+     * @param inputNode The node that the input slot is on
+     * @param input The input slot to connect
+     * @param afterRerouteId The reroute ID to use for the link
+     * @returns The link that was created, or null if the connection was blocked
+     */
+    connectSlots(output: INodeOutputSlot, inputNode: LGraphNode, input: INodeInputSlot, afterRerouteId: RerouteId | undefined): LLink | null | undefined;
+    connectFloatingReroute(pos: Point, slot: INodeInputSlot | INodeOutputSlot, afterRerouteId?: RerouteId): Reroute;
+    /**
+     * disconnect one output to an specific node
+     * @param slot (could be the number of the slot or the string with the name of the slot)
+     * @param target_node the target node to which this slot is connected [Optional,
+     * if not target_node is specified all nodes will be disconnected]
+     * @returns if it was disconnected successfully
+     */
+    disconnectOutput(slot: string | number, target_node?: LGraphNode): boolean;
+    /**
+     * Disconnect one input
+     * @param slot Input slot index, or the name of the slot
+     * @param keepReroutes If `true`, reroutes will not be garbage collected.
+     * @returns true if disconnected successfully or already disconnected, otherwise false
+     */
+    disconnectInput(slot: number | string, keepReroutes?: boolean): boolean;
+    /**
+     * @deprecated Use {@link getInputPos} or {@link getOutputPos} instead.
+     * returns the center of a connection point in canvas coords
+     * @param is_input true if if a input slot, false if it is an output
+     * @param slot_number (could be the number of the slot or the string with the name of the slot)
+     * @param out [optional] a place to store the output, to free garbage
+     * @returns the position
+     */
+    getConnectionPos(is_input: boolean, slot_number: number, out?: Point): Point;
+    /**
+     * Gets the position of an input slot, in graph co-ordinates.
+     *
+     * This method is preferred over the legacy {@link getConnectionPos} method.
+     * @param slot Input slot index
+     * @returns Position of the input slot
+     */
+    getInputPos(slot: number): Point;
+    /**
+     * Gets the position of an input slot, in graph co-ordinates.
+     * @param input The actual node input object
+     * @returns Position of the centre of the input slot in graph co-ordinates.
+     */
+    getInputSlotPos(input: INodeInputSlot): Point;
+    /**
+     * Gets the position of an output slot, in graph co-ordinates.
+     *
+     * This method is preferred over the legacy {@link getConnectionPos} method.
+     * @param slot Output slot index
+     * @returns Position of the output slot
+     */
+    getOutputPos(slot: number): Point;
+    /** @inheritdoc */
+    snapToGrid(snapTo: number): boolean;
+    /** @see {@link snapToGrid} */
+    alignToGrid(): void;
+    trace(msg: string): void;
+    setDirtyCanvas(dirty_foreground: boolean, dirty_background?: boolean): void;
+    loadImage(url: string): HTMLImageElement;
+    /**
+     * Allows to get onMouseMove and onMouseUp events even if the mouse is out of focus
+     * @deprecated Use {@link LGraphCanvas.pointer} instead.
+     */
+    captureInput(v: boolean): void;
+    get collapsed(): boolean;
+    get collapsible(): boolean;
+    /**
+     * Toggle node collapse (makes it smaller on the canvas)
+     */
+    collapse(force?: boolean): void;
+    /**
+     * Toggles advanced mode of the node, showing advanced widgets
+     */
+    toggleAdvanced(): void;
+    get pinned(): boolean;
+    /**
+     * Prevents the node being accidentally moved or resized by mouse interaction.
+     * Toggles pinned state if no value is provided.
+     */
+    pin(v?: boolean): void;
+    unpin(): void;
+    localToScreen(x: number, y: number, dragAndScale: DragAndScale): Point;
+    get width(): number;
+    /**
+     * Returns the height of the node, including the title bar.
+     */
+    get height(): number;
+    /**
+     * Returns the height of the node, excluding the title bar.
+     */
+    get bodyHeight(): number;
+    drawBadges(ctx: CanvasRenderingContext2D, { gap }?: {
+        gap?: number | undefined;
+    }): void;
+    /**
+     * Renders the node's title bar background
+     */
+    drawTitleBarBackground(ctx: CanvasRenderingContext2D, { scale, title_height, low_quality, }: DrawTitleOptions): void;
+    /**
+     * Renders the node's title box, i.e. the dot in front of the title text that
+     * when clicked toggles the node's collapsed state. The term `title box` comes
+     * from the original LiteGraph implementation.
+     */
+    drawTitleBox(ctx: CanvasRenderingContext2D, { scale, low_quality, title_height, box_size, }: DrawTitleBoxOptions): void;
+    /**
+     * Renders the node's title text.
+     */
+    drawTitleText(ctx: CanvasRenderingContext2D, { scale, default_title_color, low_quality, title_height, }: DrawTitleTextOptions): void;
+    /**
+     * Attempts to gracefully bypass this node in all of its connections by reconnecting all links.
+     *
+     * Each input is checked against each output.  This is done on a matching index basis, i.e. input 3 -> output 3.
+     * If there are any input links remaining,
+     * and {@link flags}.{@link INodeFlags.keepAllLinksOnBypass keepAllLinksOnBypass} is `true`,
+     * each input will check for outputs that match, and take the first one that matches
+     * `true`: Try the index matching first, then every input to every output.
+     * `false`: Only matches indexes, e.g. input 3 to output 3.
+     *
+     * If {@link flags}.{@link INodeFlags.keepAllLinksOnBypass keepAllLinksOnBypass} is `undefined`, it will fall back to
+     * the static {@link keepAllLinksOnBypass}.
+     * @returns `true` if any new links were established, otherwise `false`.
+     * @todo Decision: Change API to return array of new links instead?
+     */
+    connectInputToOutput(): boolean | undefined;
+    /**
+     * Returns `true` if the widget is visible, otherwise `false`.
+     */
+    isWidgetVisible(widget: IBaseWidget): boolean;
+    drawWidgets(ctx: CanvasRenderingContext2D, { lowQuality, editorAlpha, }: DrawWidgetsOptions): void;
+    /**
+     * When {@link LGraphNode.collapsed} is `true`, this method draws the node's collapsed slots.
+     */
+    drawCollapsedSlots(ctx: CanvasRenderingContext2D): void;
+    get slots(): (INodeInputSlot | INodeOutputSlot)[];
+    /**
+     * Returns the input slot that is associated with the given widget.
+     */
+    getSlotFromWidget(widget: IBaseWidget | undefined): INodeInputSlot | undefined;
+    /**
+     * Returns the widget that is associated with the given input slot.
+     */
+    getWidgetFromSlot(slot: INodeInputSlot): IBaseWidget | undefined;
+    /**
+     * Draws the node's input and output slots.
+     */
+    drawSlots(ctx: CanvasRenderingContext2D, { fromSlot, colorContext, editorAlpha, lowQuality, }: DrawSlotsOptions): void;
+    /**
+     * @internal Sets the internal concrete slot arrays, ensuring they are instances of
+     * {@link NodeInputSlot} or {@link NodeOutputSlot}.
+     *
+     * A temporary workaround until duck-typed inputs and outputs
+     * have been removed from the ecosystem.
+     */
+    _setConcreteSlots(): void;
+    /**
+     * Arranges node elements in preparation for rendering (slots & widgets).
+     */
+    arrange(): void;
+    /**
+     * Draws a progress bar on the node.
+     * @param ctx The canvas context to draw on
+     */
+    drawProgressBar(ctx: CanvasRenderingContext2D): void;
+}
+export {};