proc `&`(str: String): StringName {.inline, ...raises: [Exception],
                                    tags: [RootEffect], forbids: [].}

proc `^`(str: String): NodePath {.inline, ...raises: [Exception],
                                  tags: [RootEffect], forbids: [].}

proc `as`[T: RefCounted](self: GdRef; Result: typedesc[GdRef[T]]): Result:type

proc `as`[T: RefCounted](self: Object; Result: typedesc[GdRef[T]]): Result:type

proc `as`[T: SomeClass](self: SomeClass; _: typedesc[T]): T

converter convertToArray[T: not Variant](arr: Array[T]): Array[Variant] {.inline.}

converter convertToArray[T: not Variant](arr: var Array[T]): var Array[Variant] {.
    inline.}

converter convertToBool(variant: Variant): Bool {.inline, ...raises: [Exception],
    tags: [RootEffect], forbids: [].}

converter convertToDictionary[A, B](dict: Dictionary[A, B]): Dictionary[Variant,
    Variant] {.inline.}

converter convertToDictionary[A, B](dict: var Dictionary[A, B]): var Dictionary[
    Variant, Variant] {.inline.}

converter convertToNodePath(str: string): NodePath {.inline,
    ...raises: [Exception], tags: [RootEffect], forbids: [].}

converter convertToSingleton[T: SomeClass](_: typedesc[T]): T {.inline.}

converter convertToString(str: string): String {.inline, ...raises: [Exception],
    tags: [RootEffect], forbids: [].}

converter convertToStringName(str: string): StringName {.inline,
    ...raises: [Exception], tags: [RootEffect], forbids: [].}

converter convertToVaraint(x: Bool | SomeOrdinal | SomeFloat | SomeVector |
    Quaternion |
    Rect2 |
    Rect2i |
    Transform2D |
    Transform3D |
    Plane |
    AABB |
    Basis |
    Projection |
    Color |
    string |
    String |
    StringName |
    NodePath |
    RID |
    Callable |
    Signal): Variant {.inline.}

converter convertToVariant(x: GdRef): Variant {.inline.}

converter convertToVariant(x: Object): Variant {.inline, ...raises: [Exception],
    tags: [RootEffect], forbids: [].}

converter convertToVariant(x: PackedArray | Array | Dictionary): Variant {.
    inline.}

template `as`[T](v: Variant; Result: typedesc[T]): Result:type