NOTIFICATION_ENTER_TREE* = 10'i64

NOTIFICATION_EXIT_TREE* = 11'i64

NOTIFICATION_MOVED_IN_PARENT* = 12'i64

NOTIFICATION_READY* = 13'i64

NOTIFICATION_FIXED_PROCESS* = 16'i64

NOTIFICATION_PROCESS* = 17'i64

NOTIFICATION_PARENTED* = 18'i64

NOTIFICATION_UNPARENTED* = 19'i64

NOTIFICATION_PAUSED* = 14'i64

NOTIFICATION_UNPAUSED* = 15'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_FIXED_PROCESS* = 26'i64

RPC_MODE_DISABLED* = 0'i64

RPC_MODE_REMOTE* = 1'i64

RPC_MODE_SYNC* = 2'i64

RPC_MODE_MASTER* = 3'i64

RPC_MODE_SLAVE* = 4'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
.}

proc `importPath =`*(self: Node; val: NodePath) {.
gcsafe, locks: 0
.}

proc pauseMode*(self: Node): int64 {.
gcsafe, locks: 0
.}

proc `pauseMode =`*(self: Node; val: int64) {.
gcsafe, locks: 0
.}

proc editordisplayFolded*(self: Node): bool {.
gcsafe, locks: 0
.}

proc `editordisplayFolded =`*(self: Node; val: bool) {.
gcsafe, locks: 0
.}

proc setName*(self: Node; name: string) {.
gcsafe, locks: 0
.}

proc getName*(self: Node): string {.
gcsafe, locks: 0
.}

proc addChild*(self: Node; node: Node; legibleUniqueName: bool = false) {.
gcsafe, locks: 0
.}

proc removeChild*(self: Node; node: Node) {.
gcsafe, locks: 0
.}

proc getChildCount*(self: Node): int64 {.
gcsafe, locks: 0
.}

proc getChildren*(self: Node): Array {.
gcsafe, locks: 0
.}

proc getChild*(self: Node; idx: int64): Node {.
gcsafe, locks: 0
.}

proc hasNode*(self: Node; path: NodePath): bool {.
gcsafe, locks: 0
.}

proc getNode*(self: Node; path: NodePath): Node {.
gcsafe, locks: 0
.}

proc getParent*(self: Node): Node {.
gcsafe, locks: 0
.}

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

    gcsafe, locks: 0
.}

proc hasNodeAndResource*(self: Node; path: NodePath): bool {.
gcsafe, locks: 0
.}

proc getNodeAndResource*(self: Node; path: NodePath): Array {.
gcsafe, locks: 0
.}

proc isInsideTree*(self: Node): bool {.
gcsafe, locks: 0
.}

proc isAParentOf*(self: Node; node: Node): bool {.
gcsafe, locks: 0
.}

proc isGreaterThan*(self: Node; node: Node): bool {.
gcsafe, locks: 0
.}

proc getPath*(self: Node): NodePath {.
gcsafe, locks: 0
.}

proc getPathTo*(self: Node; node: Node): NodePath {.
gcsafe, locks: 0
.}

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

proc removeFromGroup*(self: Node; group: string) {.
gcsafe, locks: 0
.}

proc isInGroup*(self: Node; group: string): bool {.
gcsafe, locks: 0
.}

proc moveChild*(self: Node; childNode: Node; toPos: int64) {.
gcsafe, locks: 0
.}

proc getGroups*(self: Node): Array {.
gcsafe, locks: 0
.}

proc raisee*(self: Node) {.
gcsafe, locks: 0
.}

proc setOwner*(self: Node; owner: Node) {.
gcsafe, locks: 0
.}

proc getOwner*(self: Node): Node {.
gcsafe, locks: 0
.}

proc removeAndSkip*(self: Node) {.
gcsafe, locks: 0
.}

proc getIndex*(self: Node): int64 {.
gcsafe, locks: 0
.}

proc printTree*(self: Node) {.
gcsafe, locks: 0
.}

proc setFilename*(self: Node; filename: string) {.
gcsafe, locks: 0
.}

proc getFilename*(self: Node): string {.
gcsafe, locks: 0
.}

proc propagateNotification*(self: Node; what: int64) {.
gcsafe, locks: 0
.}

proc setFixedProcess*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc getFixedProcessDeltaTime*(self: Node): float64 {.
gcsafe, locks: 0
.}

proc isFixedProcessing*(self: Node): bool {.
gcsafe, locks: 0
.}

proc getProcessDeltaTime*(self: Node): float64 {.
gcsafe, locks: 0
.}

proc setProcess*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isProcessing*(self: Node): bool {.
gcsafe, locks: 0
.}

proc setProcessInput*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isProcessingInput*(self: Node): bool {.
gcsafe, locks: 0
.}

proc setProcessUnhandledInput*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isProcessingUnhandledInput*(self: Node): bool {.
gcsafe, locks: 0
.}

proc setProcessUnhandledKeyInput*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isProcessingUnhandledKeyInput*(self: Node): bool {.
gcsafe, locks: 0
.}

proc canProcess*(self: Node): bool {.
gcsafe, locks: 0
.}

proc printStrayNodes*(self: Node) {.
gcsafe, locks: 0
.}

proc getPositionInParent*(self: Node): int64 {.
gcsafe, locks: 0
.}

proc setProcessInternal*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isProcessingInternal*(self: Node): bool {.
gcsafe, locks: 0
.}

proc setFixedProcessInternal*(self: Node; enable: bool) {.
gcsafe, locks: 0
.}

proc isFixedProcessingInternal*(self: Node): bool {.
gcsafe, locks: 0
.}

proc getTree*(self: Node): SceneTree {.
gcsafe, locks: 0
.}

proc duplicate*(self: Node; flags: int64 = 15'i64): Node {.
gcsafe, locks: 0
.}

proc replaceBy*(self: Node; node: Node; keepData: bool = false) {.
gcsafe, locks: 0
.}

proc setSceneInstanceLoadPlaceholder*(self: Node; loadPlaceholder: bool) {.
gcsafe,
    locks: 0
.}

proc getSceneInstanceLoadPlaceholder*(self: Node): bool {.
gcsafe, locks: 0
.}

proc getViewport*(self: Node): Viewport {.
gcsafe, locks: 0
.}

proc queueFree*(self: Node) {.
gcsafe, locks: 0
.}

proc requestReady*(self: Node) {.
gcsafe, locks: 0
.}

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

proc getNetworkMaster*(self: Node): int64 {.
gcsafe, locks: 0
.}

proc isNetworkMaster*(self: Node): bool {.
gcsafe, locks: 0
.}

proc rpcConfig*(self: Node; methodd: string; mode: int64) {.
gcsafe, locks: 0
.}

proc rsetConfig*(self: Node; property: string; mode: int64) {.
gcsafe, locks: 0
.}

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

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

    gcsafe, locks: 0
.}

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

    gcsafe, locks: 0
.}

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

proc rset*(self: Node; property: string; value: Variant) {.
gcsafe, locks: 0
.}

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

proc rsetUnreliable*(self: Node; property: string; value: Variant) {.
gcsafe, locks: 0
.}

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

    gcsafe, locks: 0
.}

method process*(self: Node; delta: float64) {.
gcsafe, locks: 0, base
.}

method fixedProcess*(self: Node; delta: float64) {.
gcsafe, locks: 0, base
.}

method enterTree*(self: Node) {.
gcsafe, locks: 0, base
.}

method exitTree*(self: Node) {.
gcsafe, locks: 0, base
.}

method ready*(self: Node) {.
gcsafe, locks: 0, base
.}

method input*(self: Node; event: InputEvent) {.
gcsafe, locks: 0, base
.}

method unhandledInput*(self: Node; event: InputEvent) {.
gcsafe, locks: 0, base
.}

method unhandledKeyInput*(self: Node; event: InputEventKey) {.
gcsafe, locks: 0, base
.}

method addChildBelowNode*(self: Node; node: Node; childNode: Node;
                         legibleUniqueName: bool = false) {.
gcsafe, locks: 0, base
.}