@ringozz/godot 0.1.0

package/gen/classes/GraphEdit.ts

@@ -0,0 +1,535 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedVector2Array, Signal, StringName } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/index.ts';
+import type { GraphFrame } from './GraphFrame.ts';
+import type { HBoxContainer } from './HBoxContainer.ts';
+import type { Node } from './Node.ts';
+import type { Object } from './Object.ts';
+
+/**
+ * {@link GraphEdit} provides tools for creation, manipulation, and display of various graphs. Its main purpose in the engine is to power the visual programming systems, such as visual shaders, but it is also available for use in user projects.
+ * {@link GraphEdit} by itself is only an empty container, representing an infinite grid where {@link GraphNode}s can be placed. Each {@link GraphNode} represents a node in the graph, a single unit of data in the connected scheme. {@link GraphEdit}, in turn, helps to control various interactions with nodes and between nodes. When the user attempts to connect, disconnect, or delete a {@link GraphNode}, a signal is emitted in the {@link GraphEdit}, but no action is taken by default. It is the responsibility of the programmer utilizing this control to implement the necessary logic to determine how each request should be handled.
+ * **Performance:** It is greatly advised to enable low-processor usage mode (see {@link OS.lowProcessorUsageMode}) when using GraphEdits.
+ * **Note:** Keep in mind that {@link Node.getChildren} will also return the connection layer node named `_connection_layer` due to technical limitations. This behavior may change in future releases.
+ */
+export class GraphEdit extends Control {
+    constructor(name = 317) { super(name); }
+
+    /**
+     * Create a connection between the `fromPort` of the `fromNode` {@link GraphNode} and the `toPort` of the `toNode` {@link GraphNode}. If the connection already exists, no connection is created.
+     * Connections with `keepAlive` set to `false` may be deleted automatically if invalid during a redraw.
+     */
+    connectNode(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number, keepAlive?: boolean /* = false */): Error { return _C(this, 2434, fromNode, fromPort, toNode, toPort, keepAlive) as Error; }
+
+    /**
+     * Returns `true` if the `fromPort` of the `fromNode` {@link GraphNode} is connected to the `toPort` of the `toNode` {@link GraphNode}.
+     */
+    isNodeConnected(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number): boolean { return _C(this, 8133, fromNode, fromPort, toNode, toPort) as boolean; }
+
+    /**
+     * Removes the connection between the `fromPort` of the `fromNode` {@link GraphNode} and the `toPort` of the `toNode` {@link GraphNode}. If the connection does not exist, no connection is removed.
+     */
+    disconnectNode(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number): void { _C(this, 2825, fromNode, fromPort, toNode, toPort); }
+
+    /**
+     * Sets the coloration of the connection between `fromNode`'s `fromPort` and `toNode`'s `toPort` with the color provided in the {@link activity} theme property. The color is linearly interpolated between the connection color and the activity color using `amount` as weight.
+     */
+    setConnectionActivity(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number, amount: number): void { _C(this, 10937, fromNode, fromPort, toNode, toPort, amount); }
+
+    /**
+     * Returns the number of connections from `fromPort` of `fromNode`.
+     */
+    getConnectionCount(fromNode: StringName, fromPort: number): number { return _C(this, 4267, fromNode, fromPort) as number; }
+
+    /**
+     * Returns the closest connection to the given point in screen space. If no connection is found within `maxDistance` pixels, an empty {@link Dictionary} is returned.
+     * A connection is represented as a {@link Dictionary} in the form of:
+     *
+     * ```text
+     *
+     * {
+     * 	from_node: StringName,
+     * 	from_port: int,
+     * 	to_node: StringName,
+     * 	to_port: int,
+     * 	keep_alive: bool
+     * }
+     *
+     * ```
+     *
+     * For example, getting a connection at a given mouse position can be achieved like this:
+     *
+     *
+     * ```gdscript
+     *
+     * var connection = get_closest_connection_at_point(mouse_event.get_position())
+     *
+     * ```
+     */
+    getClosestConnectionAtPoint(point: Vector2, maxDistance?: number /* = 4.0 */): GodotDictionary { return _C(this, 4171, point, maxDistance) as GodotDictionary; }
+
+    /**
+     * Returns an {@link Array} containing a list of all connections for `node`.
+     * A connection is represented as a {@link Dictionary} in the form of:
+     *
+     * ```text
+     *
+     * {
+     * 	from_node: StringName,
+     * 	from_port: int,
+     * 	to_node: StringName,
+     * 	to_port: int,
+     * 	keep_alive: bool
+     * }
+     *
+     * ```
+     *
+     * **Example:** Get all connections on a specific port:
+     *
+     * ```text
+     *
+     * func get_connection_list_from_port(node, port):
+     * 	var connections = get_connection_list_from_node(node)
+     * 	var result = []
+     * 	for connection in connections:
+     * 		var dict = {}
+     * 		if connection["from_node"] == node and connection["from_port"] == port:
+     * 			dict["node"] = connection["to_node"]
+     * 			dict["port"] = connection["to_port"]
+     * 			dict["type"] = "left"
+     * 			result.push_back(dict)
+     * 		elif connection["to_node"] == node and connection["to_port"] == port:
+     * 			dict["node"] = connection["from_node"]
+     * 			dict["port"] = connection["from_port"]
+     * 			dict["type"] = "right"
+     * 			result.push_back(dict)
+     * 	return result
+     *
+     * ```
+     */
+    getConnectionListFromNode(node: StringName): GodotArray<GodotDictionary> { return _C(this, 4273, node) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Returns an {@link Array} containing the list of connections that intersect with the given {@link Rect2}.
+     * A connection is represented as a {@link Dictionary} in the form of:
+     *
+     * ```text
+     *
+     * {
+     * 	from_node: StringName,
+     * 	from_port: int,
+     * 	to_node: StringName,
+     * 	to_port: int,
+     * 	keep_alive: bool
+     * }
+     *
+     * ```
+     */
+    getConnectionsIntersectingWithRect(rect: Rect2): GodotArray<GodotDictionary> { return _C(this, 4282, rect) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Removes all connections between nodes.
+     */
+    clearConnections(): void { _C(this, 2253); }
+
+    /**
+     * Ends the creation of the current connection. In other words, if you are dragging a connection you can use this method to abort the process and remove the line that followed your cursor.
+     * This is best used together with {@link connection_drag_started} and {@link connection_drag_ended} to add custom behavior like node addition through shortcuts.
+     * **Note:** This method suppresses any other connection request signals apart from {@link connection_drag_ended}.
+     */
+    forceConnectionDragEnd(): void { _C(this, 3528); }
+
+    /**
+     * Allows to disconnect nodes when dragging from the right port of the {@link GraphNode}'s slot if it has the specified type. See also {@link removeValidRightDisconnectType}.
+     */
+    addValidRightDisconnectType(type: number): void { _C(this, 1333, type); }
+
+    /**
+     * Disallows to disconnect nodes when dragging from the right port of the {@link GraphNode}'s slot if it has the specified type. Use this to disable a disconnection previously allowed with {@link addValidRightDisconnectType}.
+     */
+    removeValidRightDisconnectType(type: number): void { _C(this, 9988, type); }
+
+    /**
+     * Allows to disconnect nodes when dragging from the left port of the {@link GraphNode}'s slot if it has the specified type. See also {@link removeValidLeftDisconnectType}.
+     */
+    addValidLeftDisconnectType(type: number): void { _C(this, 1332, type); }
+
+    /**
+     * Disallows to disconnect nodes when dragging from the left port of the {@link GraphNode}'s slot if it has the specified type. Use this to disable a disconnection previously allowed with {@link addValidLeftDisconnectType}.
+     */
+    removeValidLeftDisconnectType(type: number): void { _C(this, 9987, type); }
+
+    /**
+     * Allows the connection between two different port types. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.setSlot} method.
+     * See also {@link isValidConnectionType} and {@link removeValidConnectionType}.
+     */
+    addValidConnectionType(fromType: number, toType: number): void { _C(this, 1331, fromType, toType); }
+
+    /**
+     * Disallows the connection between two different port types previously allowed by {@link addValidConnectionType}. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.setSlot} method.
+     * See also {@link isValidConnectionType}.
+     */
+    removeValidConnectionType(fromType: number, toType: number): void { _C(this, 9986, fromType, toType); }
+
+    /**
+     * Returns whether it's possible to make a connection between two different port types. The port type is defined individually for the left and the right port of each slot with the {@link GraphNode.setSlot} method.
+     * See also {@link addValidConnectionType} and {@link removeValidConnectionType}.
+     */
+    isValidConnectionType(fromType: number, toType: number): boolean { return _C(this, 8434, fromType, toType) as boolean; }
+
+    /**
+     * Returns the points which would make up a connection between `fromNode` and `toNode`.
+     */
+    getConnectionLine(fromNode: Vector2, toNode: Vector2): PackedVector2Array { return _C(this, 4269, fromNode, toNode) as PackedVector2Array; }
+
+    /**
+     * Attaches the `element` {@link GraphElement} to the `frame` {@link GraphFrame}.
+     */
+    attachGraphElementToFrame(element: StringName, frame: StringName): void { _C(this, 1612, element, frame); }
+
+    /**
+     * Detaches the `element` {@link GraphElement} from the {@link GraphFrame} it is currently attached to.
+     */
+    detachGraphElementFromFrame(element: StringName): void { _C(this, 2761, element); }
+
+    /**
+     * Returns the {@link GraphFrame} that contains the {@link GraphElement} with the given name.
+     */
+    getElementFrame(element: StringName): GraphFrame { return _C(this, 4609, element) as GraphFrame; }
+
+    /**
+     * Returns an array of node names that are attached to the {@link GraphFrame} with the given name.
+     */
+    getAttachedNodesOfFrame(frame: StringName): GodotArray<StringName> { return _C(this, 3806, frame) as GodotArray<StringName>; }
+
+    /**
+     * Gets the {@link HBoxContainer} that contains the zooming and grid snap controls in the top left of the graph. You can use this method to reposition the toolbar or to add your own custom controls to it.
+     * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+     */
+    getMenuHbox(): HBoxContainer { return _C(this, 5507) as HBoxContainer; }
+
+    /**
+     * Rearranges selected nodes in a layout with minimum crossings between connections and uniform horizontal and vertical gap between nodes.
+     */
+    arrangeNodes(): void { _C(this, 1590); }
+
+    /**
+     * Sets the specified `node` as the one selected.
+     */
+    setSelected(node: Node): void { _C(this, 12688, node); }
+
+    /**
+     * The scroll offset.
+     */
+    get scrollOffset(): Vector2 { return _C(this, 6281) as Vector2; }
+    set scrollOffset(v: Vector2) { _C(this, 12640, v); }
+
+    /**
+     * If `true`, the grid is visible.
+     */
+    get showGrid(): boolean { return _C(this, 8308) as boolean; }
+    set showGrid(v: boolean) { _C(this, 12730, v); }
+
+    /**
+     * The pattern used for drawing the grid.
+     */
+    get gridPattern(): GridPattern { return _C(this, 4979) as GridPattern; }
+    set gridPattern(v: GridPattern) { _C(this, 11562, v); }
+
+    /**
+     * If `true`, enables snapping.
+     */
+    get snappingEnabled(): boolean { return _C(this, 8328) as boolean; }
+    set snappingEnabled(v: boolean) { _C(this, 12804, v); }
+
+    /**
+     * The snapping distance in pixels, also determines the grid line distance.
+     */
+    get snappingDistance(): number { return _C(this, 6447) as number; }
+    set snappingDistance(v: number) { _C(this, 12803, v); }
+
+    /**
+     * Defines the control scheme for panning with mouse wheel.
+     */
+    get panningScheme(): PanningScheme { return _C(this, 5802) as PanningScheme; }
+    set panningScheme(v: PanningScheme) { _C(this, 12242, v); }
+
+    /**
+     * If `true`, enables disconnection of existing connections in the GraphEdit by dragging the right end.
+     */
+    get rightDisconnects(): boolean { return _C(this, 8249) as boolean; }
+    set rightDisconnects(v: boolean) { _C(this, 12555, v); }
+
+    /**
+     * {@link Dictionary} of human-readable port type names.
+     */
+    get typeNames(): GodotDictionary { return _C(this, 6923) as GodotDictionary; }
+    set typeNames(v: GodotDictionary) { _C(this, 13163, v); }
+
+    /**
+     * The curvature of the lines between the nodes. 0 results in straight lines.
+     */
+    get connectionLinesCurvature(): number { return _C(this, 4270) as number; }
+    set connectionLinesCurvature(v: number) { _C(this, 10939, v); }
+
+    /**
+     * The thickness of the lines between the nodes.
+     */
+    get connectionLinesThickness(): number { return _C(this, 4271) as number; }
+    set connectionLinesThickness(v: number) { _C(this, 10940, v); }
+
+    /**
+     * If `true`, the lines between nodes will use antialiasing.
+     */
+    get connectionLinesAntialiased(): boolean { return _C(this, 7858) as boolean; }
+    set connectionLinesAntialiased(v: boolean) { _C(this, 10938, v); }
+
+    /**
+     * The connections between {@link GraphNode}s.
+     * A connection is represented as a {@link Dictionary} in the form of:
+     *
+     * ```text
+     *
+     * {
+     * 	from_node: StringName,
+     * 	from_port: int,
+     * 	to_node: StringName,
+     * 	to_port: int,
+     * 	keep_alive: bool
+     * }
+     *
+     * ```
+     *
+     * Connections with `keep_alive` set to `false` may be deleted automatically if invalid during a redraw.
+     */
+    get connections(): GodotArray<GodotDictionary> { return _C(this, 4272) as GodotArray<GodotDictionary>; }
+    set connections(v: GodotArray<GodotDictionary>) { _C(this, 10941, v); }
+
+    /**
+     * The current zoom value.
+     */
+    get zoom(): number { return _C(this, 7185) as number; }
+    set zoom(v: number) { _C(this, 13409, v); }
+
+    /**
+     * The lower zoom limit.
+     */
+    get zoomMin(): number { return _C(this, 7187) as number; }
+    set zoomMin(v: number) { _C(this, 13411, v); }
+
+    /**
+     * The upper zoom limit.
+     */
+    get zoomMax(): number { return _C(this, 7186) as number; }
+    set zoomMax(v: number) { _C(this, 13410, v); }
+
+    /**
+     * The step of each zoom level.
+     */
+    get zoomStep(): number { return _C(this, 7188) as number; }
+    set zoomStep(v: number) { _C(this, 13412, v); }
+
+    /**
+     * If `true`, the minimap is visible.
+     */
+    get minimapEnabled(): boolean { return _C(this, 8107) as boolean; }
+    set minimapEnabled(v: boolean) { _C(this, 12058, v); }
+
+    /**
+     * The size of the minimap rectangle. The map itself is based on the size of the grid area and is scaled to fit this rectangle.
+     */
+    get minimapSize(): Vector2 { return _C(this, 5550) as Vector2; }
+    set minimapSize(v: Vector2) { _C(this, 12060, v); }
+
+    /**
+     * The opacity of the minimap rectangle.
+     */
+    get minimapOpacity(): number { return _C(this, 5549) as number; }
+    set minimapOpacity(v: number) { _C(this, 12059, v); }
+
+    /**
+     * If `true`, the menu toolbar is visible.
+     */
+    get showMenu(): boolean { return _C(this, 8311) as boolean; }
+    set showMenu(v: boolean) { _C(this, 12733, v); }
+
+    /**
+     * If `true`, the label with the current zoom level is visible. The zoom level is displayed in percents.
+     */
+    get showZoomLabel(): boolean { return _C(this, 8315) as boolean; }
+    set showZoomLabel(v: boolean) { _C(this, 12740, v); }
+
+    /**
+     * If `true`, buttons that allow to change and reset the zoom level are visible.
+     */
+    get showZoomButtons(): boolean { return _C(this, 8314) as boolean; }
+    set showZoomButtons(v: boolean) { _C(this, 12739, v); }
+
+    /**
+     * If `true`, buttons that allow to configure grid and snapping options are visible.
+     */
+    get showGridButtons(): boolean { return _C(this, 8309) as boolean; }
+    set showGridButtons(v: boolean) { _C(this, 12731, v); }
+
+    /**
+     * If `true`, the button to toggle the minimap is visible.
+     */
+    get showMinimapButton(): boolean { return _C(this, 8312) as boolean; }
+    set showMinimapButton(v: boolean) { _C(this, 12734, v); }
+
+    /**
+     * If `true`, the button to automatically arrange graph nodes is visible.
+     */
+    get showArrangeButton(): boolean { return _C(this, 8307) as boolean; }
+    set showArrangeButton(v: boolean) { _C(this, 12729, v); }
+
+    /**
+     * Emitted to the GraphEdit when the connection between the `fromPort` of the `fromNode` {@link GraphNode} and the `toPort` of the `toNode` {@link GraphNode} is attempted to be created.
+     */
+    get connectionRequest(): Signal<(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void> { return _G(this, 2451) as Signal<(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void>; }
+    set connectionRequest(v: ((fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void) | null) { _G(this, 2451, v); }
+
+    /**
+     * Emitted to the GraphEdit when the connection between `fromPort` of `fromNode` {@link GraphNode} and `toPort` of `toNode` {@link GraphNode} is attempted to be removed.
+     */
+    get disconnectionRequest(): Signal<(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void> { return _G(this, 2829) as Signal<(fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void>; }
+    set disconnectionRequest(v: ((fromNode: StringName, fromPort: number, toNode: StringName, toPort: number) => void) | null) { _G(this, 2829, v); }
+
+    /**
+     * Emitted when user drags a connection from an output port into the empty space of the graph.
+     */
+    get connectionToEmpty(): Signal<(fromNode: StringName, fromPort: number, releasePosition: Vector2) => void> { return _G(this, 2452) as Signal<(fromNode: StringName, fromPort: number, releasePosition: Vector2) => void>; }
+    set connectionToEmpty(v: ((fromNode: StringName, fromPort: number, releasePosition: Vector2) => void) | null) { _G(this, 2452, v); }
+
+    /**
+     * Emitted when user drags a connection from an input port into the empty space of the graph.
+     */
+    get connectionFromEmpty(): Signal<(toNode: StringName, toPort: number, releasePosition: Vector2) => void> { return _G(this, 2447) as Signal<(toNode: StringName, toPort: number, releasePosition: Vector2) => void>; }
+    set connectionFromEmpty(v: ((toNode: StringName, toPort: number, releasePosition: Vector2) => void) | null) { _G(this, 2447, v); }
+
+    /**
+     * Emitted at the beginning of a connection drag.
+     */
+    get connectionDragStarted(): Signal<(fromNode: StringName, fromPort: number, isOutput: boolean) => void> { return _G(this, 2445) as Signal<(fromNode: StringName, fromPort: number, isOutput: boolean) => void>; }
+    set connectionDragStarted(v: ((fromNode: StringName, fromPort: number, isOutput: boolean) => void) | null) { _G(this, 2445, v); }
+
+    /**
+     * Emitted at the end of a connection drag.
+     */
+    get connectionDragEnded(): Signal<() => void> { return _G(this, 2444) as Signal<() => void>; }
+    set connectionDragEnded(v: (() => void) | null) { _G(this, 2444, v); }
+
+    /**
+     * Emitted when this {@link GraphEdit} captures a `ui_copy` action (`Ctrl + C` by default). In general, this signal indicates that the selected {@link GraphElement}s should be copied.
+     */
+    get copyNodesRequest(): Signal<() => void> { return _G(this, 2491) as Signal<() => void>; }
+    set copyNodesRequest(v: (() => void) | null) { _G(this, 2491, v); }
+
+    /**
+     * Emitted when this {@link GraphEdit} captures a `ui_cut` action (`Ctrl + X` by default). In general, this signal indicates that the selected {@link GraphElement}s should be cut.
+     */
+    get cutNodesRequest(): Signal<() => void> { return _G(this, 2637) as Signal<() => void>; }
+    set cutNodesRequest(v: (() => void) | null) { _G(this, 2637, v); }
+
+    /**
+     * Emitted when this {@link GraphEdit} captures a `ui_paste` action (`Ctrl + V` by default). In general, this signal indicates that previously copied {@link GraphElement}s should be pasted.
+     */
+    get pasteNodesRequest(): Signal<() => void> { return _G(this, 9347) as Signal<() => void>; }
+    set pasteNodesRequest(v: (() => void) | null) { _G(this, 9347, v); }
+
+    /**
+     * Emitted when this {@link GraphEdit} captures a `ui_graph_duplicate` action (`Ctrl + D` by default). In general, this signal indicates that the selected {@link GraphElement}s should be duplicated.
+     */
+    get duplicateNodesRequest(): Signal<() => void> { return _G(this, 2984) as Signal<() => void>; }
+    set duplicateNodesRequest(v: (() => void) | null) { _G(this, 2984, v); }
+
+    /**
+     * Emitted when this {@link GraphEdit} captures a `ui_graph_delete` action (`Delete` by default).
+     * `nodes` is an array of node names that should be removed. These usually include all selected nodes.
+     */
+    get deleteNodesRequest(): Signal<(nodes: GodotArray<StringName>) => void> { return _G(this, 2723) as Signal<(nodes: GodotArray<StringName>) => void>; }
+    set deleteNodesRequest(v: ((nodes: GodotArray<StringName>) => void) | null) { _G(this, 2723, v); }
+
+    /**
+     * Emitted when the given {@link GraphElement} node is selected.
+     */
+    get nodeSelected(): Signal<(node: Node) => void> { return _G(this, 9086) as Signal<(node: Node) => void>; }
+    set nodeSelected(v: ((node: Node) => void) | null) { _G(this, 9086, v); }
+
+    /**
+     * Emitted when the given {@link GraphElement} node is deselected.
+     */
+    get nodeDeselected(): Signal<(node: Node) => void> { return _G(this, 9082) as Signal<(node: Node) => void>; }
+    set nodeDeselected(v: ((node: Node) => void) | null) { _G(this, 9082, v); }
+
+    /**
+     * Emitted when the {@link GraphFrame} `frame` is resized to `newRect`.
+     */
+    get frameRectChanged(): Signal<(frame: GraphFrame, newRect: Rect2) => void> { return _G(this, 3569) as Signal<(frame: GraphFrame, newRect: Rect2) => void>; }
+    set frameRectChanged(v: ((frame: GraphFrame, newRect: Rect2) => void) | null) { _G(this, 3569, v); }
+
+    /**
+     * Emitted when a popup is requested. Happens on right-clicking in the GraphEdit. `atPosition` is the position of the mouse pointer when the signal is sent.
+     */
+    get popupRequest(): Signal<(atPosition: Vector2) => void> { return _G(this, 9495) as Signal<(atPosition: Vector2) => void>; }
+    set popupRequest(v: ((atPosition: Vector2) => void) | null) { _G(this, 9495, v); }
+
+    /**
+     * Emitted at the beginning of a {@link GraphElement}'s movement.
+     */
+    get beginNodeMove(): Signal<() => void> { return _G(this, 1751) as Signal<() => void>; }
+    set beginNodeMove(v: (() => void) | null) { _G(this, 1751, v); }
+
+    /**
+     * Emitted at the end of a {@link GraphElement}'s movement.
+     */
+    get endNodeMove(): Signal<() => void> { return _G(this, 3101) as Signal<() => void>; }
+    set endNodeMove(v: (() => void) | null) { _G(this, 3101, v); }
+
+    /**
+     * Emitted when one or more {@link GraphElement}s are dropped onto the {@link GraphFrame} named `frame`, when they were not previously attached to any other one.
+     * `elements` is an array of {@link GraphElement}s to be attached.
+     */
+    get graphElementsLinkedToFrameRequest(): Signal<(elements: GodotArray, frame: StringName) => void> { return _G(this, 7288) as Signal<(elements: GodotArray, frame: StringName) => void>; }
+    set graphElementsLinkedToFrameRequest(v: ((elements: GodotArray, frame: StringName) => void) | null) { _G(this, 7288, v); }
+
+    /**
+     * Emitted when the scroll offset is changed by the user. It will not be emitted when changed in code.
+     */
+    get scrollOffsetChanged(): Signal<(offset: Vector2) => void> { return _G(this, 10290) as Signal<(offset: Vector2) => void>; }
+    set scrollOffsetChanged(v: ((offset: Vector2) => void) | null) { _G(this, 10290, v); }
+
+    static readonly name = _R(317, GraphEdit);
+}
+
+export const PanningScheme = {
+    /**
+     * `Mouse Wheel` will zoom, `Ctrl + Mouse Wheel` will move the view.
+     */
+    SCROLL_ZOOMS: 0,
+    /**
+     * `Mouse Wheel` will move the view, `Ctrl + Mouse Wheel` will zoom.
+     */
+    SCROLL_PANS: 1,
+} as const;
+
+export type PanningScheme = (typeof PanningScheme)[keyof typeof PanningScheme];
+
+export const GridPattern = {
+    /**
+     * Draw the grid using solid lines.
+     */
+    GRID_PATTERN_LINES: 0,
+    /**
+     * Draw the grid using dots.
+     */
+    GRID_PATTERN_DOTS: 1,
+} as const;
+
+export type GridPattern = (typeof GridPattern)[keyof typeof GridPattern];
+

package/gen/classes/GraphElement.ts

@@ -0,0 +1,101 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Container } from './Container.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * {@link GraphElement} allows to create custom elements for a {@link GraphEdit} graph. By default such elements can be selected, resized, and repositioned, but they cannot be connected. For a graph element that allows for connections see {@link GraphNode}.
+ */
+export class GraphElement extends Container {
+    constructor(name = 318) { super(name); }
+
+    /**
+     * The offset of the GraphElement, relative to the scroll offset of the {@link GraphEdit}.
+     */
+    get positionOffset(): Vector2 { return _C(this, 5975) as Vector2; }
+    set positionOffset(v: Vector2) { _C(this, 12383, v); }
+
+    /**
+     * If `true`, the user can resize the GraphElement.
+     * **Note:** Dragging the handle will only emit the {@link resize_request} and {@link resize_end} signals, the GraphElement needs to be resized manually.
+     */
+    get resizable(): boolean { return _C(this, 8244) as boolean; }
+    set resizable(v: boolean) { _C(this, 12539, v); }
+
+    /**
+     * If `true`, the user can drag the GraphElement.
+     */
+    get draggable(): boolean { return _C(this, 7899) as boolean; }
+    set draggable(v: boolean) { _C(this, 11178, v); }
+
+    /**
+     * If `true`, the user can select the GraphElement.
+     */
+    get selectable(): boolean { return _C(this, 8286) as boolean; }
+    set selectable(v: boolean) { _C(this, 12687, v); }
+
+    /**
+     * If `true`, the GraphElement is selected.
+     */
+    get selected(): boolean { return _C(this, 8287) as boolean; }
+    set selected(v: boolean) { _C(this, 12688, v); }
+
+    /**
+     * If `true`, {@link PopupMenu}s that are descendants of the GraphElement are scaled with the {@link GraphEdit} zoom.
+     */
+    get scalingMenus(): boolean { return _C(this, 8269) as boolean; }
+    set scalingMenus(v: boolean) { _C(this, 12618, v); }
+
+    /**
+     * Emitted when the GraphElement is selected.
+     */
+    get nodeSelected(): Signal<() => void> { return _G(this, 9086) as Signal<() => void>; }
+    set nodeSelected(v: (() => void) | null) { _G(this, 9086, v); }
+
+    /**
+     * Emitted when the GraphElement is deselected.
+     */
+    get nodeDeselected(): Signal<() => void> { return _G(this, 9082) as Signal<() => void>; }
+    set nodeDeselected(v: (() => void) | null) { _G(this, 9082, v); }
+
+    /**
+     * Emitted when displaying the GraphElement over other ones is requested. Happens on focusing (clicking into) the GraphElement.
+     */
+    get raiseRequest(): Signal<() => void> { return _G(this, 9718) as Signal<() => void>; }
+    set raiseRequest(v: (() => void) | null) { _G(this, 9718, v); }
+
+    /**
+     * Emitted when removing the GraphElement is requested.
+     */
+    get deleteRequest(): Signal<() => void> { return _G(this, 2725) as Signal<() => void>; }
+    set deleteRequest(v: (() => void) | null) { _G(this, 2725, v); }
+
+    /**
+     * Emitted when resizing the GraphElement is requested. Happens on dragging the resizer handle (see {@link resizable}).
+     */
+    get resizeRequest(): Signal<(newSize: Vector2) => void> { return _G(this, 10080) as Signal<(newSize: Vector2) => void>; }
+    set resizeRequest(v: ((newSize: Vector2) => void) | null) { _G(this, 10080, v); }
+
+    /**
+     * Emitted when releasing the mouse button after dragging the resizer handle (see {@link resizable}).
+     */
+    get resizeEnd(): Signal<(newSize: Vector2) => void> { return _G(this, 10078) as Signal<(newSize: Vector2) => void>; }
+    set resizeEnd(v: ((newSize: Vector2) => void) | null) { _G(this, 10078, v); }
+
+    /**
+     * Emitted when the GraphElement is dragged.
+     */
+    get dragged(): Signal<(from: Vector2, to: Vector2) => void> { return _G(this, 2899) as Signal<(from: Vector2, to: Vector2) => void>; }
+    set dragged(v: ((from: Vector2, to: Vector2) => void) | null) { _G(this, 2899, v); }
+
+    /**
+     * Emitted when the GraphElement is moved.
+     */
+    get positionOffsetChanged(): Signal<() => void> { return _G(this, 9506) as Signal<() => void>; }
+    set positionOffsetChanged(v: (() => void) | null) { _G(this, 9506, v); }
+
+    static readonly name = _R(318, GraphElement);
+}