leanCLR_gdext/tools/binding_generator/generate_bindings.py

#!/usr/bin/env python3
import argparse
import json
import re
from dataclasses import dataclass
from pathlib import Path


SMOKE_TEST_CLASSES = ["Object", "RefCounted", "Resource", "MainLoop", "SceneTree", "Node", "CanvasItem", "Node2D", "Control", "Label", "Sprite2D"]
CS_CLASS_NAMES = {"Object": "GodotObject"}
CPP_HEADER_NAME_OVERRIDES = {
    "Object": "object",
    "RefCounted": "ref_counted",
    "Resource": "resource",
    "MainLoop": "main_loop",
    "SceneTree": "scene_tree",
    "Node": "node",
    "CanvasItem": "canvas_item",
    "Node2D": "node2d",
    "Control": "control",
    "Label": "label",
    "Sprite2D": "sprite2d",
    "AnimationNodeBlendSpace1D": "animation_node_blend_space1_d",
    "ClassDB": "class_db_singleton",
    "EditorSceneFormatImporterFBX2GLTF": "editor_scene_format_importer_fbx2_gltf",
    "Generic6DOFJoint3D": "generic6_dof_joint3d",
    "GradientTexture1D": "gradient_texture1_d",
}
# godot-cpp 4.5 renamed ClassDB to a ClassDBSingleton wrapper. Map the API
# class name to the renamed C++ class and treat all of its methods as static
# (so the generated native side calls ClassDBSingleton::get_singleton()->...).
SINGLETON_CLASS_CPP_NAMES = {"ClassDB": "ClassDBSingleton"}
HANDWRITTEN_PARTIAL_CLASSES = {"GodotObject", "Node"}
CS_KEYWORDS = {
    "abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const",
    "continue", "decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern",
    "false", "finally", "fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "int", "interface",
    "internal", "is", "lock", "long", "namespace", "new", "null", "object", "operator", "out", "override",
    "params", "private", "protected", "public", "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof",
    "stackalloc", "static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong",
    "unchecked", "unsafe", "ushort", "using", "virtual", "void", "volatile", "while",
}

PROPERTY_METHODS = {
    ("Node", "get_name"),
    ("Node", "set_name"),
    ("Node2D", "get_position"),
    ("Node2D", "set_position"),
    ("Node2D", "get_global_position"),
    ("Node2D", "set_global_position"),
    ("Node2D", "get_scale"),
    ("Node2D", "set_scale"),
    ("Control", "get_position"),
    ("Control", "set_position"),
    ("Control", "get_size"),
    ("Control", "set_size"),
    ("Label", "get_text"),
    ("Label", "set_text"),
    ("Sprite2D", "is_centered"),
    ("Sprite2D", "set_centered"),
    ("Sprite2D", "get_offset"),
    ("Sprite2D", "set_offset"),
    ("Sprite2D", "is_flipped_h"),
    ("Sprite2D", "set_flip_h"),
    ("Sprite2D", "is_flipped_v"),
    ("Sprite2D", "set_flip_v"),
}

EXCLUDED_METHODS = set()

METHOD_ALIASES = {
    ("Object", "to_string"): "ToGodotString",
    ("Node", "get_node"): "GetNode",
    ("Node", "get_node_or_null"): "GetNodeOrNull",
}

ICALL_SUFFIX_ALIASES = {
    ("Node", "get_node"): "GetNode",
    ("Node", "get_node_or_null"): "GetNodeOrNull",
}

CPP_METHOD_ALIASES = {
    ("Node", "get_node"): "get_node<Node>",
    ("Node", "get_node_or_null"): "get_node_or_null",
    ("TextServer", "shaped_get_run_glyph_range"): "shaped_get_run_range",
}

METHOD_ARGUMENT_TYPE_OVERRIDES = {
    ("FileAccess", "create_temp", "mode_flags"): ("enum::FileAccess.ModeFlags", None),
}

STRING_LIKE_TYPES = {"String", "StringName", "NodePath"}
PACKED_ARRAY_TYPES = {
    "PackedByteArray", "PackedInt32Array", "PackedInt64Array", "PackedFloat32Array", "PackedFloat64Array",
    "PackedVector2Array", "PackedVector3Array", "PackedColorArray",
}
OPAQUE_VARIANT_TYPES = {"Array", "Dictionary", "Callable", "Signal"}
OPAQUE_VALUE_TYPES = set()
INT32_META = {"int8", "uint8", "int16", "uint16", "int32", "uint32", "char16", "char32"}
INT64_META = {"int64", "uint64"}
CPP_INT_TYPES = {
    "int8": "int8_t",
    "uint8": "uint8_t",
    "int16": "int16_t",
    "uint16": "uint16_t",
    "int32": "int32_t",
    "uint32": "uint32_t",
    "char16": "char16_t",
    "char32": "char32_t",
    "int64": "int64_t",
    "uint64": "uint64_t",
}

PACKED_ARRAY_INFOS = {
    "PackedByteArray": {"cs": "byte", "cpp": "PackedByteArray", "stack": "uint8_t", "default": "0"},
    "PackedInt32Array": {"cs": "int", "cpp": "PackedInt32Array", "stack": "int32_t", "default": "0"},
    "PackedInt64Array": {"cs": "long", "cpp": "PackedInt64Array", "stack": "int64_t", "default": "0"},
    "PackedFloat32Array": {"cs": "float", "cpp": "PackedFloat32Array", "stack": "float", "default": "0.0f"},
    "PackedFloat64Array": {"cs": "double", "cpp": "PackedFloat64Array", "stack": "double", "default": "0.0"},
    "PackedVector2Array": {"cs": "Vector2", "cpp": "PackedVector2Array", "stack": "Vector2", "default": "Vector2()"},
    "PackedVector3Array": {"cs": "Vector3", "cpp": "PackedVector3Array", "stack": "Vector3", "default": "Vector3()"},
    "PackedColorArray": {"cs": "Color", "cpp": "PackedColorArray", "stack": "Color", "default": "Color()"},
}


@dataclass(frozen=True)
class TypeInfo:
    managed_type: str
    native_type: str
    stack_type: str
    signature_type: str
    category: str
    cpp_type: str = ""
    cs_class: str = ""
    stack_slots: int = 1


@dataclass(frozen=True)
class GeneratedMethod:
    class_name: str
    cs_class_name: str
    cpp_class_name: str
    api_name: str
    cpp_name: str
    cs_name: str
    icall_suffix: str
    return_type: TypeInfo
    args: tuple
    is_static: bool
    is_virtual: bool = False
    is_vararg: bool = False


def write(path, content):
    path.parent.mkdir(parents=True, exist_ok=True)
    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
    with path.open("w", encoding="utf-8", newline="") as file:
        file.write(normalized.replace("\n", "\r\n"))


def cs_class_name(class_name):
    return cs_identifier(CS_CLASS_NAMES.get(class_name, class_name), "GodotType")


def cs_identifier(name, fallback):
    identifier = re.sub(r"[^0-9A-Za-z_]", "_", name)
    if not identifier:
        identifier = fallback
    if identifier[0].isdigit():
        identifier = f"{fallback}{identifier}"
    if identifier.lower() in CS_KEYWORDS:
        identifier = f"{identifier}_"
    return identifier


def pascal_name(snake_name):
    return cs_identifier("".join(part.capitalize() for part in snake_name.split("_") if part), "Value")


def camel_name(snake_name):
    pascal = pascal_name(snake_name)
    return pascal[:1].lower() + pascal[1:]


def native_function_name(method):
    return f"godot_{method.cs_class_name}_{method.icall_suffix}".lower()


def cpp_header_name(class_name):
    if class_name in CPP_HEADER_NAME_OVERRIDES:
        return CPP_HEADER_NAME_OVERRIDES[class_name]
    header = re.sub(r"(.)([A-Z][a-z]+)", r"\1_\2", class_name)
    header = re.sub(r"([a-z])([A-Z])", r"\1_\2", header)
    return header.lower()


def icall_name(method):
    param_types = [] if method.is_static else ["System.IntPtr"]
    param_sig = ",".join(param_types + [arg["type"].signature_type for arg in method.args])
    if method.is_vararg:
        param_sig = param_sig + ("," if param_sig else "") + "Godot.Variant[]"
    return f"Godot.NativeCalls::Godot{method.cs_class_name}{method.icall_suffix}({param_sig})"


def class_inherits(class_name, base_name, classes):
    current = classes.get(class_name, {}).get("inherits")
    while current:
        if current == base_name:
            return True
        current = classes.get(current, {}).get("inherits")
    return False


def method_type_info(raw_type, meta, class_names, classes=None, global_enum_names=None, global_bitfield_names=None):
    if raw_type is None:
        return TypeInfo("void", "leanclr::RtResultVoid", "", "", "void", stack_slots=0)
    if raw_type == "bool":
        return TypeInfo("bool", "bool", "bool", "System.Boolean", "bool")
    if raw_type == "float":
        return TypeInfo("float", "float", "float", "System.Single", "float")
    if raw_type == "int":
        if meta in INT32_META:
            return TypeInfo("int", "int32_t", "int32_t", "System.Int32", "int", cpp_type=CPP_INT_TYPES[meta])
        if meta in INT64_META:
            return TypeInfo("long", "int64_t", "int64_t", "System.Int64", "int", cpp_type=CPP_INT_TYPES[meta])
        return TypeInfo("long", "int64_t", "int64_t", "System.Int64", "int")
    if raw_type in STRING_LIKE_TYPES:
        managed_type = "string" if raw_type == "String" else raw_type
        return TypeInfo(managed_type, "leanclr::vm::RtString*", "leanclr::vm::RtString*", "System.String", "string", cpp_type=raw_type)
    if raw_type == "Variant":
        return TypeInfo("Variant", "ManagedVariant", "ManagedVariant", "Godot.Variant", "variant", cpp_type="Variant", stack_slots=9)
    if raw_type == "PackedStringArray":
        return TypeInfo("PackedStringArray", "intptr_t", "intptr_t", "System.IntPtr", "packed_string_array", cpp_type="PackedStringArray")
    if raw_type in PACKED_ARRAY_TYPES:
        return TypeInfo(raw_type, "intptr_t", "intptr_t", "System.IntPtr", "packed_array", cpp_type=raw_type, cs_class=raw_type)
    if raw_type in OPAQUE_VARIANT_TYPES:
        return TypeInfo(raw_type, "intptr_t", "intptr_t", "System.IntPtr", "opaque_variant", cpp_type=raw_type, cs_class=raw_type)
    if raw_type and raw_type.startswith("typedarray::"):
        element_type = raw_type.removeprefix("typedarray::")
        cpp_element_type = element_type
        if element_type == "Object":
            cpp_element_type = "Object"
        return TypeInfo("GodotArray", "intptr_t", "intptr_t", "System.IntPtr", "typed_array", cpp_type=f"TypedArray<{cpp_element_type}>", cs_class="GodotArray")
    if raw_type in OPAQUE_VALUE_TYPES:
        return TypeInfo(raw_type, "intptr_t", "intptr_t", "System.IntPtr", "opaque_value", cpp_type=raw_type, cs_class=raw_type)
    if raw_type in {"const void*", "const GDExtensionInitializationFunction*"} or (raw_type and raw_type.endswith("*")):
        return TypeInfo("IntPtr", "intptr_t", "intptr_t", "System.IntPtr", "native_pointer", cpp_type=raw_type)
    if raw_type == "Vector2":
        return TypeInfo("Vector2", "Vector2", "Vector2", "Godot.Vector2", "vector2", cpp_type="Vector2")
    if raw_type == "Vector2i":
        return TypeInfo("Vector2i", "Vector2i", "Vector2i", "Godot.Vector2i", "vector2i", cpp_type="Vector2i")
    if raw_type == "Vector3":
        return TypeInfo("Vector3", "Vector3", "Vector3", "Godot.Vector3", "vector3", cpp_type="Vector3", stack_slots=2)
    if raw_type == "Vector3i":
        return TypeInfo("Vector3i", "Vector3i", "Vector3i", "Godot.Vector3i", "vector3i", cpp_type="Vector3i", stack_slots=2)
    if raw_type == "Color":
        return TypeInfo("Color", "Color", "Color", "Godot.Color", "color", cpp_type="Color", stack_slots=2)
    if raw_type == "Rect2":
        return TypeInfo("Rect2", "Rect2", "Rect2", "Godot.Rect2", "rect2", cpp_type="Rect2", stack_slots=2)
    if raw_type == "Rect2i":
        return TypeInfo("Rect2i", "Rect2i", "Rect2i", "Godot.Rect2i", "rect2i", cpp_type="Rect2i", stack_slots=2)
    if raw_type == "Transform2D":
        return TypeInfo("Transform2D", "Transform2D", "Transform2D", "Godot.Transform2D", "transform2d", cpp_type="Transform2D", stack_slots=3)
    if raw_type == "AABB":
        return TypeInfo("Aabb", "AABB", "AABB", "Godot.Aabb", "aabb", cpp_type="AABB", stack_slots=3)
    if raw_type == "Quaternion":
        return TypeInfo("Quaternion", "Quaternion", "Quaternion", "Godot.Quaternion", "quaternion", cpp_type="Quaternion", stack_slots=2)
    if raw_type == "Basis":
        return TypeInfo("Basis", "Basis", "Basis", "Godot.Basis", "basis", cpp_type="Basis", stack_slots=5)
    if raw_type == "Transform3D":
        return TypeInfo("Transform3D", "Transform3D", "Transform3D", "Godot.Transform3D", "transform3d", cpp_type="Transform3D", stack_slots=6)
    if raw_type == "Vector4":
        return TypeInfo("Vector4", "Vector4", "Vector4", "Godot.Vector4", "vector4", cpp_type="Vector4", stack_slots=2)
    if raw_type == "Vector4i":
        return TypeInfo("Vector4i", "Vector4i", "Vector4i", "Godot.Vector4i", "vector4i", cpp_type="Vector4i", stack_slots=2)
    if raw_type == "Plane":
        return TypeInfo("Plane", "Plane", "Plane", "Godot.Plane", "plane", cpp_type="Plane", stack_slots=2)
    if raw_type == "Projection":
        return TypeInfo("Projection", "Projection", "Projection", "Godot.Projection", "projection", cpp_type="Projection", stack_slots=8)
    if raw_type == "RID":
        return TypeInfo("RID", "RID", "RID", "Godot.RID", "rid", cpp_type="RID")
    if raw_type and raw_type.startswith("enum::"):
        enum_name = raw_type.removeprefix("enum::")
        if "." not in enum_name:
            if global_enum_names is not None and enum_name in global_enum_names:
                managed_name = cs_identifier(enum_name, "GodotEnum")
                return TypeInfo(managed_name, "int32_t", "int32_t", "System.Int32", "enum", cpp_type=enum_name)
            return TypeInfo("", "", "", "", "unsupported")
        class_name, nested_name = enum_name.split(".", 1)
        managed_name = f"{cs_class_name(class_name)}.{cs_identifier(nested_name, 'GodotEnum')}"
        return TypeInfo(managed_name, "int32_t", "int32_t", "System.Int32", "enum", cpp_type=enum_name.replace(".", "::"))
    if raw_type and raw_type.startswith("bitfield::"):
        bitfield_name = raw_type.removeprefix("bitfield::")
        if "." not in bitfield_name:
            if global_bitfield_names is not None and bitfield_name in global_bitfield_names:
                managed_name = cs_identifier(bitfield_name, "GodotBitfield")
                return TypeInfo(managed_name, "int64_t", "int64_t", "System.Int64", "bitfield", cpp_type=f"BitField<{bitfield_name}>")
            return TypeInfo("", "", "", "", "unsupported")
        class_name, nested_name = bitfield_name.split(".", 1)
        cpp_enum_name = bitfield_name.replace(".", "::")
        managed_name = f"{cs_class_name(class_name)}.{cs_identifier(nested_name, 'GodotBitfield')}"
        return TypeInfo(managed_name, "int64_t", "int64_t", "System.Int64", "bitfield", cpp_type=f"BitField<{cpp_enum_name}>")
    if raw_type in class_names:
        if classes is not None and (raw_type == "RefCounted" or class_inherits(raw_type, "RefCounted", classes)):
            return TypeInfo(cs_class_name(raw_type), "intptr_t", "intptr_t", "System.IntPtr", "refcounted", cpp_type=raw_type, cs_class=cs_class_name(raw_type))
        return TypeInfo(cs_class_name(raw_type), "intptr_t", "intptr_t", "System.IntPtr", "object", cpp_type=raw_type, cs_class=cs_class_name(raw_type))
    return TypeInfo("", "", "", "", "unsupported")


def is_supported_type(type_info):
    return type_info.category in {"void", "bool", "float", "int", "string", "variant", "packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value", "native_pointer", "object", "refcounted", "enum", "bitfield", "vector2", "vector2i", "vector3", "vector3i", "color", "rect2", "rect2i", "transform2d", "aabb", "quaternion", "basis", "transform3d", "vector4", "vector4i", "plane", "projection", "rid"}


def empty_report(class_order):
    return {
        "class_count": len(class_order),
        "generated_managed_classes": len(class_order),
        "native_bound_classes": [],
        "generated_methods": 0,
        "skipped_methods": {},
        "unsupported_type_counts": {},
        "overview": {},
        "per_class": [],
        "examples": {},
    }


def add_report_skip(report, reason, example, raw_type=None):
    report["skipped_methods"][reason] = report["skipped_methods"].get(reason, 0) + 1
    examples = report["examples"].setdefault(reason, [])
    if len(examples) < 20:
        examples.append(example)
    if raw_type:
        report["unsupported_type_counts"][raw_type] = report["unsupported_type_counts"].get(raw_type, 0) + 1


def method_example(class_name, method):
    return f"{class_name}.{method['name']}"


def method_skip_reason(class_name, method, class_names, classes, global_enum_names, global_bitfield_names):
    if (class_name, method["name"]) in EXCLUDED_METHODS:
        return "excluded_method", None
    if method.get("is_vararg"):
        return "vararg_method", None
    if method.get("is_virtual"):
        return "virtual_method", None
    return_value = method.get("return_value") or {}
    return_type = method_type_info(return_value.get("type"), return_value.get("meta"), class_names, classes, global_enum_names, global_bitfield_names)
    if not is_supported_type(return_type):
        return "unsupported_return", return_value.get("type")
    for arg in method.get("arguments", []):
        if "default_value" in arg:
            continue
        raw_type, meta = METHOD_ARGUMENT_TYPE_OVERRIDES.get((class_name, method["name"], arg["name"]), (arg["type"], arg.get("meta")))
        arg_type = method_type_info(raw_type, meta, class_names, classes, global_enum_names, global_bitfield_names)
        if not is_supported_type(arg_type) or arg_type.category == "void":
            return "unsupported_argument", arg.get("type")
    return "supported_signature_not_selected", None


def build_generated_method(class_name, api_method, class_names, classes, global_enum_names, global_bitfield_names):
    if (class_name, api_method["name"]) in EXCLUDED_METHODS:
        return None, "excluded_method", None
    is_vararg = bool(api_method.get("is_vararg"))
    is_virtual = bool(api_method.get("is_virtual"))

    return_value = api_method.get("return_value") or {}
    return_type = method_type_info(return_value.get("type"), return_value.get("meta"), class_names, classes, global_enum_names, global_bitfield_names)
    if not is_supported_type(return_type):
        return None, "unsupported_return", return_value.get("type")

    args = []
    for arg in api_method.get("arguments", []):
        if "default_value" in arg:
            continue
        raw_type, meta = METHOD_ARGUMENT_TYPE_OVERRIDES.get((class_name, api_method["name"], arg["name"]), (arg["type"], arg.get("meta")))
        arg_type = method_type_info(raw_type, meta, class_names, classes, global_enum_names, global_bitfield_names)
        if not is_supported_type(arg_type) or arg_type.category == "void":
            return None, "unsupported_argument", arg.get("type")
        args.append({"name": arg["name"], "type": arg_type})

    api_name = api_method["name"]
    if is_virtual and api_name.startswith("_"):
        cs_name = "_" + pascal_name(api_name[1:])
    else:
        cs_name = METHOD_ALIASES.get((class_name, api_name), pascal_name(api_name))
    icall_suffix = ICALL_SUFFIX_ALIASES.get((class_name, api_name), cs_name)
    cpp_name = CPP_METHOD_ALIASES.get((class_name, api_name), api_name)
    return GeneratedMethod(
        class_name=class_name,
        cs_class_name=cs_class_name(class_name),
        cpp_class_name=SINGLETON_CLASS_CPP_NAMES.get(class_name, class_name),
        api_name=api_name,
        cpp_name=cpp_name,
        cs_name=cs_name,
        icall_suffix=icall_suffix,
        return_type=return_type,
        args=tuple(args),
        is_static=bool(api_method.get("is_static")) or class_name in SINGLETON_CLASS_CPP_NAMES,
        is_virtual=is_virtual,
        is_vararg=is_vararg,
    ), None, None


def build_model(api):
    classes = {entry["name"]: entry for entry in api["classes"]}
    class_order = [entry["name"] for entry in api["classes"]]
    class_names = set(classes.keys())
    global_enums = api.get("global_enums", [])
    global_enum_names = {entry["name"] for entry in global_enums if not entry.get("is_bitfield")}
    global_bitfield_names = {entry["name"] for entry in global_enums if entry.get("is_bitfield")}
    missing_classes = [name for name in SMOKE_TEST_CLASSES if name not in classes]
    if missing_classes:
        raise SystemExit("extension_api.json is missing required classes: " + ", ".join(missing_classes))

    methods = []
    report = empty_report(class_order)
    generated_signatures = set()
    per_class = {name: {"class_name": name, "methods_total": len(classes[name].get("methods", [])), "methods_generated": 0, "methods_skipped": 0, "skip_reasons": {}} for name in class_order}
    for class_name in class_order:
        for api_method in classes[class_name].get("methods", []):
            method, reason, raw_type = build_generated_method(class_name, api_method, class_names, classes, global_enum_names, global_bitfield_names)
            if method is None:
                add_report_skip(report, reason, method_example(class_name, api_method), raw_type)
                per_class[class_name]["methods_skipped"] += 1
                per_class[class_name]["skip_reasons"][reason] = per_class[class_name]["skip_reasons"].get(reason, 0) + 1
                continue

            signature = (method.class_name, method.is_static, method.cs_name, tuple(arg["type"].managed_type for arg in method.args), method.is_vararg)
            if signature in generated_signatures:
                add_report_skip(report, "duplicate_managed_signature", method_example(class_name, api_method))
                per_class[class_name]["methods_skipped"] += 1
                per_class[class_name]["skip_reasons"]["duplicate_managed_signature"] = per_class[class_name]["skip_reasons"].get("duplicate_managed_signature", 0) + 1
                continue
            generated_signatures.add(signature)
            methods.append(method)
            per_class[class_name]["methods_generated"] += 1

    report["generated_methods"] = len(methods)
    native_methods = [method for method in methods if not method.is_virtual]
    native_bound_classes = sorted({method.class_name for method in native_methods})
    total_methods = sum(entry["methods_total"] for entry in per_class.values())
    skipped_methods = sum(report["skipped_methods"].values())
    report["native_bound_classes"] = native_bound_classes
    report["overview"] = {
        "api_class_count": len(class_order),
        "skeleton_class_count": len(class_order),
        "native_bound_class_count": len(native_bound_classes),
        "classes_with_generated_methods": len(native_bound_classes),
        "total_methods": total_methods,
        "generated_methods": len(methods),
        "generated_native_methods": len(native_methods),
        "generated_virtual_stubs": sum(1 for method in methods if method.is_virtual),
        "generated_vararg_bridges": sum(1 for method in methods if method.is_vararg),
        "skipped_methods": skipped_methods,
        "class_skeleton_coverage_pct": 100.0,
        "native_class_coverage_pct": round(len(native_bound_classes) * 100.0 / len(class_order), 2) if class_order else 0.0,
        "method_coverage_pct": round(len(methods) * 100.0 / total_methods, 2) if total_methods else 0.0,
    }
    class_rows = []
    for class_name in class_order:
        row = per_class[class_name]
        row["coverage_pct"] = round(row["methods_generated"] * 100.0 / row["methods_total"], 2) if row["methods_total"] else 0.0
        class_rows.append(row)
    report["per_class"] = class_rows
    return classes, class_order, global_enums, methods, report


def managed_base_clause(class_name, classes):
    cs_name = cs_class_name(class_name)
    if cs_name in HANDWRITTEN_PARTIAL_CLASSES:
        return ""
    base = classes[class_name].get("inherits")
    if not base:
        return ""
    return f" : {cs_class_name(base)}"


def managed_arg_declaration(arg):
    return f"{arg['type'].managed_type} {camel_name(arg['name'])}"


def managed_native_arg_expression(arg):
    name = camel_name(arg["name"])
    if arg["type"].category == "variant":
        return name
    if arg["type"].category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return f"{name} != null ? {name}.NativePtr : IntPtr.Zero"
    if arg["type"].category in {"object", "refcounted"}:
        return f"{name} != null ? {name}.NativePtr : IntPtr.Zero"
    if arg["type"].category == "string" and arg["type"].managed_type != "string":
        return f"{name}.ToString()"
    if arg["type"].category == "enum":
        return f"(int){name}"
    if arg["type"].category == "bitfield":
        return f"(long){name}"
    return name


def managed_return_expression(method, call):
    if method.return_type.category == "void":
        return f"            {call};"
    if method.return_type.category == "object":
        return f"            return CreateFromNative<{method.return_type.cs_class}>({call});"
    if method.return_type.category == "refcounted":
        return f"            return CreateFromNative<{method.return_type.cs_class}>({call}, true);"
    if method.return_type.category == "variant":
        return f"            return {call};"
    if method.return_type.category == "packed_string_array":
        return f"            return PackedStringArray.CreateFromNative({call});"
    if method.return_type.category in {"packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return f"            return {method.return_type.cs_class}.CreateFromNative({call});"
    if method.return_type.category == "string" and method.return_type.managed_type != "string":
        return f"            return new {method.return_type.managed_type}({call});"
    if method.return_type.category == "enum":
        return f"            return ({method.return_type.managed_type}){call};"
    if method.return_type.category == "bitfield":
        return f"            return ({method.return_type.managed_type}){call};"
    return f"            return {call};"


def managed_default_return_expression(type_info):
    category = type_info.category
    if category == "void":
        return ""
    if category == "bool":
        return "            return false;"
    if category in {"int", "enum", "bitfield"}:
        return "            return 0;"
    if category == "float":
        return "            return 0.0f;"
    if category == "string":
        return "            return string.Empty;"
    if category in {"object", "refcounted", "packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return "            return null;"
    return f"            return default({type_info.managed_type});"


def generate_managed_method(method):
    if (method.class_name, method.api_name) in PROPERTY_METHODS:
        return ""
    if method.class_name == "Node" and method.api_name in {"_ready", "_process"}:
        return ""
    if method.class_name == "Node" and method.api_name == "get_node":
        return """        public T GetNode<T>(NodePath path) where T : Node, new()
        {
            return CreateFromNative<T>(NativeCalls.GodotNodeGetNode(NativePtr, path.ToString()));
        }
"""
    if method.class_name == "Node" and method.api_name == "get_node_or_null":
        return """        public T GetNodeOrNull<T>(NodePath path) where T : Node, new()
        {
            return CreateFromNative<T>(NativeCalls.GodotNodeGetNodeOrNull(NativePtr, path.ToString()));
        }
"""

    args = ", ".join(managed_arg_declaration(arg) for arg in method.args)
    if method.is_vararg:
        args = (args + ", " if args else "") + "params Variant[] varargs"
    if method.is_virtual:
        return_type = method.return_type.managed_type
        body = managed_default_return_expression(method.return_type)
        return f"""        public virtual {return_type} {method.cs_name}({args})
        {{
{body}
        }}
"""
    native_args = ([] if method.is_static else ["NativePtr"]) + [managed_native_arg_expression(arg) for arg in method.args]
    if method.is_vararg:
        native_args.append("varargs")
    call = f"NativeCalls.Godot{method.cs_class_name}{method.icall_suffix}(" + ", ".join(native_args) + ")"
    return_type = method.return_type.managed_type
    body = managed_return_expression(method, call)
    static_modifier = "static " if method.is_static else ""
    return f"""        public {static_modifier}{return_type} {method.cs_name}({args})
        {{
{body}
        }}
"""


def generate_node_name_property():
    return """        public StringName Name
        {
            get { return new StringName(NativeCalls.GodotNodeGetName(NativePtr)); }
            set { NativeCalls.GodotNodeSetName(NativePtr, value.ToString()); }
        }
"""


def generate_node2d_vector2_property(property_name, getter, setter):
    return f"""        public Vector2 {property_name}
        {{
            get {{ return NativeCalls.GodotNode2D{getter}(NativePtr); }}
            set {{ NativeCalls.GodotNode2D{setter}(NativePtr, value); }}
        }}
"""


def generate_vector2_property(class_name, property_name, getter, setter):
    return f"""        public Vector2 {property_name}
        {{
            get {{ return NativeCalls.Godot{class_name}{getter}(NativePtr); }}
            set {{ NativeCalls.Godot{class_name}{setter}(NativePtr, value); }}
        }}
"""


def generate_bool_property(class_name, property_name, getter, setter):
    return f"""        public bool {property_name}
        {{
            get {{ return NativeCalls.Godot{class_name}{getter}(NativePtr); }}
            set {{ NativeCalls.Godot{class_name}{setter}(NativePtr, value); }}
        }}
"""


def generate_string_property(class_name, property_name, getter, setter):
    return f"""        public string {property_name}
        {{
            get {{ return NativeCalls.Godot{class_name}{getter}(NativePtr); }}
            set {{ NativeCalls.Godot{class_name}{setter}(NativePtr, value); }}
        }}
"""


def generate_builtin_wrappers(generated):
    write(
        generated / "Variant.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Explicit)]
        public partial struct Variant : IEquatable<Variant>
        {
        private const int OwnsNativePtrFlag = 1;

        [StructLayout(LayoutKind.Explicit)]
        private struct VariantUnion
        {
            [FieldOffset(0)]
            public bool Bool;

            [FieldOffset(0)]
            public long Int;

            [FieldOffset(0)]
            public double Float;

            [FieldOffset(0)]
            public string String;

            [FieldOffset(0)]
            public long Rid;

            [FieldOffset(0)]
            public IntPtr NativePtr;

            [FieldOffset(0)]
            public Vector2 Vector2;

            [FieldOffset(0)]
            public Vector2i Vector2i;

            [FieldOffset(0)]
            public Vector3 Vector3;

            [FieldOffset(0)]
            public Vector3i Vector3i;

            [FieldOffset(0)]
            public Vector4 Vector4;

            [FieldOffset(0)]
            public Vector4i Vector4i;

            [FieldOffset(0)]
            public Color Color;

            [FieldOffset(0)]
            public Rect2 Rect2;

            [FieldOffset(0)]
            public Rect2i Rect2i;

            [FieldOffset(0)]
            public Transform2D Transform2D;

            [FieldOffset(0)]
            public Aabb Aabb;

            [FieldOffset(0)]
            public Quaternion Quaternion;

            [FieldOffset(0)]
            public Basis Basis;

            [FieldOffset(0)]
            public Transform3D Transform3D;

            [FieldOffset(0)]
            public Plane Plane;

            [FieldOffset(0)]
            public Projection Projection;
        }

        [FieldOffset(0)]
        private Type variantType;

        [FieldOffset(4)]
        private int flags;

        [FieldOffset(8)]
        private VariantUnion data;

        public Variant(bool value)
        {
            variantType = Type.Bool_;
            flags = 0;
            data = default(VariantUnion);
            data.Bool = value;
        }

        public Variant(int value)
            : this((long)value)
        {
        }

        public Variant(long value)
        {
            variantType = Type.Int_;
            flags = 0;
            data = default(VariantUnion);
            data.Int = value;
        }

        public Variant(float value)
            : this((double)value)
        {
        }

        public Variant(double value)
        {
            variantType = Type.Float_;
            flags = 0;
            data = default(VariantUnion);
            data.Float = value;
        }

        public Variant(string value)
        {
            variantType = Type.String_;
            flags = 0;
            data = default(VariantUnion);
            data.String = value ?? string.Empty;
        }

        public Variant(StringName value)
        {
            variantType = Type.StringName;
            flags = 0;
            data = default(VariantUnion);
            data.String = value.ToString();
        }

        public Variant(NodePath value)
        {
            variantType = Type.NodePath;
            flags = 0;
            data = default(VariantUnion);
            data.String = value.ToString();
        }

        public Variant(RID value)
        {
            variantType = Type.Rid;
            flags = 0;
            data = default(VariantUnion);
            data.Rid = value.GetId();
        }

        public Variant(GodotObject value)
        {
            variantType = Type.Object_;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(Array value)
        {
            variantType = Type.Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(Dictionary value)
        {
            variantType = Type.Dictionary;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedByteArray value)
        {
            variantType = Type.PackedByteArray;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedInt32Array value)
        {
            variantType = Type.PackedInt32Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedInt64Array value)
        {
            variantType = Type.PackedInt64Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedFloat32Array value)
        {
            variantType = Type.PackedFloat32Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedFloat64Array value)
        {
            variantType = Type.PackedFloat64Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedStringArray value)
        {
            variantType = Type.PackedStringArray;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedVector2Array value)
        {
            variantType = Type.PackedVector2Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedVector3Array value)
        {
            variantType = Type.PackedVector3Array;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(PackedColorArray value)
        {
            variantType = Type.PackedColorArray;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(Callable value)
        {
            variantType = Type.Callable;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(Signal value)
        {
            variantType = Type.Signal;
            flags = 0;
            data = default(VariantUnion);
            data.NativePtr = value != null ? value.NativePtr : IntPtr.Zero;
        }

        public Variant(Vector2 value)
        {
            variantType = Type.Vector2;
            flags = 0;
            data = default(VariantUnion);
            data.Vector2 = value;
        }

        public Variant(Vector2i value)
        {
            variantType = Type.Vector2i;
            flags = 0;
            data = default(VariantUnion);
            data.Vector2i = value;
        }

        public Variant(Vector3 value)
        {
            variantType = Type.Vector3;
            flags = 0;
            data = default(VariantUnion);
            data.Vector3 = value;
        }

        public Variant(Vector3i value)
        {
            variantType = Type.Vector3i;
            flags = 0;
            data = default(VariantUnion);
            data.Vector3i = value;
        }

        public Variant(Vector4 value)
        {
            variantType = Type.Vector4;
            flags = 0;
            data = default(VariantUnion);
            data.Vector4 = value;
        }

        public Variant(Vector4i value)
        {
            variantType = Type.Vector4i;
            flags = 0;
            data = default(VariantUnion);
            data.Vector4i = value;
        }

        public Variant(Projection value)
        {
            variantType = Type.Projection;
            flags = 0;
            data = default(VariantUnion);
            data.Projection = value;
        }

        public Variant(Color value)
        {
            variantType = Type.Color;
            flags = 0;
            data = default(VariantUnion);
            data.Color = value;
        }

        public Variant(Rect2 value)
        {
            variantType = Type.Rect2;
            flags = 0;
            data = default(VariantUnion);
            data.Rect2 = value;
        }

        public Variant(Rect2i value)
        {
            variantType = Type.Rect2i;
            flags = 0;
            data = default(VariantUnion);
            data.Rect2i = value;
        }

        public Variant(Transform2D value)
        {
            variantType = Type.Transform2d;
            flags = 0;
            data = default(VariantUnion);
            data.Transform2D = value;
        }

        public Variant(Aabb value)
        {
            variantType = Type.Aabb;
            flags = 0;
            data = default(VariantUnion);
            data.Aabb = value;
        }

        public Variant(Plane value)
        {
            variantType = Type.Plane;
            flags = 0;
            data = default(VariantUnion);
            data.Plane = value;
        }

        public Variant(Quaternion value)
        {
            variantType = Type.Quaternion;
            flags = 0;
            data = default(VariantUnion);
            data.Quaternion = value;
        }

        public Variant(Basis value)
        {
            variantType = Type.Basis;
            flags = 0;
            data = default(VariantUnion);
            data.Basis = value;
        }

        public Variant(Transform3D value)
        {
            variantType = Type.Transform3d;
            flags = 0;
            data = default(VariantUnion);
            data.Transform3D = value;
        }

        public Type VariantType
        {
            get { return variantType; }
        }

        public void Dispose()
        {
            if ((flags & OwnsNativePtrFlag) != 0 && data.NativePtr != IntPtr.Zero)
            {
                if (variantType == Type.Array || variantType == Type.Dictionary || variantType == Type.Callable || variantType == Type.Signal || variantType == Type.PackedByteArray || variantType == Type.PackedInt32Array || variantType == Type.PackedInt64Array || variantType == Type.PackedFloat32Array || variantType == Type.PackedFloat64Array || variantType == Type.PackedVector2Array || variantType == Type.PackedVector3Array || variantType == Type.PackedColorArray)
                {
                    NativeCalls.GodotOpaqueValueDestroy(data.NativePtr);
                }
                else if (variantType == Type.PackedStringArray)
                {
                    NativeCalls.GodotPackedStringArrayDestroy(data.NativePtr);
                }

                data.NativePtr = IntPtr.Zero;
                flags = 0;
            }
        }

        public bool AsBool()
        {
            return data.Bool;
        }

        public long AsInt64()
        {
            return data.Int;
        }

        public double AsDouble()
        {
            return data.Float;
        }

        public string AsString()
        {
            return data.String ?? string.Empty;
        }

        public StringName AsStringName()
        {
            return new StringName(data.String ?? string.Empty);
        }

        public NodePath AsNodePath()
        {
            return new NodePath(data.String ?? string.Empty);
        }

        public RID AsRID()
        {
            return new RID(data.Rid);
        }

        public T AsObject<T>() where T : GodotObject, new()
        {
            return GodotObject.CreateFromNative<T>(data.NativePtr);
        }

        public Array AsArray()
        {
            return Array.CreateFromNative(data.NativePtr, false);
        }

        public Dictionary AsDictionary()
        {
            return Dictionary.CreateFromNative(data.NativePtr, false);
        }

        public PackedByteArray AsPackedByteArray()
        {
            return PackedByteArray.CreateFromNative(data.NativePtr, false);
        }

        public PackedInt32Array AsPackedInt32Array()
        {
            return PackedInt32Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedInt64Array AsPackedInt64Array()
        {
            return PackedInt64Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedFloat32Array AsPackedFloat32Array()
        {
            return PackedFloat32Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedFloat64Array AsPackedFloat64Array()
        {
            return PackedFloat64Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedStringArray AsPackedStringArray()
        {
            return PackedStringArray.CreateFromNative(data.NativePtr, false);
        }

        public PackedVector2Array AsPackedVector2Array()
        {
            return PackedVector2Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedVector3Array AsPackedVector3Array()
        {
            return PackedVector3Array.CreateFromNative(data.NativePtr, false);
        }

        public PackedColorArray AsPackedColorArray()
        {
            return PackedColorArray.CreateFromNative(data.NativePtr, false);
        }

        public Callable AsCallable()
        {
            return Callable.CreateFromNative(data.NativePtr, false);
        }

        public Signal AsSignal()
        {
            return Signal.CreateFromNative(data.NativePtr, false);
        }

        public Vector2 AsVector2()
        {
            return data.Vector2;
        }

        public Vector2i AsVector2i()
        {
            return data.Vector2i;
        }

        public Vector3 AsVector3()
        {
            return data.Vector3;
        }

        public Vector3i AsVector3i()
        {
            return data.Vector3i;
        }

        public Vector4 AsVector4()
        {
            return data.Vector4;
        }

        public Vector4i AsVector4i()
        {
            return data.Vector4i;
        }

        public Projection AsProjection()
        {
            return data.Projection;
        }

        public Color AsColor()
        {
            return data.Color;
        }

        public Rect2 AsRect2()
        {
            return data.Rect2;
        }

        public Rect2i AsRect2i()
        {
            return data.Rect2i;
        }

        public Transform2D AsTransform2D()
        {
            return data.Transform2D;
        }

        public Aabb AsAabb()
        {
            return data.Aabb;
        }

        public Plane AsPlane()
        {
            return data.Plane;
        }

        public Quaternion AsQuaternion()
        {
            return data.Quaternion;
        }

        public Basis AsBasis()
        {
            return data.Basis;
        }

        public Transform3D AsTransform3D()
        {
            return data.Transform3D;
        }

        public bool Equals(Variant other)
        {
            if (variantType != other.variantType)
            {
                return false;
            }

            switch (variantType)
            {
                case Type.Nil:
                    return true;
                case Type.Bool_:
                    return data.Bool == other.data.Bool;
                case Type.Int_:
                    return data.Int == other.data.Int;
                case Type.Float_:
                    return data.Float == other.data.Float;
                case Type.String_:
                case Type.StringName:
                case Type.NodePath:
                    return data.String == other.data.String;
                case Type.Rid:
                    return data.Rid == other.data.Rid;
                case Type.Object_:
                case Type.Array:
                case Type.Dictionary:
                case Type.Callable:
                case Type.Signal:
                case Type.PackedStringArray:
                case Type.PackedByteArray:
                case Type.PackedInt32Array:
                case Type.PackedInt64Array:
                case Type.PackedFloat32Array:
                case Type.PackedFloat64Array:
                case Type.PackedVector2Array:
                case Type.PackedVector3Array:
                case Type.PackedColorArray:
                    return data.NativePtr == other.data.NativePtr;
                case Type.Vector2:
                    return data.Vector2.Equals(other.data.Vector2);
                case Type.Vector2i:
                    return data.Vector2i.Equals(other.data.Vector2i);
                case Type.Vector3:
                    return data.Vector3.Equals(other.data.Vector3);
                case Type.Vector3i:
                    return data.Vector3i.Equals(other.data.Vector3i);
                case Type.Vector4:
                    return data.Vector4.Equals(other.data.Vector4);
                case Type.Vector4i:
                    return data.Vector4i.Equals(other.data.Vector4i);
                case Type.Projection:
                    return data.Projection.Equals(other.data.Projection);
                case Type.Color:
                    return data.Color.Equals(other.data.Color);
                case Type.Rect2:
                    return data.Rect2.Equals(other.data.Rect2);
                case Type.Rect2i:
                    return data.Rect2i.Equals(other.data.Rect2i);
                case Type.Transform2d:
                    return data.Transform2D.Equals(other.data.Transform2D);
                case Type.Aabb:
                    return data.Aabb.Equals(other.data.Aabb);
                case Type.Plane:
                    return data.Plane.Equals(other.data.Plane);
                case Type.Quaternion:
                    return data.Quaternion.Equals(other.data.Quaternion);
                case Type.Basis:
                    return data.Basis.Equals(other.data.Basis);
                case Type.Transform3d:
                    return data.Transform3D.Equals(other.data.Transform3D);
                default:
                    return false;
            }
        }

        public override bool Equals(object obj)
        {
            return obj is Variant && Equals((Variant)obj);
        }

        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }

        public override string ToString()
        {
            return NativeCalls.GodotVariantStringify(this);
        }
    }
}
""",
    )

    write(
        generated / "PackedStringArray.generated.cs",
        """// <auto-generated />
using System;

namespace Godot
{
    public partial class PackedStringArray : IDisposable
    {
        internal IntPtr NativePtr;
        private bool ownsNativePtr;

        public PackedStringArray()
            : this(NativeCalls.GodotPackedStringArrayCreate(), true)
        {
        }

        public PackedStringArray(string[] values)
            : this()
        {
            if (values == null)
            {
                return;
            }

            for (int i = 0; i < values.Length; ++i)
            {
                Add(values[i]);
            }
        }

        private PackedStringArray(IntPtr nativePtr, bool ownsNativePtr)
        {
            NativePtr = nativePtr;
            this.ownsNativePtr = ownsNativePtr;
        }

        internal static PackedStringArray CreateFromNative(IntPtr nativePtr)
        {
            return CreateFromNative(nativePtr, true);
        }

        internal static PackedStringArray CreateFromNative(IntPtr nativePtr, bool ownsNativePtr)
        {
            return nativePtr != IntPtr.Zero ? new PackedStringArray(nativePtr, ownsNativePtr) : null;
        }

        ~PackedStringArray()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (ownsNativePtr && NativePtr != IntPtr.Zero)
            {
                NativeCalls.GodotPackedStringArrayDestroy(NativePtr);
                NativePtr = IntPtr.Zero;
                ownsNativePtr = false;
            }
        }

        public int Count
        {
            get { return NativePtr != IntPtr.Zero ? NativeCalls.GodotPackedStringArraySize(NativePtr) : 0; }
        }

        public string this[int index]
        {
            get { return NativeCalls.GodotPackedStringArrayGet(NativePtr, index); }
        }

        public void Add(string value)
        {
            NativeCalls.GodotPackedStringArrayAppend(NativePtr, value);
        }

        public string[] ToArray()
        {
            string[] values = new string[Count];
            for (int i = 0; i < values.Length; ++i)
            {
                values[i] = this[i];
            }
            return values;
        }
    }
}
""",
    )

    opaque_wrappers = sorted(PACKED_ARRAY_TYPES | OPAQUE_VARIANT_TYPES | OPAQUE_VALUE_TYPES | {"GodotArray"})
    for wrapper_name in opaque_wrappers:
        destroy_call = "NativeCalls.GodotOpaqueValueDestroy"
        create_call = {"Array": "GodotArrayCreate", "Dictionary": "GodotDictionaryCreate"}.get(wrapper_name)
        public_constructor = (
            f"""\n        public {wrapper_name}()\n            : this(NativeCalls.{create_call}(), true)\n        {{\n        }}\n"""
            if create_call is not None
            else ""
        )
        collection_methods = ""
        extra_constructor = ""
        if wrapper_name == "Callable":
            extra_constructor = """

        public Callable(GodotObject target, StringName method)
            : this(NativeCalls.GodotCallableCreate(target != null ? target.NativePtr : IntPtr.Zero, method.ToString()), true)
        {
        }

        public static Callable From(Action action)
        {
            long delegateId = CallableDelegateRegistry.Register(args => { action(); return new Variant(); });
            return new Callable(NativeCalls.GodotCallableCreateDelegate(delegateId), true, delegateId);
        }

        public static Callable From(Func<Variant> function)
        {
            long delegateId = CallableDelegateRegistry.Register(args => function());
            return new Callable(NativeCalls.GodotCallableCreateDelegate(delegateId), true, delegateId);
        }

        public static Callable From<T>(Action<T> action)
        {
            long delegateId = CallableDelegateRegistry.Register(args => { action(CallableDelegateRegistry.ConvertArgument<T>(args, 0)); return new Variant(); });
            return new Callable(NativeCalls.GodotCallableCreateDelegate(delegateId), true, delegateId);
        }

        public static Callable From<T>(Func<T, Variant> function)
        {
            long delegateId = CallableDelegateRegistry.Register(args => function(CallableDelegateRegistry.ConvertArgument<T>(args, 0)));
            return new Callable(NativeCalls.GodotCallableCreateDelegate(delegateId), true, delegateId);
        }
"""
            collection_methods = """
        public bool IsValid()
        {
            return NativeCalls.GodotCallableIsValid(NativePtr);
        }

        public StringName GetMethod()
        {
            return new StringName(NativeCalls.GodotCallableGetMethod(NativePtr));
        }

        public Variant Call(params Variant[] varargs)
        {
            return NativeCalls.GodotCallableCall(NativePtr, varargs);
        }

        public Callable Bind(params Variant[] varargs)
        {
            return CreateFromNative(NativeCalls.GodotCallableBind(NativePtr, varargs));
        }
"""
        elif wrapper_name == "Signal":
            extra_constructor = """

        public Signal(GodotObject target, StringName signal)
            : this(NativeCalls.GodotSignalCreate(target != null ? target.NativePtr : IntPtr.Zero, signal.ToString()), true)
        {
        }
"""
            collection_methods = """
        public bool IsNull()
        {
            return NativeCalls.GodotSignalIsNull(NativePtr);
        }

        public StringName GetName()
        {
            return new StringName(NativeCalls.GodotSignalGetName(NativePtr));
        }

        public Error Connect(Callable callable, int flags)
        {
            return (Error)NativeCalls.GodotSignalConnect(NativePtr, callable != null ? callable.NativePtr : IntPtr.Zero, flags);
        }

        public void Emit(params Variant[] varargs)
        {
            NativeCalls.GodotSignalEmit(NativePtr, varargs);
        }
"""

        elif wrapper_name in PACKED_ARRAY_INFOS:
            element_type = PACKED_ARRAY_INFOS[wrapper_name]["cs"]
            public_constructor = f"""
        public {wrapper_name}()
            : this(NativeCalls.Godot{wrapper_name}Create(), true)
        {{
        }}
"""
            collection_methods = f"""
        public int Count
        {{
            get {{ return NativePtr != IntPtr.Zero ? NativeCalls.Godot{wrapper_name}Size(NativePtr) : 0; }}
        }}

        public {element_type} this[int index]
        {{
            get {{ return NativeCalls.Godot{wrapper_name}Get(NativePtr, index); }}
            set {{ NativeCalls.Godot{wrapper_name}Set(NativePtr, index, value); }}
        }}

        public void Add({element_type} value)
        {{
            NativeCalls.Godot{wrapper_name}Add(NativePtr, value);
        }}

        public void Clear()
        {{
            NativeCalls.Godot{wrapper_name}Clear(NativePtr);
        }}

        public {element_type}[] ToArray()
        {{
            {element_type}[] values = new {element_type}[Count];
            for (int i = 0; i < values.Length; ++i)
            {{
                values[i] = this[i];
            }}
            return values;
        }}
"""
        if wrapper_name == "Array" or wrapper_name == "GodotArray":
            collection_methods = """
        public int Count
        {
            get { return NativePtr != IntPtr.Zero ? NativeCalls.GodotArraySize(NativePtr) : 0; }
        }

        public Variant this[int index]
        {
            get { return NativeCalls.GodotArrayGet(NativePtr, index); }
            set { NativeCalls.GodotArraySet(NativePtr, index, value); }
        }

        public void Add(Variant value)
        {
            NativeCalls.GodotArrayAdd(NativePtr, value);
        }

        public void Insert(int index, Variant value)
        {
            NativeCalls.GodotArrayInsert(NativePtr, index, value);
        }

        public void RemoveAt(int index)
        {
            NativeCalls.GodotArrayRemoveAt(NativePtr, index);
        }

        public void Clear()
        {
            NativeCalls.GodotArrayClear(NativePtr);
        }

        public bool Contains(Variant value)
        {
            return NativeCalls.GodotArrayContains(NativePtr, value);
        }

        public int IndexOf(Variant value)
        {
            return NativeCalls.GodotArrayIndexOf(NativePtr, value);
        }

        public Variant[] ToArray()
        {
            Variant[] values = new Variant[Count];
            for (int i = 0; i < values.Length; ++i)
            {
                values[i] = this[i];
            }
            return values;
        }

        public IEnumerator<Variant> GetEnumerator()
        {
            for (int i = 0; i < Count; ++i)
            {
                yield return this[i];
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
"""
        elif wrapper_name == "Dictionary":
            collection_methods = """
        public int Count
        {
            get { return NativePtr != IntPtr.Zero ? NativeCalls.GodotDictionarySize(NativePtr) : 0; }
        }

        public Variant this[Variant key]
        {
            get { return NativeCalls.GodotDictionaryGet(NativePtr, key); }
            set { NativeCalls.GodotDictionarySet(NativePtr, key, value); }
        }

        public bool ContainsKey(Variant key)
        {
            return NativeCalls.GodotDictionaryContainsKey(NativePtr, key);
        }

        public bool Remove(Variant key)
        {
            return NativeCalls.GodotDictionaryRemove(NativePtr, key);
        }

        public void Clear()
        {
            NativeCalls.GodotDictionaryClear(NativePtr);
        }

        public Array Keys
        {
            get { return Array.CreateFromNative(NativeCalls.GodotDictionaryKeys(NativePtr)); }
        }

        public Array Values
        {
            get { return Array.CreateFromNative(NativeCalls.GodotDictionaryValues(NativePtr)); }
        }

        public IEnumerator<KeyValuePair<Variant, Variant>> GetEnumerator()
        {
            Array keys = Keys;
            for (int i = 0; i < keys.Count; ++i)
            {
                Variant key = keys[i];
                yield return new KeyValuePair<Variant, Variant>(key, this[key]);
            }
            keys.Dispose();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
"""
        write(
            generated / f"{wrapper_name}.generated.cs",
            f"""// <auto-generated />
using System;
using System.Collections;
using System.Collections.Generic;

namespace Godot
{{
    public partial class {wrapper_name} : IDisposable{', IEnumerable<Variant>' if wrapper_name == 'Array' or wrapper_name == 'GodotArray' else ', IEnumerable<KeyValuePair<Variant, Variant>>' if wrapper_name == 'Dictionary' else ''}
    {{
        internal IntPtr NativePtr;
        private bool ownsNativePtr;
        private long delegateId;

        internal static {wrapper_name} CreateFromNative(IntPtr nativePtr)
        {{
            return nativePtr != IntPtr.Zero ? new {wrapper_name}(nativePtr, true) : null;
        }}

        internal static {wrapper_name} CreateFromNative(IntPtr nativePtr, bool ownsNativePtr)
        {{
            return nativePtr != IntPtr.Zero ? new {wrapper_name}(nativePtr, ownsNativePtr) : null;
        }}
{public_constructor}{extra_constructor}

        private {wrapper_name}(IntPtr nativePtr, bool ownsNativePtr)
            : this(nativePtr, ownsNativePtr, 0)
        {{
        }}

        private {wrapper_name}(IntPtr nativePtr, bool ownsNativePtr, long delegateId)
        {{
            NativePtr = nativePtr;
            this.ownsNativePtr = ownsNativePtr;
            this.delegateId = delegateId;
        }}

        ~{wrapper_name}()
        {{
            Dispose(false);
        }}

        public void Dispose()
        {{
            Dispose(true);
            GC.SuppressFinalize(this);
        }}

        private void Dispose(bool disposing)
        {{
            if (ownsNativePtr && NativePtr != IntPtr.Zero)
            {{
                {destroy_call}(NativePtr);
                if (delegateId != 0)
                {{
                    CallableDelegateRegistry.Unregister(delegateId);
                    delegateId = 0;
                }}
                NativePtr = IntPtr.Zero;
                ownsNativePtr = false;
            }}
        }}
{collection_methods}
    }}
}}
""",
        )

    write(
        generated / "StringName.generated.cs",
        """// <auto-generated />
using System;

namespace Godot
{
    public struct StringName : IEquatable<StringName>
    {
        private readonly string value;

        public StringName(string value)
        {
            this.value = value ?? string.Empty;
        }

        public bool Equals(StringName other)
        {
            return ToString() == other.ToString();
        }

        public override bool Equals(object obj)
        {
            return obj is StringName && Equals((StringName)obj);
        }

        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }

        public override string ToString()
        {
            return value ?? string.Empty;
        }

        public static implicit operator StringName(string value)
        {
            return new StringName(value);
        }

        public static implicit operator string(StringName value)
        {
            return value.ToString();
        }
    }
}
""",
    )

    write(
        generated / "Vector2.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector2 : IEquatable<Vector2>
    {
        public float X;
        public float Y;

        public Vector2(float x, float y)
        {
            X = x;
            Y = y;
        }

        public bool Equals(Vector2 other)
        {
            return X == other.X && Y == other.Y;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector2 && Equals((Vector2)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ")";
        }

        public static Vector2 One
        {
            get { return new Vector2(1.0f, 1.0f); }
        }

        public static Vector2 Zero
        {
            get { return new Vector2(0.0f, 0.0f); }
        }
    }
}
""",
    )

    write(
        generated / "Vector2i.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector2i : IEquatable<Vector2i>
    {
        public int X;
        public int Y;

        public Vector2i(int x, int y)
        {
            X = x;
            Y = y;
        }

        public bool Equals(Vector2i other)
        {
            return X == other.X && Y == other.Y;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector2i && Equals((Vector2i)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ")";
        }

        public static Vector2i One
        {
            get { return new Vector2i(1, 1); }
        }

        public static Vector2i Zero
        {
            get { return new Vector2i(0, 0); }
        }
    }
}
""",
    )

    write(
        generated / "Vector3.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector3 : IEquatable<Vector3>
    {
        public float X;
        public float Y;
        public float Z;

        public Vector3(float x, float y, float z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        public bool Equals(Vector3 other)
        {
            return X == other.X && Y == other.Y && Z == other.Z;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector3 && Equals((Vector3)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ")";
        }

        public static Vector3 One
        {
            get { return new Vector3(1.0f, 1.0f, 1.0f); }
        }

        public static Vector3 Zero
        {
            get { return new Vector3(0.0f, 0.0f, 0.0f); }
        }
    }
}
""",
    )

    write(
        generated / "Vector3i.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector3i : IEquatable<Vector3i>
    {
        public int X;
        public int Y;
        public int Z;

        public Vector3i(int x, int y, int z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        public bool Equals(Vector3i other)
        {
            return X == other.X && Y == other.Y && Z == other.Z;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector3i && Equals((Vector3i)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Rect2.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Rect2 : IEquatable<Rect2>
    {
        public Vector2 Position;
        public Vector2 Size;

        public Rect2(Vector2 position, Vector2 size)
        {
            Position = position;
            Size = size;
        }

        public Rect2(float x, float y, float width, float height)
        {
            Position = new Vector2(x, y);
            Size = new Vector2(width, height);
        }

        public bool Equals(Rect2 other)
        {
            return Position.Equals(other.Position) && Size.Equals(other.Size);
        }

        public override bool Equals(object obj)
        {
            return obj is Rect2 && Equals((Rect2)obj);
        }

        public override int GetHashCode()
        {
            return Position.GetHashCode() ^ Size.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + Position.ToString() + ", " + Size.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Rect2i.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Rect2i : IEquatable<Rect2i>
    {
        public Vector2i Position;
        public Vector2i Size;

        public Rect2i(Vector2i position, Vector2i size)
        {
            Position = position;
            Size = size;
        }

        public Rect2i(int x, int y, int width, int height)
        {
            Position = new Vector2i(x, y);
            Size = new Vector2i(width, height);
        }

        public bool Equals(Rect2i other)
        {
            return Position.Equals(other.Position) && Size.Equals(other.Size);
        }

        public override bool Equals(object obj)
        {
            return obj is Rect2i && Equals((Rect2i)obj);
        }

        public override int GetHashCode()
        {
            return Position.GetHashCode() ^ Size.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + Position.ToString() + ", " + Size.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Transform2D.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Transform2D : IEquatable<Transform2D>
    {
        public Vector2 X;
        public Vector2 Y;
        public Vector2 Origin;

        public Transform2D(Vector2 x, Vector2 y, Vector2 origin)
        {
            X = x;
            Y = y;
            Origin = origin;
        }

        public bool Equals(Transform2D other)
        {
            return X.Equals(other.X) && Y.Equals(other.Y) && Origin.Equals(other.Origin);
        }

        public override bool Equals(object obj)
        {
            return obj is Transform2D && Equals((Transform2D)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Origin.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Origin.ToString() + ")";
        }

        public static Transform2D Identity
        {
            get { return new Transform2D(new Vector2(1.0f, 0.0f), new Vector2(0.0f, 1.0f), Vector2.Zero); }
        }
    }
}
""",
    )

    write(
        generated / "Aabb.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Aabb : IEquatable<Aabb>
    {
        public Vector3 Position;
        public Vector3 Size;

        public Aabb(Vector3 position, Vector3 size)
        {
            Position = position;
            Size = size;
        }

        public bool Equals(Aabb other)
        {
            return Position.Equals(other.Position) && Size.Equals(other.Size);
        }

        public override bool Equals(object obj)
        {
            return obj is Aabb && Equals((Aabb)obj);
        }

        public override int GetHashCode()
        {
            return Position.GetHashCode() ^ Size.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + Position.ToString() + ", " + Size.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Quaternion.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Quaternion : IEquatable<Quaternion>
    {
        public float X;
        public float Y;
        public float Z;
        public float W;

        public Quaternion(float x, float y, float z, float w)
        {
            X = x;
            Y = y;
            Z = z;
            W = w;
        }

        public bool Equals(Quaternion other)
        {
            return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
        }

        public override bool Equals(object obj)
        {
            return obj is Quaternion && Equals((Quaternion)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ", " + W.ToString() + ")";
        }

        public static Quaternion Identity
        {
            get { return new Quaternion(0.0f, 0.0f, 0.0f, 1.0f); }
        }
    }
}
""",
    )

    write(
        generated / "Basis.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Basis : IEquatable<Basis>
    {
        public Vector3 X;
        public Vector3 Y;
        public Vector3 Z;

        public Basis(Vector3 x, Vector3 y, Vector3 z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        public bool Equals(Basis other)
        {
            return X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z);
        }

        public override bool Equals(object obj)
        {
            return obj is Basis && Equals((Basis)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ")";
        }

        public static Basis Identity
        {
            get { return new Basis(new Vector3(1.0f, 0.0f, 0.0f), new Vector3(0.0f, 1.0f, 0.0f), new Vector3(0.0f, 0.0f, 1.0f)); }
        }
    }
}
""",
    )

    write(
        generated / "Transform3D.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Transform3D : IEquatable<Transform3D>
    {
        public Basis Basis;
        public Vector3 Origin;

        public Transform3D(Basis basis, Vector3 origin)
        {
            Basis = basis;
            Origin = origin;
        }

        public bool Equals(Transform3D other)
        {
            return Basis.Equals(other.Basis) && Origin.Equals(other.Origin);
        }

        public override bool Equals(object obj)
        {
            return obj is Transform3D && Equals((Transform3D)obj);
        }

        public override int GetHashCode()
        {
            return Basis.GetHashCode() ^ Origin.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + Basis.ToString() + ", " + Origin.ToString() + ")";
        }

        public static Transform3D Identity
        {
            get { return new Transform3D(Basis.Identity, Vector3.Zero); }
        }
    }
}
""",
    )

    write(
        generated / "Vector4.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector4 : IEquatable<Vector4>
    {
        public float X;
        public float Y;
        public float Z;
        public float W;

        public Vector4(float x, float y, float z, float w)
        {
            X = x;
            Y = y;
            Z = z;
            W = w;
        }

        public bool Equals(Vector4 other)
        {
            return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector4 && Equals((Vector4)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ", " + W.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Vector4i.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Vector4i : IEquatable<Vector4i>
    {
        public int X;
        public int Y;
        public int Z;
        public int W;

        public Vector4i(int x, int y, int z, int w)
        {
            X = x;
            Y = y;
            Z = z;
            W = w;
        }

        public bool Equals(Vector4i other)
        {
            return X == other.X && Y == other.Y && Z == other.Z && W == other.W;
        }

        public override bool Equals(object obj)
        {
            return obj is Vector4i && Equals((Vector4i)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ", " + W.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Plane.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Plane : IEquatable<Plane>
    {
        public Vector3 Normal;
        public float D;

        public Plane(Vector3 normal, float d)
        {
            Normal = normal;
            D = d;
        }

        public bool Equals(Plane other)
        {
            return Normal.Equals(other.Normal) && D == other.D;
        }

        public override bool Equals(object obj)
        {
            return obj is Plane && Equals((Plane)obj);
        }

        public override int GetHashCode()
        {
            return Normal.GetHashCode() ^ D.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + Normal.ToString() + ", " + D.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Projection.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Projection : IEquatable<Projection>
    {
        public Vector4 X;
        public Vector4 Y;
        public Vector4 Z;
        public Vector4 W;

        public Projection(Vector4 x, Vector4 y, Vector4 z, Vector4 w)
        {
            X = x;
            Y = y;
            Z = z;
            W = w;
        }

        public bool Equals(Projection other)
        {
            return X.Equals(other.X) && Y.Equals(other.Y) && Z.Equals(other.Z) && W.Equals(other.W);
        }

        public override bool Equals(object obj)
        {
            return obj is Projection && Equals((Projection)obj);
        }

        public override int GetHashCode()
        {
            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + X.ToString() + ", " + Y.ToString() + ", " + Z.ToString() + ", " + W.ToString() + ")";
        }
    }
}
""",
    )

    write(
        generated / "Color.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public partial struct Color : IEquatable<Color>
    {
        public float R;
        public float G;
        public float B;
        public float A;

        public Color(float r, float g, float b, float a)
        {
            R = r;
            G = g;
            B = b;
            A = a;
        }

        public bool Equals(Color other)
        {
            return R == other.R && G == other.G && B == other.B && A == other.A;
        }

        public override bool Equals(object obj)
        {
            return obj is Color && Equals((Color)obj);
        }

        public override int GetHashCode()
        {
            return R.GetHashCode() ^ G.GetHashCode() ^ B.GetHashCode() ^ A.GetHashCode();
        }

        public override string ToString()
        {
            return "(" + R.ToString() + ", " + G.ToString() + ", " + B.ToString() + ", " + A.ToString() + ")";
        }

        public static Color White
        {
            get { return new Color(1.0f, 1.0f, 1.0f, 1.0f); }
        }

        public static Color Transparent
        {
            get { return new Color(0.0f, 0.0f, 0.0f, 0.0f); }
        }
    }
}
""",
    )

    write(
        generated / "RID.generated.cs",
        """// <auto-generated />
using System;
using System.Runtime.InteropServices;

namespace Godot
{
    [StructLayout(LayoutKind.Sequential)]
    public struct RID : IEquatable<RID>
    {
        private readonly long id;

        public RID(long id)
        {
            this.id = id;
        }

        public bool IsValid()
        {
            return id != 0;
        }

        public long GetId()
        {
            return id;
        }

        public bool Equals(RID other)
        {
            return id == other.id;
        }

        public override bool Equals(object obj)
        {
            return obj is RID && Equals((RID)obj);
        }

        public override int GetHashCode()
        {
            return id.GetHashCode();
        }

        public override string ToString()
        {
            return id.ToString();
        }
    }
}
""",
    )

    write(
        generated / "NodePath.generated.cs",
        """// <auto-generated />
using System;

namespace Godot
{
    public struct NodePath : IEquatable<NodePath>
    {
        private readonly string value;

        public NodePath(string value)
        {
            this.value = value ?? string.Empty;
        }

        public bool Equals(NodePath other)
        {
            return ToString() == other.ToString();
        }

        public override bool Equals(object obj)
        {
            return obj is NodePath && Equals((NodePath)obj);
        }

        public override int GetHashCode()
        {
            return ToString().GetHashCode();
        }

        public override string ToString()
        {
            return value ?? string.Empty;
        }

        public static implicit operator NodePath(string value)
        {
            return new NodePath(value);
        }

        public static implicit operator string(NodePath value)
        {
            return value.ToString();
        }
    }
}
""",
    )


def screaming_enum_prefix(enum_name):
    result = []
    for char in enum_name:
        if char.isupper() and result:
            result.append("_")
        result.append(char.upper())
    return "".join(result)


def enum_member_name(enum_name, value_name):
    prefix = screaming_enum_prefix(enum_name)
    short_name = value_name
    if short_name.startswith(prefix + "_"):
        short_name = short_name[len(prefix) + 1 :]
    if short_name.startswith("FLAG_"):
        short_name = short_name[5:]
    return pascal_name(short_name.lower())


def generate_enum_declarations(class_entry):
    declarations = []
    seen_enum_names = set()
    for enum_entry in class_entry.get("enums", []):
        enum_name = cs_identifier(enum_entry["name"], "GodotEnum")
        if enum_name in seen_enum_names:
            continue
        seen_enum_names.add(enum_name)
        if enum_entry.get("is_bitfield"):
            declarations.append("        [Flags]")
            declarations.append(f"        public enum {enum_name} : long")
        else:
            declarations.append(f"        public enum {enum_name}")
        declarations.append("        {")
        seen_value_names = set()
        for value in enum_entry.get("values", []):
            member_name = enum_member_name(enum_entry["name"], value["name"])
            if member_name in seen_value_names:
                member_name = f"{member_name}_{value['value']}"
            seen_value_names.add(member_name)
            declarations.append(f"            {member_name} = {value['value']},")
        declarations.append("        }")
    return "\n".join(declarations)


def generate_standalone_nested_enum_declarations(type_name, enums):
    lines = [f"    public partial struct {cs_identifier(type_name, 'GodotBuiltin')}", "    {"]
    seen_enum_names = set()
    for enum_entry in enums:
        enum_name = cs_identifier(enum_entry["name"], "GodotEnum")
        if enum_name in seen_enum_names:
            continue
        seen_enum_names.add(enum_name)
        if enum_entry.get("is_bitfield"):
            lines.append("        [Flags]")
            lines.append(f"        public enum {enum_name} : long")
        else:
            lines.append(f"        public enum {enum_name}")
        lines.append("        {")
        seen_value_names = set()
        for value in enum_entry.get("values", []):
            member_name = enum_member_name(enum_entry["name"], value["name"])
            if member_name in seen_value_names:
                member_name = f"{member_name}_{value['value']}"
            seen_value_names.add(member_name)
            lines.append(f"            {member_name} = {value['value']},")
        lines.append("        }")
    lines.append("    }")
    return lines


def generate_builtin_enums(builtin_classes, generated):
    lines = ["// <auto-generated />", "using System;", "", "namespace Godot", "{"]
    for builtin_class in builtin_classes:
        enums = builtin_class.get("enums", [])
        if not enums:
            continue
        lines.extend(generate_standalone_nested_enum_declarations(builtin_class["name"], enums))
    lines.extend(["}", ""])
    write(generated / "BuiltinEnums.generated.cs", "\n".join(lines))


def generate_global_enums(global_enums, generated):
    lines = ["// <auto-generated />", "using System;", "", "namespace Godot", "{"]
    nested_enums = {}
    for enum_entry in global_enums:
        enum_name = cs_identifier(enum_entry["name"], "GodotEnum")
        if "." in enum_entry["name"]:
            container_name, nested_name = enum_entry["name"].split(".", 1)
            nested_entry = dict(enum_entry)
            nested_entry["name"] = nested_name
            nested_enums.setdefault(container_name, []).append(nested_entry)
            continue
        if enum_entry.get("is_bitfield"):
            lines.append("    [Flags]")
            lines.append(f"    public enum {enum_name} : long")
        else:
            lines.append(f"    public enum {enum_name}")
        lines.append("    {")
        seen_value_names = set()
        for value in enum_entry.get("values", []):
            member_name = enum_member_name(enum_entry["name"], value["name"])
            if member_name in seen_value_names:
                member_name = f"{member_name}_{value['value']}"
            seen_value_names.add(member_name)
            lines.append(f"        {member_name} = {value['value']},")
        lines.append("    }")
    for container_name, enums in nested_enums.items():
        lines.extend(generate_standalone_nested_enum_declarations(container_name, enums))
    lines.extend(["}", ""])
    write(generated / "GlobalEnums.generated.cs", "\n".join(lines))


def generate_managed(classes, class_order, global_enums, builtin_classes, methods, managed_dir):
    generated = managed_dir / "Generated"
    generated.mkdir(parents=True, exist_ok=True)
    for stale_file in generated.glob("*.generated.cs"):
        stale_file.unlink()
    generate_builtin_wrappers(generated)
    generate_builtin_enums(builtin_classes, generated)
    generate_global_enums(global_enums, generated)
    by_class = {name: [] for name in class_order}
    for method in methods:
        by_class[method.class_name].append(method)

    for class_name in class_order:
        cs_name = cs_class_name(class_name)
        lines = ["// <auto-generated />", "using System;", "", "namespace Godot", "{", f"    public partial class {cs_name}{managed_base_clause(class_name, classes)}", "    {"]
        enum_declarations = generate_enum_declarations(classes[class_name])
        if enum_declarations:
            lines.append(enum_declarations)
        if class_name == "Node":
            lines.append(generate_node_name_property().rstrip())
        if class_name == "Node2D":
            lines.append(generate_node2d_vector2_property("Position", "GetPosition", "SetPosition").rstrip())
            lines.append(generate_node2d_vector2_property("GlobalPosition", "GetGlobalPosition", "SetGlobalPosition").rstrip())
            lines.append(generate_node2d_vector2_property("Scale", "GetScale", "SetScale").rstrip())
        if class_name == "Control":
            lines.append(generate_vector2_property("Control", "Position", "GetPosition", "SetPosition").rstrip())
            lines.append(generate_vector2_property("Control", "Size", "GetSize", "SetSize").rstrip())
        if class_name == "Label":
            lines.append(generate_string_property("Label", "Text", "GetText", "SetText").rstrip())
        if class_name == "Sprite2D":
            lines.append(generate_bool_property("Sprite2D", "Centered", "IsCentered", "SetCentered").rstrip())
            lines.append(generate_vector2_property("Sprite2D", "Offset", "GetOffset", "SetOffset").rstrip())
            lines.append(generate_bool_property("Sprite2D", "FlipH", "IsFlippedH", "SetFlipH").rstrip())
            lines.append(generate_bool_property("Sprite2D", "FlipV", "IsFlippedV", "SetFlipV").rstrip())
        for method in by_class[class_name]:
            generated_method = generate_managed_method(method)
            if generated_method:
                lines.append(generated_method.rstrip())
        lines.extend(["    }", "}", ""])
        write(generated / f"{cs_name}.generated.cs", "\n".join(lines))

    native_call_lines = [
        "// <auto-generated />",
        "using System;",
        "using System.Runtime.CompilerServices;",
        "",
        "namespace Godot",
        "{",
        "    internal static partial class NativeCalls",
        "    {",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotObjectReleaseRefCounted(IntPtr nativePtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern string GodotVariantStringify(Variant variant);",
        "",        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotCallableCreate(IntPtr targetPtr, string method);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotCallableCreateDelegate(long delegateId);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern bool GodotCallableIsValid(IntPtr callablePtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern string GodotCallableGetMethod(IntPtr callablePtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Variant GodotCallableCall(IntPtr callablePtr, Variant[] varargs);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotCallableBind(IntPtr callablePtr, Variant[] varargs);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotSignalCreate(IntPtr targetPtr, string signal);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern bool GodotSignalIsNull(IntPtr signalPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern string GodotSignalGetName(IntPtr signalPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotSignalConnect(IntPtr signalPtr, IntPtr callablePtr, int flags);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotSignalEmit(IntPtr signalPtr, Variant[] varargs);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedStringArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedStringArrayDestroy(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedStringArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern string GodotPackedStringArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedStringArrayAppend(IntPtr arrayPtr, string value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedByteArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedByteArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern byte GodotPackedByteArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedByteArraySet(IntPtr arrayPtr, int index, byte value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedByteArrayAdd(IntPtr arrayPtr, byte value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedByteArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedInt32ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedInt32ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedInt32ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt32ArraySet(IntPtr arrayPtr, int index, int value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt32ArrayAdd(IntPtr arrayPtr, int value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt32ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedInt64ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedInt64ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern long GodotPackedInt64ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt64ArraySet(IntPtr arrayPtr, int index, long value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt64ArrayAdd(IntPtr arrayPtr, long value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedInt64ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedFloat32ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedFloat32ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern float GodotPackedFloat32ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat32ArraySet(IntPtr arrayPtr, int index, float value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat32ArrayAdd(IntPtr arrayPtr, float value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat32ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedFloat64ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedFloat64ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern double GodotPackedFloat64ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat64ArraySet(IntPtr arrayPtr, int index, double value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat64ArrayAdd(IntPtr arrayPtr, double value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedFloat64ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedVector2ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedVector2ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Vector2 GodotPackedVector2ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector2ArraySet(IntPtr arrayPtr, int index, Vector2 value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector2ArrayAdd(IntPtr arrayPtr, Vector2 value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector2ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedVector3ArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedVector3ArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Vector3 GodotPackedVector3ArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector3ArraySet(IntPtr arrayPtr, int index, Vector3 value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector3ArrayAdd(IntPtr arrayPtr, Vector3 value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedVector3ArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotPackedColorArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotPackedColorArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Color GodotPackedColorArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedColorArraySet(IntPtr arrayPtr, int index, Color value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedColorArrayAdd(IntPtr arrayPtr, Color value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotPackedColorArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotOpaqueValueDestroy(IntPtr valuePtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotArrayCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotArraySize(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Variant GodotArrayGet(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotArraySet(IntPtr arrayPtr, int index, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotArrayAdd(IntPtr arrayPtr, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotArrayInsert(IntPtr arrayPtr, int index, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotArrayRemoveAt(IntPtr arrayPtr, int index);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotArrayClear(IntPtr arrayPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern bool GodotArrayContains(IntPtr arrayPtr, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotArrayIndexOf(IntPtr arrayPtr, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotDictionaryCreate();",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern int GodotDictionarySize(IntPtr dictionaryPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern bool GodotDictionaryContainsKey(IntPtr dictionaryPtr, Variant key);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern Variant GodotDictionaryGet(IntPtr dictionaryPtr, Variant key);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotDictionarySet(IntPtr dictionaryPtr, Variant key, Variant value);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern bool GodotDictionaryRemove(IntPtr dictionaryPtr, Variant key);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern void GodotDictionaryClear(IntPtr dictionaryPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotDictionaryKeys(IntPtr dictionaryPtr);",
        "",
        "        [MethodImpl(MethodImplOptions.InternalCall)]",
        "        internal static extern IntPtr GodotDictionaryValues(IntPtr dictionaryPtr);",
        "",
    ]
    for method in methods:
        if method.return_type.category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value", "object", "refcounted"}:
            return_type = "IntPtr"
        elif method.return_type.category == "variant":
            return_type = "Variant"
        elif method.return_type.category == "string":
            return_type = "string"
        elif method.return_type.category == "enum":
            return_type = "int"
        elif method.return_type.category == "bitfield":
            return_type = "long"
        elif method.return_type.category in {"vector2", "vector2i", "vector3", "vector3i", "color", "rect2", "rect2i", "transform2d", "aabb", "quaternion", "basis", "transform3d", "vector4", "vector4i", "plane", "projection", "rid"}:
            return_type = method.return_type.managed_type
        else:
            return_type = method.return_type.managed_type if method.return_type.category != "void" else "void"
        args = [] if method.is_static else ["IntPtr nativePtr"]
        for arg in method.args:
            if arg["type"].category == "variant":
                args.append(f"Variant {camel_name(arg['name'])}")
            elif arg["type"].category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value"}:
                args.append(f"IntPtr {camel_name(arg['name'])}Ptr")
            elif arg["type"].category == "native_pointer":
                args.append(f"IntPtr {camel_name(arg['name'])}")
            elif arg["type"].category in {"object", "refcounted"}:
                args.append(f"IntPtr {camel_name(arg['name'])}Ptr")
            elif arg["type"].category == "string":
                args.append(f"string {camel_name(arg['name'])}")
            elif arg["type"].category == "enum":
                args.append(f"int {camel_name(arg['name'])}")
            elif arg["type"].category == "bitfield":
                args.append(f"long {camel_name(arg['name'])}")
            elif arg["type"].category in {"vector2", "vector2i", "vector3", "vector3i", "color", "rect2", "rect2i", "transform2d", "aabb", "quaternion", "basis", "transform3d", "vector4", "vector4i", "plane", "projection", "rid"}:
                args.append(f"{arg['type'].managed_type} {camel_name(arg['name'])}")
            else:
                args.append(managed_arg_declaration(arg))
        if method.is_vararg:
            args.append("Variant[] varargs")
        native_call_lines.extend(
            [
                "        [MethodImpl(MethodImplOptions.InternalCall)]",
                f"        internal static extern {return_type} Godot{method.cs_class_name}{method.icall_suffix}({', '.join(args)});",
                "",
            ]
        )
    native_call_lines.extend(["    }", "}", ""])
    write(generated / "NativeCalls.generated.cs", "\n".join(native_call_lines))


def cpp_cast_type(type_info):
    return type_info.cpp_type


def cpp_return_statement(method, call):
    category = method.return_type.category
    if category == "void":
        return f"    {call};\n    return leanclr::core::Unit{{}};"
    if category == "string":
        return f"    return to_rt_string({call});"
    if category == "variant":
        return f"    return to_managed_variant({call});"
    if category == "packed_string_array":
        return f"    return new_packed_string_array({call});"
    if category in {"packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return f"    return new_opaque_value({call});"
    if category == "object":
        return f"    return reinterpret_cast<intptr_t>({call});"
    if category == "native_pointer":
        return f"    return reinterpret_cast<intptr_t>({call});"
    if category == "refcounted":
        return f"    return retain_refcounted({call});"
    if category == "enum":
        return f"    return static_cast<int32_t>({call});"
    if category == "bitfield":
        return f"    return static_cast<int64_t>({call});"
    if category == "float":
        return f"    return static_cast<float>({call});"
    return f"    return {call};"


def cpp_native_param_declaration(arg):
    name = camel_name(arg["name"])
    typ = arg["type"]
    if typ.category == "string":
        return f"leanclr::vm::RtString* p_{name}"
    if typ.category == "variant":
        return f"ManagedVariant p_{name}"
    if typ.category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return f"intptr_t p_{name}_ptr"
    if typ.category == "native_pointer":
        return f"intptr_t p_{name}"
    if typ.category in {"object", "refcounted"}:
        return f"intptr_t p_{name}_ptr"
    if typ.category == "enum":
        return f"int32_t p_{name}"
    if typ.category == "bitfield":
        return f"int64_t p_{name}"
    return f"{typ.native_type} p_{name}"


def cpp_call_arg(arg):
    name = camel_name(arg["name"])
    typ = arg["type"]
    if typ.category == "string":
        if typ.cpp_type == "StringName":
            return f"StringName(rt_string_to_godot(p_{name}))"
        if typ.cpp_type == "NodePath":
            return f"NodePath(rt_string_to_godot(p_{name}))"
        return f"rt_string_to_godot(p_{name})"
    if typ.category == "variant":
        return f"variant_arg(p_{name})"
    if typ.category == "packed_string_array":
        return f"packed_string_array_arg(p_{name}_ptr)"
    if typ.category in {"packed_array", "opaque_variant", "typed_array", "opaque_value"}:
        return f"opaque_value_arg<{typ.cpp_type}>(p_{name}_ptr)"
    if typ.category == "native_pointer":
        return f"reinterpret_cast<{typ.cpp_type}>(p_{name})"
    if typ.category == "object":
        return f"as_godot_object<{cpp_cast_type(typ)}>(p_{name}_ptr)"
    if typ.category == "refcounted":
        return f"Ref<{cpp_cast_type(typ)}>(as_godot_object<{cpp_cast_type(typ)}>(p_{name}_ptr))"
    if typ.category == "enum":
        return f"static_cast<{typ.cpp_type}>(p_{name})"
    if typ.category == "bitfield":
        return f"{typ.cpp_type}(p_{name})"
    if typ.category == "int" and typ.cpp_type and typ.cpp_type != typ.native_type:
        return f"static_cast<{typ.cpp_type}>(p_{name})"
    return f"p_{name}"


def cpp_self_type(method):
    return "Object" if method.class_name == "Object" else method.cpp_class_name


def append_formal_vararg(array_name, arg):
    category = arg["type"].category
    expression = cpp_call_arg(arg)
    if category == "void":
        return ""
    if category == "enum":
        expression = f"static_cast<int32_t>({expression})"
    if category == "bitfield":
        expression = f"static_cast<int64_t>({expression})"
    return f"    {array_name}.append(Variant({expression}));"


def vararg_return_statement(method, result_name):
    category = method.return_type.category
    if category == "void":
        return "    return leanclr::core::Unit{};"
    if category == "variant":
        return f"    return to_managed_variant({result_name});"
    if category == "enum":
        return f"    return static_cast<int32_t>(static_cast<int64_t>({result_name}));"
    if category == "bitfield":
        return f"    return static_cast<int64_t>({result_name});"
    if category == "bool":
        return f"    return static_cast<bool>({result_name});"
    if category == "int":
        return f"    return static_cast<int64_t>({result_name});"
    if category == "float":
        return f"    return static_cast<float>(static_cast<double>({result_name}));"
    if category == "string":
        return f"    return to_rt_string(static_cast<String>({result_name}));"
    if category in {"object", "refcounted"}:
        return f"    return reinterpret_cast<intptr_t>(static_cast<Object*>({result_name}));"
    return f"    return {method.return_type.native_type}();"


def generate_native_vararg_method_function(method):
    fn = native_function_name(method)
    params = ([] if method.is_static else ["intptr_t p_native_ptr"]) + [cpp_native_param_declaration(arg) for arg in method.args] + ["leanclr::vm::RtArray* p_varargs"]
    self_type = "Object"
    setup_lines = []
    if not method.is_static:
        setup_lines.extend(
            [
                f"    {self_type}* self = as_godot_object<{self_type}>(p_native_ptr);",
                "    if (self == nullptr)",
                "    {",
                f"        { {'void': 'return leanclr::core::Unit{};', 'variant': 'return to_managed_variant(Variant());', 'enum': 'return 0;'}.get(method.return_type.category, 'return ' + method.return_type.native_type + '();') }",
                "    }",
                "",
            ]
        )
    setup_lines.append("    Array args;")
    if method.class_name == "Object" and method.api_name == "call":
        call_method = "rt_string_to_godot(p_method)"
    else:
        call_method = f"StringName(\"{method.api_name}\")"
        for arg in method.args:
            setup_lines.append(append_formal_vararg("args", arg))
    setup_lines.append("    append_managed_varargs(args, p_varargs);")
    if method.is_static and method.class_name in SINGLETON_CLASS_CPP_NAMES:
        target = f"{method.cpp_class_name}::get_singleton()"
    else:
        target = method.cpp_class_name if method.is_static else "self"
    if method.return_type.category == "void":
        call_lines = [f"    {target}->callv({call_method}, args);", *vararg_return_statement(method, "result").splitlines()]
    else:
        call_lines = [f"    Variant result = {target}->callv({call_method}, args);", *vararg_return_statement(method, "result").splitlines()]
    return f"""{method.return_type.native_type} {fn}({', '.join(params)}) noexcept
{{
{chr(10).join(line for line in setup_lines if line is not None)}
{chr(10).join(call_lines)}
}}
"""


def generate_native_method_function(method):
    fn = native_function_name(method)
    if method.is_vararg:
        return generate_native_vararg_method_function(method)
    params = ([] if method.is_static else ["intptr_t p_native_ptr"]) + [cpp_native_param_declaration(arg) for arg in method.args]
    call_args = ", ".join(cpp_call_arg(arg) for arg in method.args)
    if method.is_static:
        if method.class_name in SINGLETON_CLASS_CPP_NAMES:
            # godot-cpp 4.5 exposes ClassDB methods as non-static on
            # ClassDBSingleton; route them through the singleton instance.
            target = f"{method.cpp_class_name}::get_singleton()"
            call = f"{target}->{method.cpp_name}({call_args})" if call_args else f"{target}->{method.cpp_name}()"
        else:
            call = f"{method.cpp_class_name}::{method.cpp_name}({call_args})" if call_args else f"{method.cpp_class_name}::{method.cpp_name}()"
        return f"""{method.return_type.native_type} {fn}({', '.join(params)}) noexcept
{{
{cpp_return_statement(method, call)}
}}
"""

    self_type = cpp_self_type(method)
    call = f"self->{method.cpp_name}({call_args})" if call_args else f"self->{method.cpp_name}()"
    null_return = {
        "void": "return leanclr::core::Unit{};",
        "string": "return leanclr::vm::String::get_empty_string();",
        "variant": "return to_managed_variant(Variant());",
        "packed_string_array": "return new_packed_string_array(PackedStringArray());",
        "packed_array": f"return 0;",
        "opaque_variant": f"return 0;",
        "typed_array": f"return 0;",
        "opaque_value": f"return 0;",
        "object": "return 0;",
        "native_pointer": "return 0;",
        "refcounted": "return 0;",
        "bool": "return false;",
        "int": "return 0;",
        "float": "return 0.0f;",
        "enum": "return 0;",
        "bitfield": "return 0;",
        "vector2": "return Vector2();",
        "vector2i": "return Vector2i();",
        "vector3": "return Vector3();",
        "vector3i": "return Vector3i();",
        "color": "return Color();",
        "rect2": "return Rect2();",
        "rect2i": "return Rect2i();",
        "transform2d": "return Transform2D();",
        "aabb": "return AABB();",
        "quaternion": "return Quaternion();",
        "basis": "return Basis();",
        "transform3d": "return Transform3D();",
        "vector4": "return Vector4();",
        "vector4i": "return Vector4i();",
        "plane": "return Plane();",
        "projection": "return Projection();",
        "rid": "return RID();",
    }[method.return_type.category]
    return f"""{method.return_type.native_type} {fn}({', '.join(params)}) noexcept
{{
    {self_type}* self = as_godot_object<{self_type}>(p_native_ptr);
    if (self == nullptr)
    {{
        {null_return}
    }}

{cpp_return_statement(method, call)}
}}
"""


def cpp_invoker_param_get(arg, index):
    name = camel_name(arg["name"])
    typ = arg["type"]
    if typ.category == "variant":
        return f"    ManagedVariant arg_{name} = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, {index});"
    if typ.category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value", "object", "refcounted"}:
        return f"    const intptr_t arg_{name}_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, {index});"
    return f"    {typ.stack_type} arg_{name} = leanclr::interp::EvalStackOp::get_param<{typ.stack_type}>(p_params, {index});"


def generate_native_invoker(method):
    fn = native_function_name(method)
    invoker = f"{fn}_invoker"
    param_reads = [] if method.is_static else ["    const intptr_t p_native_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);"]
    call_args = [] if method.is_static else ["p_native_ptr"]
    arg_offset = 0 if method.is_static else 1
    for arg in method.args:
        param_reads.append(cpp_invoker_param_get(arg, arg_offset))
        arg_offset += arg["type"].stack_slots
        name = camel_name(arg["name"])
        call_args.append(f"arg_{name}_ptr" if arg["type"].category in {"packed_string_array", "packed_array", "opaque_variant", "typed_array", "opaque_value", "object", "refcounted"} else f"arg_{name}")
    if method.is_vararg:
        param_reads.append(f"    leanclr::vm::RtArray* p_varargs = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtArray*>(p_params, {arg_offset});")
        call_args.append("p_varargs")
    if method.return_type.category == "void":
        body = f"    return {fn}({', '.join(call_args)});"
    else:
        body = f"    leanclr::interp::EvalStackOp::set_return(p_ret, {fn}({', '.join(call_args)}));\n    return leanclr::core::Unit{{}};"
    return f"""leanclr::RtResultVoid {invoker}(leanclr::metadata::RtManagedMethodPointer p_method_ptr,
                                       const leanclr::metadata::RtMethodInfo* p_method,
                                       const leanclr::interp::RtStackObject* p_params,
                                       leanclr::interp::RtStackObject* p_ret) noexcept
{{
    (void)p_method_ptr;
    (void)p_method;
    (void)p_params;
    (void)p_ret;
{chr(10).join(param_reads)}
{body}
}}
"""


def generate_native(classes, methods, src_dir):
    methods = [method for method in methods if not method.is_virtual]
    write(
        src_dir / "generated" / "godot_api.generated.h",
        """#pragma once

namespace godot
{

void register_generated_godot_api_icalls();

} // namespace godot
""",
    )

    includes = ["#include \"godot_api.generated.h\"", ""]
    bound_classes = {method.class_name for method in methods}
    for method in methods:
        if method.return_type.category in {"object", "refcounted"}:
            bound_classes.add(method.return_type.cpp_type)
        for arg in method.args:
            if arg["type"].category in {"object", "refcounted"}:
                bound_classes.add(arg["type"].cpp_type)
    bound_classes = sorted(bound_classes)
    for class_name in bound_classes:
        includes.append(f"#include <godot_cpp/classes/{cpp_header_name(class_name)}.hpp>")
    includes.extend(
        [
            "#include <godot_cpp/variant/char_string.hpp>",
            "#include <godot_cpp/variant/node_path.hpp>",
            "#include <godot_cpp/variant/aabb.hpp>",
            "#include <godot_cpp/variant/array.hpp>",
            "#include <godot_cpp/variant/basis.hpp>",
            "#include <godot_cpp/variant/callable.hpp>",
            "#include <godot_cpp/variant/color.hpp>",
            "#include <godot_cpp/variant/dictionary.hpp>",
            "#include <godot_cpp/variant/packed_byte_array.hpp>",
            "#include <godot_cpp/variant/packed_color_array.hpp>",
            "#include <godot_cpp/variant/packed_float32_array.hpp>",
            "#include <godot_cpp/variant/packed_float64_array.hpp>",
            "#include <godot_cpp/variant/packed_int32_array.hpp>",
            "#include <godot_cpp/variant/packed_int64_array.hpp>",
            "#include <godot_cpp/variant/packed_string_array.hpp>",
            "#include <godot_cpp/variant/packed_vector2_array.hpp>",
            "#include <godot_cpp/variant/packed_vector3_array.hpp>",
            "#include <godot_cpp/variant/plane.hpp>",
            "#include <godot_cpp/variant/rect2.hpp>",
            "#include <godot_cpp/variant/rect2i.hpp>",
            "#include <godot_cpp/variant/rid.hpp>",
            "#include <godot_cpp/variant/signal.hpp>",
            "#include <godot_cpp/variant/projection.hpp>",
            "#include <godot_cpp/variant/quaternion.hpp>",
            "#include <godot_cpp/variant/string.hpp>",
            "#include <godot_cpp/variant/string_name.hpp>",
            "#include <godot_cpp/variant/transform2d.hpp>",
            "#include <godot_cpp/variant/transform3d.hpp>",
            "#include <godot_cpp/variant/typed_array.hpp>",
            "#include <godot_cpp/variant/vector2.hpp>",
            "#include <godot_cpp/variant/vector2i.hpp>",
            "#include <godot_cpp/variant/vector3.hpp>",
            "#include <godot_cpp/variant/vector3i.hpp>",
            "#include <godot_cpp/variant/vector4.hpp>",
            "#include <godot_cpp/variant/vector4i.hpp>",
            "#include <godot_cpp/variant/variant.hpp>",
            "",
            "#include \"interp/eval_stack_op.h\"",
            "#include \"vm/internal_calls.h\"",
            "#include \"vm/rt_array.h\"",
            "#include \"vm/rt_string.h\"",
            "",
        ]
    )

    body = [
        "// <auto-generated />",
        *includes,
        "namespace godot",
        "{",
        "namespace",
        "{",
        "",
        "enum ManagedVariantType : int32_t",
        "{",
        "    MANAGED_VARIANT_TYPE_NIL = 0,",
        "    MANAGED_VARIANT_TYPE_BOOL = 1,",
        "    MANAGED_VARIANT_TYPE_INT = 2,",
        "    MANAGED_VARIANT_TYPE_FLOAT = 3,",
        "    MANAGED_VARIANT_TYPE_STRING = 4,",
        "    MANAGED_VARIANT_TYPE_VECTOR2 = 5,",
        "    MANAGED_VARIANT_TYPE_VECTOR2I = 6,",
        "    MANAGED_VARIANT_TYPE_RECT2 = 7,",
        "    MANAGED_VARIANT_TYPE_RECT2I = 8,",
        "    MANAGED_VARIANT_TYPE_VECTOR3 = 9,",
        "    MANAGED_VARIANT_TYPE_VECTOR3I = 10,",
        "    MANAGED_VARIANT_TYPE_TRANSFORM2D = 11,",
        "    MANAGED_VARIANT_TYPE_VECTOR4 = 12,",
        "    MANAGED_VARIANT_TYPE_VECTOR4I = 13,",
        "    MANAGED_VARIANT_TYPE_PLANE = 14,",
        "    MANAGED_VARIANT_TYPE_QUATERNION = 15,",
        "    MANAGED_VARIANT_TYPE_AABB = 16,",
        "    MANAGED_VARIANT_TYPE_BASIS = 17,",
        "    MANAGED_VARIANT_TYPE_TRANSFORM3D = 18,",
        "    MANAGED_VARIANT_TYPE_PROJECTION = 19,",
        "    MANAGED_VARIANT_TYPE_COLOR = 20,",
        "    MANAGED_VARIANT_TYPE_STRING_NAME = 21,",
        "    MANAGED_VARIANT_TYPE_NODE_PATH = 22,",
        "    MANAGED_VARIANT_TYPE_RID = 23,",
        "    MANAGED_VARIANT_TYPE_OBJECT = 24,"
        "    MANAGED_VARIANT_TYPE_CALLABLE = 25,"
        "    MANAGED_VARIANT_TYPE_SIGNAL = 26,"
        "    MANAGED_VARIANT_TYPE_DICTIONARY = 27,",
        "    MANAGED_VARIANT_TYPE_ARRAY = 28,",
        "    MANAGED_VARIANT_TYPE_PACKED_BYTE_ARRAY = 29,",
        "    MANAGED_VARIANT_TYPE_PACKED_INT32_ARRAY = 30,",
        "    MANAGED_VARIANT_TYPE_PACKED_INT64_ARRAY = 31,",
        "    MANAGED_VARIANT_TYPE_PACKED_FLOAT32_ARRAY = 32,",
        "    MANAGED_VARIANT_TYPE_PACKED_FLOAT64_ARRAY = 33,",
        "    MANAGED_VARIANT_TYPE_PACKED_STRING_ARRAY = 34,",
        "    MANAGED_VARIANT_TYPE_PACKED_VECTOR2_ARRAY = 35,",
        "    MANAGED_VARIANT_TYPE_PACKED_VECTOR3_ARRAY = 36,",
        "    MANAGED_VARIANT_TYPE_PACKED_COLOR_ARRAY = 37,",
        "};",
        "",
        "struct ManagedVector2 { float x; float y; };",
        "struct ManagedVector2i { int32_t x; int32_t y; };",
        "struct ManagedVector3 { float x; float y; float z; };",
        "struct ManagedVector3i { int32_t x; int32_t y; int32_t z; };",
        "struct ManagedVector4 { float x; float y; float z; float w; };",
        "struct ManagedVector4i { int32_t x; int32_t y; int32_t z; int32_t w; };",
        "struct ManagedColor { float r; float g; float b; float a; };",
        "struct ManagedRect2 { ManagedVector2 position; ManagedVector2 size; };",
        "struct ManagedRect2i { ManagedVector2i position; ManagedVector2i size; };",
        "struct ManagedTransform2D { ManagedVector2 x; ManagedVector2 y; ManagedVector2 origin; };",
        "struct ManagedAABB { ManagedVector3 position; ManagedVector3 size; };",
        "struct ManagedQuaternion { float x; float y; float z; float w; };",
        "struct ManagedBasis { ManagedVector3 x; ManagedVector3 y; ManagedVector3 z; };",
        "struct ManagedTransform3D { ManagedBasis basis; ManagedVector3 origin; };",
        "struct ManagedPlane { ManagedVector3 normal; float d; };",
        "struct ManagedProjection { ManagedVector4 x; ManagedVector4 y; ManagedVector4 z; ManagedVector4 w; };",
        "",
        "struct ManagedVariant",
        "{",
        "    int32_t type = MANAGED_VARIANT_TYPE_NIL;",
        "    int32_t flags = 0;",
        "    union",
        "    {",
        "        bool bool_value;",
        "        int64_t int_value;",
        "        double float_value;",
        "        leanclr::vm::RtString* string_value;",
        "        int64_t rid_value;",
        "        intptr_t native_ptr;",
        "        ManagedVector2 vector2_value;",
        "        ManagedVector2i vector2i_value;",
        "        ManagedVector3 vector3_value;",
        "        ManagedVector3i vector3i_value;",
        "        ManagedVector4 vector4_value;",
        "        ManagedVector4i vector4i_value;",
        "        ManagedColor color_value;",
        "        ManagedRect2 rect2_value;",
        "        ManagedRect2i rect2i_value;",
        "        ManagedTransform2D transform2d_value;",
        "        ManagedAABB aabb_value;",
        "        ManagedQuaternion quaternion_value;",
        "        ManagedBasis basis_value;",
        "        ManagedTransform3D transform3d_value;",
        "        ManagedPlane plane_value;",
        "        ManagedProjection projection_value;",
        "    };",
        "};",
        "",
        "String rt_string_to_godot(const leanclr::vm::RtString* p_string)",
        "{",
        "    if (p_string == nullptr)",
        "    {",
        "        return String();",
        "    }",
        "",
        "    String result;",
        "    for (int32_t i = 0; i < p_string->length; ++i)",
        "    {",
        "        result += String::chr(static_cast<char32_t>(*(&p_string->first_char + i)));",
        "    }",
        "    return result;",
        "}",
        "",
        "leanclr::vm::RtString* to_rt_string(const String& p_string)",
        "{",
        "    const CharString utf8 = p_string.utf8();",
        "    return leanclr::vm::String::create_string_from_utf8cstr(utf8.get_data());",
        "}",
        "",
        "leanclr::vm::RtString* to_rt_string(const StringName& p_string_name)",
        "{",
        "    return to_rt_string(String(p_string_name));",
        "}",
        "",
        "struct OpaqueValue",
        "{",
        "    void* value = nullptr;",
        "    void (*destroy)(void*) = nullptr;",
        "};",
        "",
        "template <typename T>",
        "void destroy_opaque_value(void* p_value)",
        "{",
        "    memdelete(reinterpret_cast<T*>(p_value));",
        "}",
        "",
        "template <typename T>",
        "intptr_t new_opaque_value(const T& p_value)",
        "{",
        "    OpaqueValue* opaque = memnew(OpaqueValue);",
        "    opaque->value = memnew(T(p_value));",
        "    opaque->destroy = &destroy_opaque_value<T>;",
        "    return reinterpret_cast<intptr_t>(opaque);",
        "}",
        "",
        "template <typename T>",
        "T* opaque_value_ptr(intptr_t p_value_ptr)",
        "{",
        "    OpaqueValue* opaque = reinterpret_cast<OpaqueValue*>(p_value_ptr);",
        "    return opaque != nullptr && opaque->value != nullptr ? reinterpret_cast<T*>(opaque->value) : nullptr;",
        "}",
        "",
        "template <typename T>",
        "T opaque_value_arg(intptr_t p_value_ptr)",
        "{",
        "    T* value = opaque_value_ptr<T>(p_value_ptr);",
        "    return value != nullptr ? *value : T();",
        "}",
        "",
        "intptr_t new_packed_string_array(const PackedStringArray& p_array);",
        "PackedStringArray packed_string_array_arg(intptr_t p_array_ptr);",
        "",
        "ManagedVariant to_managed_variant(const Variant& p_variant)",
        "{",
        "    ManagedVariant result;",
        "    switch (p_variant.get_type())",
        "    {",
        "        case Variant::BOOL:",
        "            result.type = MANAGED_VARIANT_TYPE_BOOL;",
        "            result.bool_value = static_cast<bool>(p_variant);",
        "            break;",
        "        case Variant::INT:",
        "            result.type = MANAGED_VARIANT_TYPE_INT;",
        "            result.int_value = static_cast<int64_t>(p_variant);",
        "            break;",
        "        case Variant::FLOAT:",
        "            result.type = MANAGED_VARIANT_TYPE_FLOAT;",
        "            result.float_value = static_cast<double>(p_variant);",
        "            break;",
        "        case Variant::STRING:",
        "            result.type = MANAGED_VARIANT_TYPE_STRING;",
        "            result.string_value = to_rt_string(static_cast<String>(p_variant));",
        "            break;",
        "        case Variant::STRING_NAME:",
        "            result.type = MANAGED_VARIANT_TYPE_STRING_NAME;",
        "            result.string_value = to_rt_string(static_cast<StringName>(p_variant));",
        "            break;",
        "        case Variant::NODE_PATH:",
        "            result.type = MANAGED_VARIANT_TYPE_NODE_PATH;",
        "            result.string_value = to_rt_string(String(static_cast<NodePath>(p_variant)));",
        "            break;",
        "        case Variant::RID:",
        "            result.type = MANAGED_VARIANT_TYPE_RID;",
        "            { const RID value = static_cast<RID>(p_variant); result.rid_value = value.get_id(); }",
        "            break;",
        "        case Variant::VECTOR2:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR2;",
        "            { const Vector2 value = static_cast<Vector2>(p_variant); result.vector2_value = ManagedVector2{value.x, value.y}; }",
        "            break;",
        "        case Variant::VECTOR2I:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR2I;",
        "            { const Vector2i value = static_cast<Vector2i>(p_variant); result.vector2i_value = ManagedVector2i{value.x, value.y}; }",
        "            break;",
        "        case Variant::RECT2:",
        "            result.type = MANAGED_VARIANT_TYPE_RECT2;",
        "            { const Rect2 value = static_cast<Rect2>(p_variant); result.rect2_value = ManagedRect2{ManagedVector2{value.position.x, value.position.y}, ManagedVector2{value.size.x, value.size.y}}; }",
        "            break;",
        "        case Variant::RECT2I:",
        "            result.type = MANAGED_VARIANT_TYPE_RECT2I;",
        "            { const Rect2i value = static_cast<Rect2i>(p_variant); result.rect2i_value = ManagedRect2i{ManagedVector2i{value.position.x, value.position.y}, ManagedVector2i{value.size.x, value.size.y}}; }",
        "            break;",
        "        case Variant::VECTOR3:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR3;",
        "            { const Vector3 value = static_cast<Vector3>(p_variant); result.vector3_value = ManagedVector3{value.x, value.y, value.z}; }",
        "            break;",
        "        case Variant::VECTOR3I:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR3I;",
        "            { const Vector3i value = static_cast<Vector3i>(p_variant); result.vector3i_value = ManagedVector3i{value.x, value.y, value.z}; }",
        "            break;",
        "        case Variant::TRANSFORM2D:",
        "            result.type = MANAGED_VARIANT_TYPE_TRANSFORM2D;",
        "            { const Transform2D value = static_cast<Transform2D>(p_variant); result.transform2d_value = ManagedTransform2D{ManagedVector2{value.columns[0].x, value.columns[0].y}, ManagedVector2{value.columns[1].x, value.columns[1].y}, ManagedVector2{value.columns[2].x, value.columns[2].y}}; }",
        "            break;",
        "        case Variant::VECTOR4:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR4;",
        "            { const Vector4 value = static_cast<Vector4>(p_variant); result.vector4_value = ManagedVector4{value.x, value.y, value.z, value.w}; }",
        "            break;",
        "        case Variant::VECTOR4I:",
        "            result.type = MANAGED_VARIANT_TYPE_VECTOR4I;",
        "            { const Vector4i value = static_cast<Vector4i>(p_variant); result.vector4i_value = ManagedVector4i{value.x, value.y, value.z, value.w}; }",
        "            break;",
        "        case Variant::PLANE:",
        "            result.type = MANAGED_VARIANT_TYPE_PLANE;",
        "            { const Plane value = static_cast<Plane>(p_variant); result.plane_value = ManagedPlane{ManagedVector3{value.normal.x, value.normal.y, value.normal.z}, value.d}; }",
        "            break;",
        "        case Variant::QUATERNION:",
        "            result.type = MANAGED_VARIANT_TYPE_QUATERNION;",
        "            { const Quaternion value = static_cast<Quaternion>(p_variant); result.quaternion_value = ManagedQuaternion{value.x, value.y, value.z, value.w}; }",
        "            break;",
        "        case Variant::AABB:",
        "            result.type = MANAGED_VARIANT_TYPE_AABB;",
        "            { const AABB value = static_cast<AABB>(p_variant); result.aabb_value = ManagedAABB{ManagedVector3{value.position.x, value.position.y, value.position.z}, ManagedVector3{value.size.x, value.size.y, value.size.z}}; }",
        "            break;",
        "        case Variant::BASIS:",
        "            result.type = MANAGED_VARIANT_TYPE_BASIS;",
        "            { const Basis value = static_cast<Basis>(p_variant); result.basis_value = ManagedBasis{ManagedVector3{value.rows[0].x, value.rows[0].y, value.rows[0].z}, ManagedVector3{value.rows[1].x, value.rows[1].y, value.rows[1].z}, ManagedVector3{value.rows[2].x, value.rows[2].y, value.rows[2].z}}; }",
        "            break;",
        "        case Variant::TRANSFORM3D:",
        "            result.type = MANAGED_VARIANT_TYPE_TRANSFORM3D;",
        "            { const Transform3D value = static_cast<Transform3D>(p_variant); result.transform3d_value = ManagedTransform3D{ManagedBasis{ManagedVector3{value.basis.rows[0].x, value.basis.rows[0].y, value.basis.rows[0].z}, ManagedVector3{value.basis.rows[1].x, value.basis.rows[1].y, value.basis.rows[1].z}, ManagedVector3{value.basis.rows[2].x, value.basis.rows[2].y, value.basis.rows[2].z}}, ManagedVector3{value.origin.x, value.origin.y, value.origin.z}}; }",
        "            break;",
        "        case Variant::PROJECTION:",
        "            result.type = MANAGED_VARIANT_TYPE_PROJECTION;",
        "            { const Projection value = static_cast<Projection>(p_variant); result.projection_value = ManagedProjection{ManagedVector4{value.columns[0].x, value.columns[0].y, value.columns[0].z, value.columns[0].w}, ManagedVector4{value.columns[1].x, value.columns[1].y, value.columns[1].z, value.columns[1].w}, ManagedVector4{value.columns[2].x, value.columns[2].y, value.columns[2].z, value.columns[2].w}, ManagedVector4{value.columns[3].x, value.columns[3].y, value.columns[3].z, value.columns[3].w}}; }",
        "            break;",
        "        case Variant::COLOR:",
        "            result.type = MANAGED_VARIANT_TYPE_COLOR;",
        "            { const Color value = static_cast<Color>(p_variant); result.color_value = ManagedColor{value.r, value.g, value.b, value.a}; }",
        "            break;",
        "        case Variant::OBJECT:",
        "            result.type = MANAGED_VARIANT_TYPE_OBJECT;",
        "            result.native_ptr = reinterpret_cast<intptr_t>(static_cast<Object*>(p_variant));",
        "            break;",
        "        case Variant::ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<Array>(p_variant));",
        "            break;",
        "        case Variant::DICTIONARY:",
        "            result.type = MANAGED_VARIANT_TYPE_DICTIONARY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<Dictionary>(p_variant));",
        "            break;",
        "        case Variant::CALLABLE:",
        "            result.type = MANAGED_VARIANT_TYPE_CALLABLE;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<Callable>(p_variant));",
        "            break;",
        "        case Variant::SIGNAL:",
        "            result.type = MANAGED_VARIANT_TYPE_SIGNAL;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<Signal>(p_variant));",
        "            break;",
        "        case Variant::PACKED_BYTE_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_BYTE_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedByteArray>(p_variant));",
        "            break;",
        "        case Variant::PACKED_INT32_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_INT32_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedInt32Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_INT64_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_INT64_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedInt64Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_FLOAT32_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_FLOAT32_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedFloat32Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_FLOAT64_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_FLOAT64_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedFloat64Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_STRING_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_STRING_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_packed_string_array(static_cast<PackedStringArray>(p_variant));",
        "            break;",
        "        case Variant::PACKED_VECTOR2_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_VECTOR2_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedVector2Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_VECTOR3_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_VECTOR3_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedVector3Array>(p_variant));",
        "            break;",
        "        case Variant::PACKED_COLOR_ARRAY:",
        "            result.type = MANAGED_VARIANT_TYPE_PACKED_COLOR_ARRAY;",
        "            result.flags = 1;",
        "            result.native_ptr = new_opaque_value(static_cast<PackedColorArray>(p_variant));",
        "            break;",
        "        default:",
        "            result.type = MANAGED_VARIANT_TYPE_NIL;",
        "            result.int_value = 0;",
        "            break;",
        "    }",
        "    return result;",
        "}",
        "",
        "Variant variant_arg(const ManagedVariant& p_variant)",
        "{",
        "    switch (p_variant.type)",
        "    {",
        "        case MANAGED_VARIANT_TYPE_BOOL:",
        "            return Variant(p_variant.bool_value);",
        "        case MANAGED_VARIANT_TYPE_INT:",
        "            return Variant(p_variant.int_value);",
        "        case MANAGED_VARIANT_TYPE_FLOAT:",
        "            return Variant(p_variant.float_value);",
        "        case MANAGED_VARIANT_TYPE_STRING:",
        "            return Variant(rt_string_to_godot(p_variant.string_value));",
        "        case MANAGED_VARIANT_TYPE_STRING_NAME:",
        "            return Variant(StringName(rt_string_to_godot(p_variant.string_value)));",
        "        case MANAGED_VARIANT_TYPE_NODE_PATH:",
        "            return Variant(NodePath(rt_string_to_godot(p_variant.string_value)));",
        "        case MANAGED_VARIANT_TYPE_RID:",
        "            { RID rid; *reinterpret_cast<int64_t*>(rid._native_ptr()) = p_variant.rid_value; return Variant(rid); }",
        "        case MANAGED_VARIANT_TYPE_VECTOR2:",
        "            return Variant(Vector2(p_variant.vector2_value.x, p_variant.vector2_value.y));",
        "        case MANAGED_VARIANT_TYPE_VECTOR2I:",
        "            return Variant(Vector2i(p_variant.vector2i_value.x, p_variant.vector2i_value.y));",
        "        case MANAGED_VARIANT_TYPE_RECT2:",
        "            return Variant(Rect2(Vector2(p_variant.rect2_value.position.x, p_variant.rect2_value.position.y), Vector2(p_variant.rect2_value.size.x, p_variant.rect2_value.size.y)));",
        "        case MANAGED_VARIANT_TYPE_RECT2I:",
        "            return Variant(Rect2i(Vector2i(p_variant.rect2i_value.position.x, p_variant.rect2i_value.position.y), Vector2i(p_variant.rect2i_value.size.x, p_variant.rect2i_value.size.y)));",
        "        case MANAGED_VARIANT_TYPE_VECTOR3:",
        "            return Variant(Vector3(p_variant.vector3_value.x, p_variant.vector3_value.y, p_variant.vector3_value.z));",
        "        case MANAGED_VARIANT_TYPE_VECTOR3I:",
        "            return Variant(Vector3i(p_variant.vector3i_value.x, p_variant.vector3i_value.y, p_variant.vector3i_value.z));",
        "        case MANAGED_VARIANT_TYPE_TRANSFORM2D:",
        "            return Variant(Transform2D(Vector2(p_variant.transform2d_value.x.x, p_variant.transform2d_value.x.y), Vector2(p_variant.transform2d_value.y.x, p_variant.transform2d_value.y.y), Vector2(p_variant.transform2d_value.origin.x, p_variant.transform2d_value.origin.y)));",
        "        case MANAGED_VARIANT_TYPE_VECTOR4:",
        "            return Variant(Vector4(p_variant.vector4_value.x, p_variant.vector4_value.y, p_variant.vector4_value.z, p_variant.vector4_value.w));",
        "        case MANAGED_VARIANT_TYPE_VECTOR4I:",
        "            return Variant(Vector4i(p_variant.vector4i_value.x, p_variant.vector4i_value.y, p_variant.vector4i_value.z, p_variant.vector4i_value.w));",
        "        case MANAGED_VARIANT_TYPE_PLANE:",
        "            return Variant(Plane(Vector3(p_variant.plane_value.normal.x, p_variant.plane_value.normal.y, p_variant.plane_value.normal.z), p_variant.plane_value.d));",
        "        case MANAGED_VARIANT_TYPE_QUATERNION:",
        "            return Variant(Quaternion(p_variant.quaternion_value.x, p_variant.quaternion_value.y, p_variant.quaternion_value.z, p_variant.quaternion_value.w));",
        "        case MANAGED_VARIANT_TYPE_AABB:",
        "            return Variant(AABB(Vector3(p_variant.aabb_value.position.x, p_variant.aabb_value.position.y, p_variant.aabb_value.position.z), Vector3(p_variant.aabb_value.size.x, p_variant.aabb_value.size.y, p_variant.aabb_value.size.z)));",
        "        case MANAGED_VARIANT_TYPE_BASIS:",
        "            return Variant(Basis(Vector3(p_variant.basis_value.x.x, p_variant.basis_value.x.y, p_variant.basis_value.x.z), Vector3(p_variant.basis_value.y.x, p_variant.basis_value.y.y, p_variant.basis_value.y.z), Vector3(p_variant.basis_value.z.x, p_variant.basis_value.z.y, p_variant.basis_value.z.z)));",
        "        case MANAGED_VARIANT_TYPE_TRANSFORM3D:",
        "            return Variant(Transform3D(Basis(Vector3(p_variant.transform3d_value.basis.x.x, p_variant.transform3d_value.basis.x.y, p_variant.transform3d_value.basis.x.z), Vector3(p_variant.transform3d_value.basis.y.x, p_variant.transform3d_value.basis.y.y, p_variant.transform3d_value.basis.y.z), Vector3(p_variant.transform3d_value.basis.z.x, p_variant.transform3d_value.basis.z.y, p_variant.transform3d_value.basis.z.z)), Vector3(p_variant.transform3d_value.origin.x, p_variant.transform3d_value.origin.y, p_variant.transform3d_value.origin.z)));",
        "        case MANAGED_VARIANT_TYPE_PROJECTION:",
        "            return Variant(Projection(Vector4(p_variant.projection_value.x.x, p_variant.projection_value.x.y, p_variant.projection_value.x.z, p_variant.projection_value.x.w), Vector4(p_variant.projection_value.y.x, p_variant.projection_value.y.y, p_variant.projection_value.y.z, p_variant.projection_value.y.w), Vector4(p_variant.projection_value.z.x, p_variant.projection_value.z.y, p_variant.projection_value.z.z, p_variant.projection_value.z.w), Vector4(p_variant.projection_value.w.x, p_variant.projection_value.w.y, p_variant.projection_value.w.z, p_variant.projection_value.w.w)));",
        "        case MANAGED_VARIANT_TYPE_COLOR:",
        "            return Variant(Color(p_variant.color_value.r, p_variant.color_value.g, p_variant.color_value.b, p_variant.color_value.a));",
        "        case MANAGED_VARIANT_TYPE_OBJECT:",
        "            return Variant(reinterpret_cast<Object*>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_ARRAY:",
        "            return Variant(opaque_value_arg<Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_DICTIONARY:",
        "            return Variant(opaque_value_arg<Dictionary>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_CALLABLE:",
        "            return Variant(opaque_value_arg<Callable>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_SIGNAL:",
        "            return Variant(opaque_value_arg<Signal>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_BYTE_ARRAY:",
        "            return Variant(opaque_value_arg<PackedByteArray>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_INT32_ARRAY:",
        "            return Variant(opaque_value_arg<PackedInt32Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_INT64_ARRAY:",
        "            return Variant(opaque_value_arg<PackedInt64Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_FLOAT32_ARRAY:",
        "            return Variant(opaque_value_arg<PackedFloat32Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_FLOAT64_ARRAY:",
        "            return Variant(opaque_value_arg<PackedFloat64Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_STRING_ARRAY:",
        "            return Variant(packed_string_array_arg(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_VECTOR2_ARRAY:",
        "            return Variant(opaque_value_arg<PackedVector2Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_VECTOR3_ARRAY:",
        "            return Variant(opaque_value_arg<PackedVector3Array>(p_variant.native_ptr));",
        "        case MANAGED_VARIANT_TYPE_PACKED_COLOR_ARRAY:",
        "            return Variant(opaque_value_arg<PackedColorArray>(p_variant.native_ptr));",
        "        default:",
        "            return Variant();",
        "    }",
        "}",
        "",
        "void append_managed_varargs(Array& r_args, leanclr::vm::RtArray* p_varargs)",
        "{",
        "    if (p_varargs == nullptr)",
        "    {",
        "        return;",
        "    }",
        "    const int32_t count = leanclr::vm::Array::get_array_length(p_varargs);",
        "    for (int32_t i = 0; i < count; ++i)",
        "    {",
        "        ManagedVariant value = leanclr::vm::Array::get_array_data_at<ManagedVariant>(p_varargs, i);",
        "        r_args.append(variant_arg(value));",
        "    }",
        "}",
        "",
        "intptr_t new_packed_string_array(const PackedStringArray& p_array)",
        "{",
        "    return reinterpret_cast<intptr_t>(memnew(PackedStringArray(p_array)));",
        "}",
        "",
        "PackedStringArray packed_string_array_arg(intptr_t p_array_ptr)",
        "{",
        "    return p_array_ptr != 0 ? *reinterpret_cast<const PackedStringArray*>(p_array_ptr) : PackedStringArray();",
        "}",
        "",
        "leanclr::RtResultVoid godot_opaquevalue_destroy(intptr_t p_value_ptr) noexcept",
        "{",
        "    if (p_value_ptr != 0)",
        "    {",
        "        OpaqueValue* opaque = reinterpret_cast<OpaqueValue*>(p_value_ptr);",
        "        if (opaque->destroy != nullptr && opaque->value != nullptr)",
        "        {",
        "            opaque->destroy(opaque->value);",
        "        }",
        "        memdelete(opaque);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "intptr_t godot_array_create() noexcept",
        "{",
        "    return new_opaque_value(Array());",
        "}",
        "",
        "Array* godot_array_ptr(intptr_t p_array_ptr)",
        "{",
        "    OpaqueValue* opaque = reinterpret_cast<OpaqueValue*>(p_array_ptr);",
        "    return opaque != nullptr ? reinterpret_cast<Array*>(opaque->value) : nullptr;",
        "}",
        "",
        "int32_t godot_array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "ManagedVariant godot_array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array == nullptr || p_index < 0 || p_index >= array->size())",
        "    {",
        "        return to_managed_variant(Variant());",
        "    }",
        "    return to_managed_variant(array->get(p_index));",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_set(intptr_t p_array_ptr, int32_t p_index, ManagedVariant p_value) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, variant_arg(p_value));",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_add(intptr_t p_array_ptr, ManagedVariant p_value) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(variant_arg(p_value));",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_insert(intptr_t p_array_ptr, int32_t p_index, ManagedVariant p_value) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->insert(p_index, variant_arg(p_value));",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_removeat(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->remove_at(p_index);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "bool godot_array_contains(intptr_t p_array_ptr, ManagedVariant p_value) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    return array != nullptr && array->has(variant_arg(p_value));",
        "}",
        "",
        "int32_t godot_array_indexof(intptr_t p_array_ptr, ManagedVariant p_value) noexcept",
        "{",
        "    Array* array = godot_array_ptr(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->find(variant_arg(p_value))) : -1;",
        "}",
        "",
        "intptr_t godot_dictionary_create() noexcept",
        "{",
        "    return new_opaque_value(Dictionary());",
        "}",
        "",
        "Dictionary* godot_dictionary_ptr(intptr_t p_dictionary_ptr)",
        "{",
        "    OpaqueValue* opaque = reinterpret_cast<OpaqueValue*>(p_dictionary_ptr);",
        "    return opaque != nullptr ? reinterpret_cast<Dictionary*>(opaque->value) : nullptr;",
        "}",
        "",
        "int32_t godot_dictionary_size(intptr_t p_dictionary_ptr) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    return dictionary != nullptr ? static_cast<int32_t>(dictionary->size()) : 0;",
        "}",
        "",
        "bool godot_dictionary_containskey(intptr_t p_dictionary_ptr, ManagedVariant p_key) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    return dictionary != nullptr && dictionary->has(variant_arg(p_key));",
        "}",
        "",
        "ManagedVariant godot_dictionary_get(intptr_t p_dictionary_ptr, ManagedVariant p_key) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    if (dictionary == nullptr)",
        "    {",
        "        return to_managed_variant(Variant());",
        "    }",
        "    const Variant key = variant_arg(p_key);",
        "    return dictionary->has(key) ? to_managed_variant((*dictionary)[key]) : to_managed_variant(Variant());",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_set(intptr_t p_dictionary_ptr, ManagedVariant p_key, ManagedVariant p_value) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    if (dictionary != nullptr)",
        "    {",
        "        (*dictionary)[variant_arg(p_key)] = variant_arg(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "bool godot_dictionary_remove(intptr_t p_dictionary_ptr, ManagedVariant p_key) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    if (dictionary == nullptr)",
        "    {",
        "        return false;",
        "    }",
        "    const Variant key = variant_arg(p_key);",
        "    const bool had_key = dictionary->has(key);",
        "    if (had_key)",
        "    {",
        "        dictionary->erase(key);",
        "    }",
        "    return had_key;",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_clear(intptr_t p_dictionary_ptr) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    if (dictionary != nullptr)",
        "    {",
        "        dictionary->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "intptr_t godot_dictionary_keys(intptr_t p_dictionary_ptr) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    return new_opaque_value(dictionary != nullptr ? dictionary->keys() : Array());",
        "}",
        "",
        "intptr_t godot_dictionary_values(intptr_t p_dictionary_ptr) noexcept",
        "{",
        "    Dictionary* dictionary = godot_dictionary_ptr(p_dictionary_ptr);",
        "    return new_opaque_value(dictionary != nullptr ? dictionary->values() : Array());",
        "}",
        "",
        "leanclr::vm::RtString* godot_variant_stringify(ManagedVariant p_variant) noexcept",
        "{",
        "    return to_rt_string(variant_arg(p_variant).stringify());",
        "}",
        "",        "intptr_t godot_callable_create(intptr_t p_target_ptr, leanclr::vm::RtString* p_method) noexcept",
        "{",
        "    return new_opaque_value(Callable(reinterpret_cast<Object*>(p_target_ptr), StringName(rt_string_to_godot(p_method))));",
        "}",
        "",
        "bool godot_callable_isvalid(intptr_t p_callable_ptr) noexcept",
        "{",
        "    return opaque_value_arg<Callable>(p_callable_ptr).is_valid();",
        "}",
        "",
        "leanclr::vm::RtString* godot_callable_getmethod(intptr_t p_callable_ptr) noexcept",
        "{",
        "    return to_rt_string(opaque_value_arg<Callable>(p_callable_ptr).get_method());",
        "}",
        "",
        "ManagedVariant godot_callable_call(intptr_t p_callable_ptr, leanclr::vm::RtArray* p_varargs) noexcept",
        "{",
        "    Array args;",
        "    append_managed_varargs(args, p_varargs);",
        "    return to_managed_variant(opaque_value_arg<Callable>(p_callable_ptr).callv(args));",
        "}",
        "",
        "intptr_t godot_callable_bind(intptr_t p_callable_ptr, leanclr::vm::RtArray* p_varargs) noexcept",
        "{",
        "    Array args;",
        "    append_managed_varargs(args, p_varargs);",
        "    return new_opaque_value(opaque_value_arg<Callable>(p_callable_ptr).bindv(args));",
        "}",
        "",
        "intptr_t godot_signal_create(intptr_t p_target_ptr, leanclr::vm::RtString* p_signal) noexcept",
        "{",
        "    return new_opaque_value(Signal(reinterpret_cast<Object*>(p_target_ptr), StringName(rt_string_to_godot(p_signal))));",
        "}",
        "",
        "bool godot_signal_isnull(intptr_t p_signal_ptr) noexcept",
        "{",
        "    return opaque_value_arg<Signal>(p_signal_ptr).is_null();",
        "}",
        "",
        "leanclr::vm::RtString* godot_signal_getname(intptr_t p_signal_ptr) noexcept",
        "{",
        "    return to_rt_string(opaque_value_arg<Signal>(p_signal_ptr).get_name());",
        "}",
        "",
        "int32_t godot_signal_connect(intptr_t p_signal_ptr, intptr_t p_callable_ptr, int32_t p_flags) noexcept",
        "{",
        "    return static_cast<int32_t>(opaque_value_arg<Signal>(p_signal_ptr).connect(opaque_value_arg<Callable>(p_callable_ptr), p_flags));",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_emit(intptr_t p_signal_ptr, leanclr::vm::RtArray* p_varargs) noexcept",
        "{",
        "    Signal signal = opaque_value_arg<Signal>(p_signal_ptr);",
        "    Object* target = signal.get_object();",
        "    if (target != nullptr)",
        "    {",
        "        Array args;",
        "        args.append(Variant(signal.get_name()));",
        "        append_managed_varargs(args, p_varargs);",
        "        target->callv(StringName(\"emit_signal\"), args);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "intptr_t godot_packedstringarray_create() noexcept",
        "{",
        "    return new_packed_string_array(PackedStringArray());",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_destroy(intptr_t p_array_ptr) noexcept",
        "{",
        "    if (p_array_ptr != 0)",
        "    {",
        "        memdelete(reinterpret_cast<PackedStringArray*>(p_array_ptr));",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "int32_t godot_packedstringarray_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    return static_cast<int32_t>(packed_string_array_arg(p_array_ptr).size());",
        "}",
        "",
        "leanclr::vm::RtString* godot_packedstringarray_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    const PackedStringArray array = packed_string_array_arg(p_array_ptr);",
        "    if (p_index < 0 || p_index >= array.size())",
        "    {",
        "        return leanclr::vm::String::get_empty_string();",
        "    }",
        "    return to_rt_string(array.get(p_index));",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_append(intptr_t p_array_ptr, leanclr::vm::RtString* p_value) noexcept",
        "{",
        "    PackedStringArray* array = reinterpret_cast<PackedStringArray*>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(rt_string_to_godot(p_value));",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "intptr_t godot_packedbytearray_create() noexcept",
        "{",
        "    return new_opaque_value(PackedByteArray());",
        "}",
        "",
        "int32_t godot_packedbytearray_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedByteArray* array = opaque_value_ptr<PackedByteArray>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "uint8_t godot_packedbytearray_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedByteArray* array = opaque_value_ptr<PackedByteArray>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : 0;",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_set(intptr_t p_array_ptr, int32_t p_index, uint8_t p_value) noexcept",
        "{",
        "    PackedByteArray* array = opaque_value_ptr<PackedByteArray>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_add(intptr_t p_array_ptr, uint8_t p_value) noexcept",
        "{",
        "    PackedByteArray* array = opaque_value_ptr<PackedByteArray>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedByteArray* array = opaque_value_ptr<PackedByteArray>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedbytearray_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedbytearray_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedbytearray_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    uint8_t p_value = leanclr::interp::EvalStackOp::get_param<uint8_t>(p_params, 2);",
        "    return godot_packedbytearray_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    uint8_t p_value = leanclr::interp::EvalStackOp::get_param<uint8_t>(p_params, 1);",
        "    return godot_packedbytearray_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedbytearray_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedbytearray_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedint32array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedInt32Array());",
        "}",
        "",
        "int32_t godot_packedint32array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedInt32Array* array = opaque_value_ptr<PackedInt32Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "int32_t godot_packedint32array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedInt32Array* array = opaque_value_ptr<PackedInt32Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : 0;",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_set(intptr_t p_array_ptr, int32_t p_index, int32_t p_value) noexcept",
        "{",
        "    PackedInt32Array* array = opaque_value_ptr<PackedInt32Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_add(intptr_t p_array_ptr, int32_t p_value) noexcept",
        "{",
        "    PackedInt32Array* array = opaque_value_ptr<PackedInt32Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedInt32Array* array = opaque_value_ptr<PackedInt32Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint32array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint32array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint32array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    int32_t p_value = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 2);",
        "    return godot_packedint32array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    int32_t p_value = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    return godot_packedint32array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint32array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedint32array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedint64array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedInt64Array());",
        "}",
        "",
        "int32_t godot_packedint64array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedInt64Array* array = opaque_value_ptr<PackedInt64Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "int64_t godot_packedint64array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedInt64Array* array = opaque_value_ptr<PackedInt64Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : 0;",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_set(intptr_t p_array_ptr, int32_t p_index, int64_t p_value) noexcept",
        "{",
        "    PackedInt64Array* array = opaque_value_ptr<PackedInt64Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_add(intptr_t p_array_ptr, int64_t p_value) noexcept",
        "{",
        "    PackedInt64Array* array = opaque_value_ptr<PackedInt64Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedInt64Array* array = opaque_value_ptr<PackedInt64Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint64array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint64array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedint64array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    int64_t p_value = leanclr::interp::EvalStackOp::get_param<int64_t>(p_params, 2);",
        "    return godot_packedint64array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    int64_t p_value = leanclr::interp::EvalStackOp::get_param<int64_t>(p_params, 1);",
        "    return godot_packedint64array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedint64array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedint64array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedfloat32array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedFloat32Array());",
        "}",
        "",
        "int32_t godot_packedfloat32array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedFloat32Array* array = opaque_value_ptr<PackedFloat32Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "float godot_packedfloat32array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedFloat32Array* array = opaque_value_ptr<PackedFloat32Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : 0.0f;",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_set(intptr_t p_array_ptr, int32_t p_index, float p_value) noexcept",
        "{",
        "    PackedFloat32Array* array = opaque_value_ptr<PackedFloat32Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_add(intptr_t p_array_ptr, float p_value) noexcept",
        "{",
        "    PackedFloat32Array* array = opaque_value_ptr<PackedFloat32Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedFloat32Array* array = opaque_value_ptr<PackedFloat32Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat32array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat32array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat32array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    float p_value = leanclr::interp::EvalStackOp::get_param<float>(p_params, 2);",
        "    return godot_packedfloat32array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    float p_value = leanclr::interp::EvalStackOp::get_param<float>(p_params, 1);",
        "    return godot_packedfloat32array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat32array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedfloat32array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedfloat64array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedFloat64Array());",
        "}",
        "",
        "int32_t godot_packedfloat64array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedFloat64Array* array = opaque_value_ptr<PackedFloat64Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "double godot_packedfloat64array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedFloat64Array* array = opaque_value_ptr<PackedFloat64Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : 0.0;",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_set(intptr_t p_array_ptr, int32_t p_index, double p_value) noexcept",
        "{",
        "    PackedFloat64Array* array = opaque_value_ptr<PackedFloat64Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_add(intptr_t p_array_ptr, double p_value) noexcept",
        "{",
        "    PackedFloat64Array* array = opaque_value_ptr<PackedFloat64Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedFloat64Array* array = opaque_value_ptr<PackedFloat64Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat64array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat64array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedfloat64array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    double p_value = leanclr::interp::EvalStackOp::get_param<double>(p_params, 2);",
        "    return godot_packedfloat64array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    double p_value = leanclr::interp::EvalStackOp::get_param<double>(p_params, 1);",
        "    return godot_packedfloat64array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedfloat64array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedfloat64array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedvector2array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedVector2Array());",
        "}",
        "",
        "int32_t godot_packedvector2array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedVector2Array* array = opaque_value_ptr<PackedVector2Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "Vector2 godot_packedvector2array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedVector2Array* array = opaque_value_ptr<PackedVector2Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : Vector2();",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_set(intptr_t p_array_ptr, int32_t p_index, Vector2 p_value) noexcept",
        "{",
        "    PackedVector2Array* array = opaque_value_ptr<PackedVector2Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_add(intptr_t p_array_ptr, Vector2 p_value) noexcept",
        "{",
        "    PackedVector2Array* array = opaque_value_ptr<PackedVector2Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedVector2Array* array = opaque_value_ptr<PackedVector2Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector2array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector2array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector2array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    Vector2 p_value = leanclr::interp::EvalStackOp::get_param<Vector2>(p_params, 2);",
        "    return godot_packedvector2array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    Vector2 p_value = leanclr::interp::EvalStackOp::get_param<Vector2>(p_params, 1);",
        "    return godot_packedvector2array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector2array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedvector2array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedvector3array_create() noexcept",
        "{",
        "    return new_opaque_value(PackedVector3Array());",
        "}",
        "",
        "int32_t godot_packedvector3array_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedVector3Array* array = opaque_value_ptr<PackedVector3Array>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "Vector3 godot_packedvector3array_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedVector3Array* array = opaque_value_ptr<PackedVector3Array>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : Vector3();",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_set(intptr_t p_array_ptr, int32_t p_index, Vector3 p_value) noexcept",
        "{",
        "    PackedVector3Array* array = opaque_value_ptr<PackedVector3Array>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_add(intptr_t p_array_ptr, Vector3 p_value) noexcept",
        "{",
        "    PackedVector3Array* array = opaque_value_ptr<PackedVector3Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedVector3Array* array = opaque_value_ptr<PackedVector3Array>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector3array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector3array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedvector3array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    Vector3 p_value = leanclr::interp::EvalStackOp::get_param<Vector3>(p_params, 2);",
        "    return godot_packedvector3array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    Vector3 p_value = leanclr::interp::EvalStackOp::get_param<Vector3>(p_params, 1);",
        "    return godot_packedvector3array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedvector3array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedvector3array_clear(p_array_ptr);",
        "}",
        "",
        "intptr_t godot_packedcolorarray_create() noexcept",
        "{",
        "    return new_opaque_value(PackedColorArray());",
        "}",
        "",
        "int32_t godot_packedcolorarray_size(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedColorArray* array = opaque_value_ptr<PackedColorArray>(p_array_ptr);",
        "    return array != nullptr ? static_cast<int32_t>(array->size()) : 0;",
        "}",
        "",
        "Color godot_packedcolorarray_get(intptr_t p_array_ptr, int32_t p_index) noexcept",
        "{",
        "    PackedColorArray* array = opaque_value_ptr<PackedColorArray>(p_array_ptr);",
        "    return array != nullptr && p_index >= 0 && p_index < array->size() ? array->get(p_index) : Color();",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_set(intptr_t p_array_ptr, int32_t p_index, Color p_value) noexcept",
        "{",
        "    PackedColorArray* array = opaque_value_ptr<PackedColorArray>(p_array_ptr);",
        "    if (array != nullptr && p_index >= 0 && p_index < array->size())",
        "    {",
        "        array->set(p_index, p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_add(intptr_t p_array_ptr, Color p_value) noexcept",
        "{",
        "    PackedColorArray* array = opaque_value_ptr<PackedColorArray>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->append(p_value);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_clear(intptr_t p_array_ptr) noexcept",
        "{",
        "    PackedColorArray* array = opaque_value_ptr<PackedColorArray>(p_array_ptr);",
        "    if (array != nullptr)",
        "    {",
        "        array->clear();",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedcolorarray_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedcolorarray_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedcolorarray_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    Color p_value = leanclr::interp::EvalStackOp::get_param<Color>(p_params, 2);",
        "    return godot_packedcolorarray_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    Color p_value = leanclr::interp::EvalStackOp::get_param<Color>(p_params, 1);",
        "    return godot_packedcolorarray_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedcolorarray_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr, const leanclr::metadata::RtMethodInfo* p_method, const leanclr::interp::RtStackObject* p_params, leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedcolorarray_clear(p_array_ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_variant_stringify_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    ManagedVariant p_variant = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_variant_stringify(p_variant));",
        "    return leanclr::core::Unit{};",
        "}",
        "",        "leanclr::RtResultVoid godot_callable_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_target_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtString* p_method_name = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtString*>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_callable_create(p_target_ptr, p_method_name));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_callable_isvalid_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_callable_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_callable_isvalid(p_callable_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_callable_getmethod_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_callable_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_callable_getmethod(p_callable_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_callable_call_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_callable_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtArray* p_varargs = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtArray*>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_callable_call(p_callable_ptr, p_varargs));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_callable_bind_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_callable_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtArray* p_varargs = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtArray*>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_callable_bind(p_callable_ptr, p_varargs));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_target_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtString* p_signal_name = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtString*>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_signal_create(p_target_ptr, p_signal_name));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_isnull_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_signal_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_signal_isnull(p_signal_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_getname_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_signal_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_signal_getname(p_signal_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_connect_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_signal_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const intptr_t p_callable_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 1);",
        "    const int32_t p_flags = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 2);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_signal_connect(p_signal_ptr, p_callable_ptr, p_flags));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_signal_emit_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_signal_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtArray* p_varargs = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtArray*>(p_params, 1);",
        "    return godot_signal_emit(p_signal_ptr, p_varargs);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedstringarray_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_destroy_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_packedstringarray_destroy(p_array_ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedstringarray_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_packedstringarray_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_packedstringarray_append_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::vm::RtString* p_value = leanclr::interp::EvalStackOp::get_param<leanclr::vm::RtString*>(p_params, 1);",
        "    return godot_packedstringarray_append(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_opaquevalue_destroy_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_value_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_opaquevalue_destroy(p_value_ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_array_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_array_size(p_array_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_array_get(p_array_ptr, p_index));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 2);",
        "    return godot_array_set(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_add_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    return godot_array_add(p_array_ptr, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_insert_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 2);",
        "    return godot_array_insert(p_array_ptr, p_index, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_removeat_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    const int32_t p_index = leanclr::interp::EvalStackOp::get_param<int32_t>(p_params, 1);",
        "    return godot_array_removeat(p_array_ptr, p_index);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_array_clear(p_array_ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_contains_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_array_contains(p_array_ptr, p_value));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_array_indexof_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_array_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_array_indexof(p_array_ptr, p_value));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_create_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_params;",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_create());",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_size_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_size(p_dictionary_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_containskey_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_key = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_containskey(p_dictionary_ptr, p_key));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_get_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_key = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_get(p_dictionary_ptr, p_key));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_set_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_key = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    ManagedVariant p_value = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 10);",
        "    return godot_dictionary_set(p_dictionary_ptr, p_key, p_value);",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_remove_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    ManagedVariant p_key = leanclr::interp::EvalStackOp::get_param<ManagedVariant>(p_params, 1);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_remove(p_dictionary_ptr, p_key));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_clear_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_dictionary_clear(p_dictionary_ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_keys_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_keys(p_dictionary_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_dictionary_values_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    const intptr_t p_dictionary_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    leanclr::interp::EvalStackOp::set_return(p_ret, godot_dictionary_values(p_dictionary_ptr));",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "template <typename T>",
        "T* as_godot_object(intptr_t p_native_ptr)",
        "{",
        "    return Object::cast_to<T>(reinterpret_cast<Object*>(p_native_ptr));",
        "}",
        "",
        "template <typename T>",
        "intptr_t retain_refcounted(const Ref<T>& p_ref)",
        "{",
        "    T* ptr = p_ref.ptr();",
        "    if (ptr != nullptr)",
        "    {",
        "        ptr->reference();",
        "    }",
        "    return reinterpret_cast<intptr_t>(ptr);",
        "}",
        "",
        "leanclr::RtResultVoid godot_object_releaserefcounted(intptr_t p_native_ptr) noexcept",
        "{",
        "    RefCounted* ref_counted = as_godot_object<RefCounted>(p_native_ptr);",
        "    if (ref_counted != nullptr && ref_counted->unreference())",
        "    {",
        "        memdelete(ref_counted);",
        "    }",
        "    return leanclr::core::Unit{};",
        "}",
        "",
        "leanclr::RtResultVoid godot_object_releaserefcounted_invoker(leanclr::metadata::RtManagedMethodPointer p_method_ptr,",
        "                                       const leanclr::metadata::RtMethodInfo* p_method,",
        "                                       const leanclr::interp::RtStackObject* p_params,",
        "                                       leanclr::interp::RtStackObject* p_ret) noexcept",
        "{",
        "    (void)p_method_ptr;",
        "    (void)p_method;",
        "    (void)p_ret;",
        "    const intptr_t p_native_ptr = leanclr::interp::EvalStackOp::get_param<intptr_t>(p_params, 0);",
        "    return godot_object_releaserefcounted(p_native_ptr);",
        "}",
        "",
    ]
    for method in methods:
        body.append(generate_native_method_function(method).rstrip())
        body.append("")
        body.append(generate_native_invoker(method).rstrip())
        body.append("")

    body.extend(["} // namespace", "", "void register_generated_godot_api_icalls()", "{"])
    body.extend(
        [
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotObjectReleaseRefCounted(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_object_releaserefcounted),",
            "                                                       godot_object_releaserefcounted_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotVariantStringify(Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_variant_stringify),",
            "                                                       godot_variant_stringify_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotCallableCreate(System.IntPtr,System.String)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_callable_create),",
            "                                                       godot_callable_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotCallableIsValid(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_callable_isvalid),",
            "                                                       godot_callable_isvalid_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotCallableGetMethod(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_callable_getmethod),",
            "                                                       godot_callable_getmethod_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotCallableCall(System.IntPtr,Godot.Variant[])\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_callable_call),",
            "                                                       godot_callable_call_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotCallableBind(System.IntPtr,Godot.Variant[])\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_callable_bind),",
            "                                                       godot_callable_bind_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotSignalCreate(System.IntPtr,System.String)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_signal_create),",
            "                                                       godot_signal_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotSignalIsNull(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_signal_isnull),",
            "                                                       godot_signal_isnull_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotSignalGetName(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_signal_getname),",
            "                                                       godot_signal_getname_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotSignalConnect(System.IntPtr,System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_signal_connect),",
            "                                                       godot_signal_connect_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotSignalEmit(System.IntPtr,Godot.Variant[])\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_signal_emit),",
            "                                                       godot_signal_emit_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedStringArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedstringarray_create),",
            "                                                       godot_packedstringarray_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedStringArrayDestroy(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedstringarray_destroy),",
            "                                                       godot_packedstringarray_destroy_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedStringArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedstringarray_size),",
            "                                                       godot_packedstringarray_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedStringArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedstringarray_get),",
            "                                                       godot_packedstringarray_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedStringArrayAppend(System.IntPtr,System.String)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedstringarray_append),",
            "                                                       godot_packedstringarray_append_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_create),",
            "                                                       godot_packedbytearray_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_size),",
            "                                                       godot_packedbytearray_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_get),",
            "                                                       godot_packedbytearray_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArraySet(System.IntPtr,System.Int32,System.Byte)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_set),",
            "                                                       godot_packedbytearray_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArrayAdd(System.IntPtr,System.Byte)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_add),",
            "                                                       godot_packedbytearray_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedByteArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedbytearray_clear),",
            "                                                       godot_packedbytearray_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_create),",
            "                                                       godot_packedint32array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_size),",
            "                                                       godot_packedint32array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_get),",
            "                                                       godot_packedint32array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArraySet(System.IntPtr,System.Int32,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_set),",
            "                                                       godot_packedint32array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArrayAdd(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_add),",
            "                                                       godot_packedint32array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt32ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint32array_clear),",
            "                                                       godot_packedint32array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_create),",
            "                                                       godot_packedint64array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_size),",
            "                                                       godot_packedint64array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_get),",
            "                                                       godot_packedint64array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArraySet(System.IntPtr,System.Int32,System.Int64)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_set),",
            "                                                       godot_packedint64array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArrayAdd(System.IntPtr,System.Int64)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_add),",
            "                                                       godot_packedint64array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedInt64ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedint64array_clear),",
            "                                                       godot_packedint64array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_create),",
            "                                                       godot_packedfloat32array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_size),",
            "                                                       godot_packedfloat32array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_get),",
            "                                                       godot_packedfloat32array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArraySet(System.IntPtr,System.Int32,System.Single)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_set),",
            "                                                       godot_packedfloat32array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArrayAdd(System.IntPtr,System.Single)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_add),",
            "                                                       godot_packedfloat32array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat32ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat32array_clear),",
            "                                                       godot_packedfloat32array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_create),",
            "                                                       godot_packedfloat64array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_size),",
            "                                                       godot_packedfloat64array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_get),",
            "                                                       godot_packedfloat64array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArraySet(System.IntPtr,System.Int32,System.Double)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_set),",
            "                                                       godot_packedfloat64array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArrayAdd(System.IntPtr,System.Double)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_add),",
            "                                                       godot_packedfloat64array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedFloat64ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedfloat64array_clear),",
            "                                                       godot_packedfloat64array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_create),",
            "                                                       godot_packedvector2array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_size),",
            "                                                       godot_packedvector2array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_get),",
            "                                                       godot_packedvector2array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArraySet(System.IntPtr,System.Int32,Godot.Vector2)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_set),",
            "                                                       godot_packedvector2array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArrayAdd(System.IntPtr,Godot.Vector2)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_add),",
            "                                                       godot_packedvector2array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector2ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector2array_clear),",
            "                                                       godot_packedvector2array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_create),",
            "                                                       godot_packedvector3array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_size),",
            "                                                       godot_packedvector3array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_get),",
            "                                                       godot_packedvector3array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArraySet(System.IntPtr,System.Int32,Godot.Vector3)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_set),",
            "                                                       godot_packedvector3array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArrayAdd(System.IntPtr,Godot.Vector3)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_add),",
            "                                                       godot_packedvector3array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedVector3ArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedvector3array_clear),",
            "                                                       godot_packedvector3array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_create),",
            "                                                       godot_packedcolorarray_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_size),",
            "                                                       godot_packedcolorarray_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_get),",
            "                                                       godot_packedcolorarray_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArraySet(System.IntPtr,System.Int32,Godot.Color)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_set),",
            "                                                       godot_packedcolorarray_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArrayAdd(System.IntPtr,Godot.Color)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_add),",
            "                                                       godot_packedcolorarray_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotPackedColorArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_packedcolorarray_clear),",
            "                                                       godot_packedcolorarray_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotOpaqueValueDestroy(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_opaquevalue_destroy),",
            "                                                       godot_opaquevalue_destroy_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_create),",
            "                                                       godot_array_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArraySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_size),",
            "                                                       godot_array_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayGet(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_get),",
            "                                                       godot_array_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArraySet(System.IntPtr,System.Int32,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_set),",
            "                                                       godot_array_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayAdd(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_add),",
            "                                                       godot_array_add_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayInsert(System.IntPtr,System.Int32,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_insert),",
            "                                                       godot_array_insert_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayRemoveAt(System.IntPtr,System.Int32)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_removeat),",
            "                                                       godot_array_removeat_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_clear),",
            "                                                       godot_array_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayContains(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_contains),",
            "                                                       godot_array_contains_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotArrayIndexOf(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_array_indexof),",
            "                                                       godot_array_indexof_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryCreate()\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_create),",
            "                                                       godot_dictionary_create_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionarySize(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_size),",
            "                                                       godot_dictionary_size_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryContainsKey(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_containskey),",
            "                                                       godot_dictionary_containskey_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryGet(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_get),",
            "                                                       godot_dictionary_get_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionarySet(System.IntPtr,Godot.Variant,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_set),",
            "                                                       godot_dictionary_set_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryRemove(System.IntPtr,Godot.Variant)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_remove),",
            "                                                       godot_dictionary_remove_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryClear(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_clear),",
            "                                                       godot_dictionary_clear_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryKeys(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_keys),",
            "                                                       godot_dictionary_keys_invoker);",
            "    leanclr::vm::InternalCalls::register_internal_call(\"Godot.NativeCalls::GodotDictionaryValues(System.IntPtr)\",",
            "                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&godot_dictionary_values),",
            "                                                       godot_dictionary_values_invoker);",
        ]
    )
    for method in methods:
        fn = native_function_name(method)
        body.extend(
            [
                f"    leanclr::vm::InternalCalls::register_internal_call(\"{icall_name(method)}\",",
                f"                                                       reinterpret_cast<leanclr::vm::InternalCallFunction>(&{fn}),",
                f"                                                       {fn}_invoker);",
            ]
        )
    body.extend(["}", "", "} // namespace godot", ""])
    write(src_dir / "generated" / "godot_api.generated.cpp", "\n".join(body))


def generate_report(report, report_path):
    report_path.parent.mkdir(parents=True, exist_ok=True)
    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def generate_summary_report(report, report_path):
    overview = report["overview"]
    top_types = sorted(report["unsupported_type_counts"].items(), key=lambda item: item[1], reverse=True)[:20]
    top_classes = sorted(
        (row for row in report["per_class"] if row["methods_generated"]),
        key=lambda row: row["methods_generated"],
        reverse=True,
    )[:20]
    lines = [
        "# LeanCLR Godot Binding Statistics",
        "",
        "## Overview",
        "",
        f"- API classes: {overview['api_class_count']}",
        f"- Generated C# skeleton classes: {overview['skeleton_class_count']} ({overview['class_skeleton_coverage_pct']}%)",
        f"- Native-bound classes with generated methods: {overview['native_bound_class_count']} ({overview['native_class_coverage_pct']}%)",
        f"- API methods: {overview['total_methods']}",
        f"- Generated methods: {overview['generated_methods']} ({overview['method_coverage_pct']}%)",
        f"- Generated native methods: {overview['generated_native_methods']}",
        f"- Generated vararg bridges: {overview['generated_vararg_bridges']}",
        f"- Generated virtual stubs: {overview['generated_virtual_stubs']}",
        f"- Skipped methods: {overview['skipped_methods']}",
        "",
        "## Skip Breakdown",
        "",
    ]
    for reason, count in sorted(report["skipped_methods"].items(), key=lambda item: item[1], reverse=True):
        lines.append(f"- {reason}: {count}")
    lines.extend(["", "## Top Unsupported Types", ""])
    for raw_type, count in top_types:
        lines.append(f"- {raw_type}: {count}")
    lines.extend(["", "## Top Generated Classes", ""])
    for row in top_classes:
        lines.append(f"- {row['class_name']}: {row['methods_generated']}/{row['methods_total']} ({row['coverage_pct']}%)")
    lines.append("")
    write(report_path, "\n".join(lines))


def main():
    parser = argparse.ArgumentParser(description="Generate minimal LeanCLR Godot bindings.")
    parser.add_argument("--api", default="extension_api.json")
    parser.add_argument("--managed-dir", default="managed/GodotSharpCompat")
    parser.add_argument("--src-dir", default="src")
    parser.add_argument("--report", default="tools/binding_generator/unsupported_api_report.json")
    parser.add_argument("--summary-report", default="tools/binding_generator/binding_statistics_report.md")
    args = parser.parse_args()

    with open(args.api, "r", encoding="utf-8") as file:
        api = json.load(file)
    classes, class_order, global_enums, methods, report = build_model(api)
    generate_managed(classes, class_order, global_enums, api.get("builtin_classes", []), methods, Path(args.managed_dir))
    generate_native(classes, methods, Path(args.src_dir))
    generate_report(report, Path(args.report))
    generate_summary_report(report, Path(args.summary_report))


if __name__ == "__main__":
    main()