proc decode(p: pointer; _: typedesc[pointer]): pointer {.inline.}

proc decode(p: pointer; T: typedesc[ObjectPtr]): T:type {.inline.}

proc decode(p`gensym0: pointer; _: typedesc[AltString]): AltString {.inline.}

proc decode(p`gensym2: pointer; D`gensym2: typedesc[AltInt]): D`gensym2:type {.
    inline.}

proc decode(p`gensym3: pointer; D`gensym3: typedesc[AltFloat]): D`gensym3:type {.
    inline.}

proc decode[T: enum](p`gensym5: pointer; _: typedesc[T]): T {.inline.}

proc decode[T: Object](p: pointer; _: typedesc[T]): T {.inline.}

proc decode[T: RefCounted](p: pointer; Result: typedesc[GdRef[T]]): Result:type {.
    inline.}

proc decode[T: SomeBuiltins](p: pointer; _: typedesc[T]): T {.inline.}

proc decode[T](p: pointer; _: typedesc[ptr T]): ptr T {.inline.}

proc decode[T](p: ptr T; _: typedesc[T]): T {.inline.}

proc decode[T](p`gensym6: pointer; _: typedesc[set[T]]): set[T] {.inline.}

proc decode[T](p`gensym7: pointer; _: typedesc[TypedArray[T]]): TypedArray[T] {.
    inline.}

proc decode_result(p: pointer; Type: typedesc): Type:type {.inline.}

proc decode_result[T: RefCounted](p: pointer; Result: typedesc[GdRef[T]]): Result:type {.
    inline.}

proc get(v: Variant; T: typedesc[ObjectPtr]): T:type {.inline.}

proc get(v`gensym0: Variant; _: typedesc[AltString]): AltString {.inline.}

proc get(v`gensym2: Variant; D`gensym2: typedesc[AltInt]): D`gensym2:type {.
    inline.}

proc get(v`gensym3: Variant; D`gensym3: typedesc[AltFloat]): D`gensym3:type {.
    inline.}

proc get[T: enum](v`gensym5: Variant; _: typedesc[T]): T {.inline.}

proc get[T: Object](v: Variant; _: typedesc[T]): T {.inline.}

proc get[T: RefCounted](v: Variant; Result: typedesc[GdRef[T]]): Result:type {.
    inline.}

proc get[T: SomeBuiltins](v: Variant; _: typedesc[T]): T {.inline.}

proc get[T](v`gensym6: Variant; _: typedesc[set[T]]): set[T] {.inline.}

proc get[T](v`gensym7: Variant; _: typedesc[TypedArray[T]]): TypedArray[T] {.
    inline.}

proc getAddr(v: Variant; T: typedesc[ObjectPtr]): ptr T:type {.inline.}

proc getAddr[T: SomeBuiltins](v: Variant; _: typedesc[T]): ptr T {.inline.}

proc variant(v: ObjectPtr): Variant {.inline, ...raises: [], tags: [RootEffect],
                                      forbids: [].}

proc variant(v`gensym0: AltString): Variant {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc variant(v`gensym2: AltInt): Variant {.inline.}

proc variant(v`gensym3: AltFloat): Variant {.inline, ...raises: [],
    tags: [RootEffect], forbids: [].}

proc variant[T: enum](v`gensym5: T): Variant {.inline.}

proc variant[T: Object](v: T): Variant {.inline.}

proc variant[T: RefCounted](v: GdRef[T]): Variant {.inline.}

proc variant[T: SomeBuiltins](v: T): Variant {.inline.}

proc variant[T](v`gensym6: set[T]): Variant {.inline.}

proc variant[T](v`gensym7: TypedArray[T]): Variant {.inline.}

template APIType(T: typedesc[not Object]): typedesc

template APIType(T: typedesc[Object]): typedesc

template decode(p: pointer; T: typedesc[Variant]): T:type {..}

template encode(v: ObjectPtr; p: pointer) {..}

template encode(v: pointer; p: pointer) {..}

template encode(v: Variant; p: pointer) {..}

template encode(v`gensym0: AltString; p`gensym0: pointer) {..}

template encode(v`gensym2: AltInt; p`gensym2: pointer) {..}

template encode(v`gensym3: AltFloat; p`gensym3: pointer) {..}

template encode[T: enum](v`gensym5: T; p`gensym5: pointer) {..}

template encode[T: Object](v: T; p: pointer) {..}

template encode[T: RefCounted](v: GdRef[T]; p: pointer) {..}

template encode[T: SomeBuiltins](v: T; p: pointer) {..}

template encode[T](v: ptr T; p: pointer) {..}

template encode[T](v`gensym6: set[T]; p`gensym6: pointer) {..}

template encode[T](v`gensym7: TypedArray[T]; p`gensym7: pointer) {..}

template encoded(_: typedesc[pointer]): typedesc[pointer] {..}

template encoded(T: typedesc[ObjectPtr]): typedesc[ObjectPtr] {..}

template encoded(T: typedesc[Variant]): typedesc[Variant] {..}

template encoded(T`gensym0: typedesc[AltString]): typedesc[String] {..}

template encoded(T`gensym2: typedesc[AltInt]): typedesc[Int] {..}

template encoded(T`gensym3: typedesc[AltFloat]): typedesc[Float] {..}

template encoded[T: enum](_: typedesc[T]): typedesc[Int] {..}

template encoded[T: Object](_: typedesc[T]): typedesc[ObjectPtr] {..}

template encoded[T: RefCounted](_: typedesc[GdRef[T]]): typedesc[ObjectPtr] {..}

template encoded[T: SomeBuiltins](_: typedesc[T]): typedesc[T] {..}

template encoded[T](_: typedesc[ptr T]): typedesc[pointer] {..}

template encoded[T](_: typedesc[set[T]]): typedesc[Int] {..}

template encoded[T](_: typedesc[TypedArray[T]]): typedesc[Array] {..}

template get(v: Variant; T: typedesc[Variant]): T:type {..}

template variant(v: Variant): Variant {..}