proc `()`(signal: Signal; args: varargs[Variant, variant]) {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}

func `*`(left: Float; right: Color): Color {....raises: [], tags: [RootEffect],
    forbids: [].}

func `*`(left: Float; right: Quaternion): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}

func `*`(left: Int; right: Color): Color {....raises: [], tags: [RootEffect],
    forbids: [].}

func `*`(left: Int; right: Quaternion): Quaternion {....raises: [],
    tags: [RootEffect], forbids: [].}

func `**`(left: Float; right: Float): Float {....raises: [], tags: [RootEffect],
    forbids: [].}

func `**`(left: Float; right: Int): Float {....raises: [], tags: [RootEffect],
    forbids: [].}

func `**`(left: Int; right: Float): Float {....raises: [], tags: [RootEffect],
    forbids: [].}

func `**`(left: Int; right: Int): Int {....raises: [], tags: [RootEffect],
                                        forbids: [].}

func `<`(left: RID; right: RID): bool {....raises: [], tags: [RootEffect],
                                        forbids: [].}

func `<=`(left: RID; right: RID): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `==`(left: Callable; right: Callable): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

func `==`(left: RID; right: RID): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `==`(left: Signal; right: Signal): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: bool; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: bool; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: bool; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Float; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Float; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Float; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Float; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Float; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Int; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Int; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Int; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `and`(left: Int; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc `bind`(self: Callable; args: varargs[Variant, variant]): Callable {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc bindv(self: var Callable; arguments: Array): Callable {....raises: [],
    tags: [RootEffect], forbids: [].}

proc call(self: Callable; args: varargs[Variant, variant]): Variant {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc callable(): Callable {....raises: [], tags: [], forbids: [].}

proc callable(from: Callable): Callable {....raises: [], tags: [RootEffect],
    forbids: [].}

proc callable(object: Object; method: StringName): Callable {....raises: [],
    tags: [RootEffect], forbids: [].}

proc callDeferred(self: Callable; args: varargs[Variant, variant]): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc callv(self: Callable; arguments: Array): Variant {....raises: [],
    tags: [RootEffect], forbids: [].}

proc connect(self: var Signal; callable: Callable; flags: Int = 0): Int {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc create(_: typedesc[Callable]; variant: Variant; method: StringName): Callable

proc disconnect(self: var Signal; callable: Callable): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc emit(self: Signal; args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getArgumentCount(self: Callable): Int {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getBoundArguments(self: Callable): Array {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getBoundArgumentsCount(self: Callable): Int {....raises: [],
    tags: [RootEffect], forbids: [].}

proc getConnections(self: Signal): Array {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getId(self: RID): Int {....raises: [], tags: [RootEffect], forbids: [].}

proc getMethod(self: Callable): StringName {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getName(self: Signal): StringName {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getObject(self: Callable): Object {....raises: [], tags: [RootEffect],
    forbids: [].}

proc getObject(self: Signal): Object {....raises: [], tags: [RootEffect],
                                       forbids: [].}

proc getObjectId(self: Callable): Int {....raises: [], tags: [RootEffect],
                                        forbids: [].}

proc getObjectId(self: Signal): Int {....raises: [], tags: [RootEffect],
                                      forbids: [].}

proc getUnboundArgumentsCount(self: Callable): Int {....raises: [],
    tags: [RootEffect], forbids: [].}

proc hasConnections(self: Signal): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc hash(self: Callable): Hash {....raises: [], tags: [RootEffect], forbids: [].}

proc isConnected(self: Signal; callable: Callable): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc isCustom(self: Callable): bool {....raises: [], tags: [RootEffect],
                                      forbids: [].}

proc isNull(self: Callable): bool {....raises: [], tags: [RootEffect], forbids: [].}

proc isNull(self: Signal): bool {....raises: [], tags: [RootEffect], forbids: [].}

proc isStandard(self: Callable): bool {....raises: [], tags: [RootEffect],
                                        forbids: [].}

proc isValid(self: Callable): bool {....raises: [], tags: [RootEffect], forbids: [].}

proc isValid(self: RID): bool {....raises: [], tags: [RootEffect], forbids: [].}

func `not`(left: Callable): bool {....raises: [], tags: [RootEffect], forbids: [].}

func `not`(left: Float): bool {....raises: [], tags: [RootEffect], forbids: [].}

func `not`(left: RID): bool {....raises: [], tags: [RootEffect], forbids: [].}

func `not`(left: Signal): bool {....raises: [], tags: [RootEffect], forbids: [].}

func `or`(left: bool; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: bool; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: bool; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Float; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Float; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Float; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Float; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Float; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Int; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Int; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Int; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `or`(left: Int; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

proc rid(): RID {....raises: [], tags: [], forbids: [].}

proc rid(from: RID): RID {....raises: [], tags: [], forbids: [].}

proc rpc(self: Callable; args: varargs[Variant, variant]): void {....raises: [],
    tags: [RootEffect], forbids: [].}

proc rpcId(self: Callable; peerId: Int; args: varargs[Variant, variant]): void {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc signal(): Signal {....raises: [], tags: [], forbids: [].}

proc signal(from: Signal): Signal {....raises: [], tags: [RootEffect], forbids: [].}

proc signal(object: Object; signal: StringName): Signal {....raises: [],
    tags: [RootEffect], forbids: [].}

proc unbind(self: Callable; argcount: Int): Callable {....raises: [],
    tags: [RootEffect], forbids: [].}

func `xor`(left: bool; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: bool; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: bool; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Float; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Float; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Float; right: Int): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Float; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Float; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Int; right: bool): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Int; right: Float): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Int; right: Object): bool {....raises: [], tags: [RootEffect],
    forbids: [].}

func `xor`(left: Int; right: Variant): bool {....raises: [], tags: [RootEffect],
    forbids: [].}