proc `$`(exception: ref Exception): string {....raises: [], tags: [], forbids: [].}

proc asGdRef[T](self: T): GdRef[T]

proc callScriptMethod(obj: Object; p_method: StringName): Variant {.
    ...raises: [GodotCallDefect], tags: [RootEffect], forbids: [].}

proc callScriptMethod(obj: Object; p_method: StringName; args: array[0, Variant]): Variant {.
    ...raises: [GodotCallDefect], tags: [RootEffect], forbids: [].}

proc callScriptMethod[I](obj: Object; p_method: StringName;
                         args: array[I, Variant]): Variant

proc castTo(obj: Object; p_class_tag: pointer): ObjectPtr {....raises: [],
    tags: [RootEffect], forbids: [].}

proc constructObject(_: typedesc[ClassDB]; p_classname: StringName): ObjectPtr

proc createClass[T: Object](o: ObjectPtr): T

proc empty(_: typedesc[String]): var String

proc empty(_: typedesc[StringName]): var StringName

proc engineInstance(obj: Object): ObjectPtr {....raises: [], tags: [], forbids: [].}

proc getClassName(o: ObjectPtr): StringName {....raises: [], tags: [RootEffect],
    forbids: [].}

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

proc getClassTag(_: typedesc[ClassDB]; p_classname: StringName): pointer

proc getInstanceBinding(p_engine_object: ObjectPtr;
                        callbacks: var InstanceBindingCallbacks): pointer {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc getInstanceBinding[T: Object](p_engine_object: ObjectPtr; _: typedesc[T]): T

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

proc getMethodBind(_: typedesc[ClassDB]; p_classname: StringName;
                   p_methodname: string; p_hash: Int): MethodBindPtr

proc getMethodBind(_: typedesc[ClassDB]; p_classname: StringName;
                   p_methodname: StringName; p_hash: Int): MethodBindPtr

proc getPtr(arr: array[0, Variant]): array[0, pointer] {....raises: [], tags: [],
    forbids: [].}

proc getPtr(arr: varargs[Variant] | seq[Variant]): seq[pointer]

proc getPtr[I](arr: array[I, Variant]): array[I, pointer]

proc hasScriptMethod(obj: Object; p_method: StringName): bool {....raises: [],
    tags: [RootEffect], forbids: [].}

proc head[T](a: openArray[T]): ptr T

proc load(op: Variant_Operator; left, right: VariantType): PtrOperatorEvaluator {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc load(typ: VariantType; proc_name: string; hash: int64): PtrBuiltInMethod {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc Meta(T: typedesc[SomeClass]): var GodotClassMeta

proc newException(ce: CallError): ref GodotCallDefect {....raises: [], tags: [],
    forbids: [].}

proc referenced[T](self: T): GdRef[T]

proc registerExtensionClass(_: typedesc[ClassDB];
                            p_class_name, p_parent_class_name: StringName;
                            p_extension_funcs: ptr ClassCreationInfo4)

proc registerExtensionClassIntegerConstant(_: typedesc[ClassDB];
    p_class_name, p_enum_name, p_constant_name: StringName;
    p_constant_value: Int; p_is_bitfield: Bool)

proc registerExtensionClassMethod(_: typedesc[ClassDB];
                                  p_class_name: StringName;
                                  p_method_info: ptr ClassMethodInfo)

proc registerExtensionClassProperty(_: typedesc[ClassDB];
                                    p_class_name: StringName;
                                    p_info: ptr PropertyInfo;
                                    p_setter, p_getter: StringName)

proc registerExtensionClassPropertyGroup(_: typedesc[ClassDB];
    p_class_name: StringName; p_group_name, p_prefix: String)

proc registerExtensionClassPropertySubgroup(_: typedesc[ClassDB];
    p_class_name: StringName; p_subgroup_name, p_prefix: String)

proc registerExtensionClassSignal(_: typedesc[ClassDB];
                                  p_class_name: StringName;
                                  p_signal_name: StringName;
                                  args: varargs[PropertyInfo])

proc registerExtensionClassVirtualMethod(_: typedesc[ClassDB];
    p_class_name: StringName; p_method_info: ClassVirtualMethodInfo)

proc reporterr(exception: ref Exception) {....raises: [], tags: [RootEffect],
    forbids: [].}

proc setInstance(p_o: ObjectPtr; p_classname: StringName; p_instance: Object) {.
    ...raises: [], tags: [RootEffect], forbids: [].}

proc setInstanceBinding(p_o: ObjectPtr; p_binding: Object;
                        p_callbacks: ptr InstanceBindingCallbacks) {....raises: [],
    tags: [RootEffect], forbids: [].}

proc unregisterExtensionClass(_: typedesc[ClassDB]; p_class_name: StringName)

macro Super(Type: typedesc): typedesc

template callbacks(T: typedesc[SomeClass]): var InstanceBindingCallbacks

template check(ce: CallError): untyped

template className(T: typedesc[SomeClass]): var StringName

template errproof(body): untyped

template getPtr(v: GdRef): pointer

template getPtr(v: Variant): pointer

template getPtr[T: Object](v: T): pointer

template getPtr[T](v: T): pointer

template getTypedPtr(v: Variant): VariantPtr

template vmethods(T: typedesc[SomeClass]): var Table[StringName,
    ClassCallVirtual]