NOTIFICATION_ENTER_TREE = 10'i64

NOTIFICATION_EXIT_TREE = 11'i64

NOTIFICATION_MOVED_IN_PARENT = 12'i64

NOTIFICATION_READY = 13'i64

NOTIFICATION_PAUSED = 14'i64

NOTIFICATION_UNPAUSED = 15'i64

NOTIFICATION_PHYSICS_PROCESS = 16'i64

NOTIFICATION_PROCESS = 17'i64

NOTIFICATION_PARENTED = 18'i64

NOTIFICATION_UNPARENTED = 19'i64

NOTIFICATION_INSTANCED = 20'i64

NOTIFICATION_DRAG_BEGIN = 21'i64

NOTIFICATION_DRAG_END = 22'i64

NOTIFICATION_PATH_CHANGED = 23'i64

NOTIFICATION_TRANSLATION_CHANGED = 24'i64

NOTIFICATION_INTERNAL_PROCESS = 25'i64

NOTIFICATION_INTERNAL_PHYSICS_PROCESS = 26'i64

PAUSE_MODE_INHERIT = 0'i64

PAUSE_MODE_STOP = 1'i64

PAUSE_MODE_PROCESS = 2'i64

DUPLICATE_SIGNALS = 1'i64

DUPLICATE_GROUPS = 2'i64

DUPLICATE_SCRIPTS = 4'i64

DUPLICATE_USE_INSTANCING = 8'i64

proc importPath(self: Node): NodePath {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc importPath=(self: Node; val: NodePath) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc pauseMode(self: Node): int64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc pauseMode=(self: Node; val: int64) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc editordisplayFolded(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc editordisplayFolded=(self: Node; val: bool) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc name(self: Node): string {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc name=(self: Node; val: string) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc filename(self: Node): string {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc filename=(self: Node; val: string) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc owner(self: Node): Node {.
gcsafe, locks: 0, raises: [Exception], tags: [RootEffect]
.}

proc owner=(self: Node; val: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc multiplayer(self: Node): MultiplayerAPI {.
gcsafe, locks: 0, raises: [Exception],
    tags: [RootEffect]
.}

proc multiplayer=(self: Node; val: MultiplayerAPI) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc customMultiplayer(self: Node): MultiplayerAPI {.
gcsafe, locks: 0,
    raises: [Exception], tags: [RootEffect]
.}

proc customMultiplayer=(self: Node; val: MultiplayerAPI) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc addChildBelowNode(self: Node; node: Object; childNode: Object;
                      legibleUniqueName: bool = false) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc addChild(self: Node; node: Object; legibleUniqueName: bool = false) {.
gcsafe,
    locks: 0, raises: [], tags: []
.}

proc removeChild(self: Node; node: Object) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getChildCount(self: Node): int64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getChildren(self: Node): Array {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getChild(self: Node; idx: int64): Node {.
gcsafe, locks: 0, raises: [Exception],
                                        tags: [RootEffect]
.}

proc hasNode(self: Node; path: NodePath): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getNode(self: Node; path: NodePath): Node {.
gcsafe, locks: 0, raises: [Exception],
    tags: [RootEffect]
.}

proc getParent(self: Node): Node {.
gcsafe, locks: 0, raises: [Exception],
                               tags: [RootEffect]
.}

proc findNode(self: Node; mask: string; recursive: bool = true; owned: bool = true): Node {.

    gcsafe, locks: 0, raises: [Exception], tags: [RootEffect]
.}

proc hasNodeAndResource(self: Node; path: NodePath): bool {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc getNodeAndResource(self: Node; path: NodePath): Array {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc isInsideTree(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isAParentOf(self: Node; node: Object): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isGreaterThan(self: Node; node: Object): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getPath(self: Node): NodePath {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getPathTo(self: Node; node: Object): NodePath {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc addToGroup(self: Node; group: string; persistent: bool = false) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc removeFromGroup(self: Node; group: string) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isInGroup(self: Node; group: string): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc moveChild(self: Node; childNode: Object; toPosition: int64) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc getGroups(self: Node): Array {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc raisee(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc removeAndSkip(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getIndex(self: Node): int64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc printTree(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc printTreePretty(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc propagateNotification(self: Node; what: int64) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc propagateCall(self: Node; methodd: string; args: Array = newArray();
                  parentFirst: bool = false) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setPhysicsProcess(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getPhysicsProcessDeltaTime(self: Node): float64 {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc isPhysicsProcessing(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getProcessDeltaTime(self: Node): float64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setProcess(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isProcessing(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setProcessInput(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isProcessingInput(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setProcessUnhandledInput(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc isProcessingUnhandledInput(self: Node): bool {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc setProcessUnhandledKeyInput(self: Node; enable: bool) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc isProcessingUnhandledKeyInput(self: Node): bool {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc canProcess(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc printStrayNodes(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc getPositionInParent(self: Node): int64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setProcessInternal(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isProcessingInternal(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setPhysicsProcessInternal(self: Node; enable: bool) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc isPhysicsProcessingInternal(self: Node): bool {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc getTree(self: Node): SceneTree {.
gcsafe, locks: 0, raises: [Exception],
                                  tags: [RootEffect]
.}

proc duplicate(self: Node; flags: int64 = 15'i64): Node {.
gcsafe, locks: 0,
    raises: [Exception], tags: [RootEffect]
.}

proc replaceBy(self: Node; node: Object; keepData: bool = false) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc setSceneInstanceLoadPlaceholder(self: Node; loadPlaceholder: bool) {.
gcsafe,
    locks: 0, raises: [], tags: []
.}

proc getSceneInstanceLoadPlaceholder(self: Node): bool {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc getViewport(self: Node): Viewport {.
gcsafe, locks: 0, raises: [Exception],
                                     tags: [RootEffect]
.}

proc queueFree(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc requestReady(self: Node) {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc setNetworkMaster(self: Node; id: int64; recursive: bool = true) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc getNetworkMaster(self: Node): int64 {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc isNetworkMaster(self: Node): bool {.
gcsafe, locks: 0, raises: [], tags: []
.}

proc rpcConfig(self: Node; methodd: string; mode: int64) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc rsetConfig(self: Node; property: string; mode: int64) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc rpc(self: Node; methodd: string; variantArgs: varargs[Variant]): Variant {.
gcsafe,
    locks: 0, raises: [CallError, ValueError], tags: []
.}

proc rpcUnreliable(self: Node; methodd: string; variantArgs: varargs[Variant]): Variant {.

    gcsafe, locks: 0, raises: [CallError, ValueError], tags: []
.}

proc rpcId(self: Node; peerId: int64; methodd: string; variantArgs: varargs[Variant]): Variant {.

    gcsafe, locks: 0, raises: [CallError, ValueError], tags: []
.}

proc rpcUnreliableId(self: Node; peerId: int64; methodd: string;
                    variantArgs: varargs[Variant]): Variant {.
gcsafe, locks: 0,
    raises: [CallError, ValueError], tags: []
.}

proc rset(self: Node; property: string; value: Variant) {.
gcsafe, locks: 0, raises: [],
    tags: []
.}

proc rsetId(self: Node; peerId: int64; property: string; value: Variant) {.
gcsafe,
    locks: 0, raises: [], tags: []
.}

proc rsetUnreliable(self: Node; property: string; value: Variant) {.
gcsafe, locks: 0,
    raises: [], tags: []
.}

proc rsetUnreliableId(self: Node; peerId: int64; property: string; value: Variant) {.

    gcsafe, locks: 0, raises: [], tags: []
.}

method process(self: Node; delta: float64) {.
gcsafe, locks: 0, base, raises: [], tags: []
.}

method physicsProcess(self: Node; delta: float64) {.
gcsafe, locks: 0, base, raises: [],
    tags: []
.}

method enterTree(self: Node) {.
gcsafe, locks: 0, base, raises: [], tags: []
.}

method exitTree(self: Node) {.
gcsafe, locks: 0, base, raises: [], tags: []
.}

method ready(self: Node) {.
gcsafe, locks: 0, base, raises: [], tags: []
.}

method input(self: Node; event: InputEvent) {.
gcsafe, locks: 0, base, raises: [], tags: []
.}

method unhandledInput(self: Node; event: InputEvent) {.
gcsafe, locks: 0, base,
    raises: [], tags: []
.}

method unhandledKeyInput(self: Node; event: InputEventKey) {.
gcsafe, locks: 0, base,
    raises: [], tags: []
.}