gdnative binding

gdnative.odin

package gdnative

import _c "core:c"

Int :: _c.int;
Real :: _c.float;
Bool :: _c.bool;
Object :: rawptr;
ClassConstructor :: #type proc "c" () -> rawptr;
GdnativeInitFn :: #type proc "c" (unamed0 : ^GdnativeInitOptions);
GdnativeTerminateFn :: #type proc "c" (unamed0 : ^GdnativeTerminateOptions);
GdnativeProcedureFn :: #type proc "c" (unamed0 : ^Array) -> Variant;
NativeCallCb :: #type proc "c" (unamed0 : rawptr, unamed1 : ^Array) -> Variant;
PoolByteArrayReadAccess :: PoolArrayReadAccess;
PoolIntArrayReadAccess :: PoolArrayReadAccess;
PoolRealArrayReadAccess :: PoolArrayReadAccess;
PoolStringArrayReadAccess :: PoolArrayReadAccess;
PoolVector2ArrayReadAccess :: PoolArrayReadAccess;
PoolVector3ArrayReadAccess :: PoolArrayReadAccess;
PoolColorArrayReadAccess :: PoolArrayReadAccess;
PoolByteArrayWriteAccess :: PoolArrayWriteAccess;
PoolIntArrayWriteAccess :: PoolArrayWriteAccess;
PoolRealArrayWriteAccess :: PoolArrayWriteAccess;
PoolStringArrayWriteAccess :: PoolArrayWriteAccess;
PoolVector2ArrayWriteAccess :: PoolArrayWriteAccess;
PoolVector3ArrayWriteAccess :: PoolArrayWriteAccess;
PoolColorArrayWriteAccess :: PoolArrayWriteAccess;
CharType :: _c.wchar_t;
PluginscriptInstanceData :: rawptr;
PluginscriptScriptData :: rawptr;
PluginscriptLanguageData :: rawptr;
GdNativeAudioMixCallback :: #type proc "c" (unamed0 : rawptr, unamed1 : ^_c.float, unamed2 : _c.int) -> _c.int;

Error :: enum i32 {
    Ok,
    Failed,
    ErrUnavailable,
    ErrUnconfigured,
    ErrUnauthorized,
    ErrParameterRangeError,
    ErrOutOfMemory,
    ErrFileNotFound,
    ErrFileBadDrive,
    ErrFileBadPath,
    ErrFileNoPermission,
    ErrFileAlreadyInUse,
    ErrFileCantOpen,
    ErrFileCantWrite,
    ErrFileCantRead,
    ErrFileUnrecognized,
    ErrFileCorrupt,
    ErrFileMissingDependencies,
    ErrFileEof,
    ErrCantOpen,
    ErrCantCreate,
    ErrQueryFailed,
    ErrAlreadyInUse,
    ErrLocked,
    ErrTimeout,
    ErrCantConnect,
    ErrCantResolve,
    ErrConnectionError,
    ErrCantAcquireResource,
    ErrCantFork,
    ErrInvalidData,
    ErrInvalidParameter,
    ErrAlreadyExists,
    ErrDoesNotExist,
    ErrDatabaseCantRead,
    ErrDatabaseCantWrite,
    ErrCompilationFailed,
    ErrMethodNotFound,
    ErrLinkFailed,
    ErrScriptFailed,
    ErrCyclicLink,
    ErrInvalidDeclaration,
    ErrDuplicateSymbol,
    ErrParseError,
    ErrBusy,
    ErrSkip,
    ErrHelp,
    ErrBug,
    ErrPrinterOnFire,
};

VariantType :: enum i32 {
    Nil,
    Bool,
    Int,
    Real,
    String,
    Vector2,
    Rect2,
    Vector3,
    Transform2D,
    Plane,
    Quat,
    Aabb,
    Basis,
    Transform,
    Color,
    NodePath,
    Rid,
    Object,
    Dictionary,
    Array,
    PoolByteArray,
    PoolIntArray,
    PoolRealArray,
    PoolStringArray,
    PoolVector2Array,
    PoolVector3Array,
    PoolColorArray,
};

VariantCallErrorError :: enum i32 {
    CallErrorCallOk,
    CallErrorCallErrorInvalidMethod,
    CallErrorCallErrorInvalidArgument,
    CallErrorCallErrorTooManyArguments,
    CallErrorCallErrorTooFewArguments,
    CallErrorCallErrorInstanceIsNull,
};

VariantOperator :: enum i32 {
    VariantOpEqual,
    VariantOpNotEqual,
    VariantOpLess,
    VariantOpLessEqual,
    VariantOpGreater,
    VariantOpGreaterEqual,
    VariantOpAdd,
    VariantOpSubtract,
    VariantOpMultiply,
    VariantOpDivide,
    VariantOpNegate,
    VariantOpPositive,
    VariantOpModule,
    VariantOpStringConcat,
    VariantOpShiftLeft,
    VariantOpShiftRight,
    VariantOpBitAnd,
    VariantOpBitOr,
    VariantOpBitXor,
    VariantOpBitNegate,
    VariantOpAnd,
    VariantOpOr,
    VariantOpXor,
    VariantOpNot,
    VariantOpIn,
    VariantOpMax,
};

Vector3Axis :: enum i32 {
    X,
    Y,
    Z,
};

GdnativeApiTypes :: enum _c.int {
    GdnativeCore,
    GdnativeExtNativescript,
    GdnativeExtPluginscript,
    GdnativeExtAndroid,
    GdnativeExtArvr,
    GdnativeExtVideodecoder,
    GdnativeExtNet,
};

MethodRpcMode :: enum i32 {
    Disabled,
    Remote,
    Master,
    Puppet,
    Slave = 3,
    Remotesync,
    Sync = 4,
    Mastersync,
    Puppetsync,
};

PropertyHint :: enum i32 {
    None,
    Range,
    ExpRange,
    Enum,
    ExpEasing,
    Length,
    SpriteFrame,
    KeyAccel,
    Flags,
    Layers2DRender,
    Layers2DPhysics,
    Layers3DRender,
    Layers3DPhysics,
    File,
    Dir,
    GlobalFile,
    GlobalDir,
    ResourceType,
    MultilineText,
    PlaceholderText,
    ColorNoAlpha,
    ImageCompressLossy,
    ImageCompressLossless,
    ObjectId,
    TypeString,
    NodePathToEditedNode,
    MethodOfVariantType,
    MethodOfBaseType,
    MethodOfInstance,
    MethodOfScript,
    PropertyOfVariantType,
    PropertyOfBaseType,
    PropertyOfInstance,
    PropertyOfScript,
    Max,
};

PropertyUsageFlags :: enum i32 {
    PropertyUsageStorage = 1,
    PropertyUsageEditor = 2,
    PropertyUsageNetwork = 4,
    PropertyUsageEditorHelper = 8,
    PropertyUsageCheckable = 16,
    PropertyUsageChecked = 32,
    PropertyUsageInternationalized = 64,
    PropertyUsageGroup = 128,
    PropertyUsageCategory = 256,
    PropertyUsageStoreIfNonzero = 512,
    PropertyUsageStoreIfNonone = 1024,
    PropertyUsageNoInstanceState = 2048,
    PropertyUsageRestartIfChanged = 4096,
    PropertyUsageScriptVariable = 8192,
    PropertyUsageStoreIfNull = 16384,
    PropertyUsageAnimateAsTrigger = 32768,
    PropertyUsageUpdateAllIfModified = 65536,
    PropertyUsageDefault = 1,
    PropertyUsageDefaultIntl = 1,
    PropertyUsageNoeditor = 1,
};

ArvrInterfaceGdnative :: struct {
    version : GdnativeApiVersion,
    constructor : #type proc "c" (unamed0 : ^Object) -> rawptr,
    destructor : #type proc "c" (unamed0 : rawptr),
    get_name : #type proc "c" (unamed0 : rawptr) -> String,
    get_capabilities : #type proc "c" (unamed0 : rawptr) -> Int,
    get_anchor_detection_is_enabled : #type proc "c" (unamed0 : rawptr) -> Bool,
    set_anchor_detection_is_enabled : #type proc "c" (unamed0 : rawptr, unamed1 : Bool),
    is_stereo : #type proc "c" (unamed0 : rawptr) -> Bool,
    is_initialized : #type proc "c" (unamed0 : rawptr) -> Bool,
    initialize : #type proc "c" (unamed0 : rawptr) -> Bool,
    uninitialize : #type proc "c" (unamed0 : rawptr),
    get_render_targetsize : #type proc "c" (unamed0 : rawptr) -> Vector2,
    get_transform_for_eye : #type proc "c" (unamed0 : rawptr, unamed1 : Int, unamed2 : ^Transform) -> Transform,
    fill_projection_for_eye : #type proc "c" (unamed0 : rawptr, unamed1 : ^Real, unamed2 : Int, unamed3 : Real, unamed4 : Real, unamed5 : Real),
    commit_for_eye : #type proc "c" (unamed0 : rawptr, unamed1 : Int, unamed2 : ^Rid, unamed3 : ^Rect2),
    process : #type proc "c" (unamed0 : rawptr),
    get_external_texture_for_eye : #type proc "c" (unamed0 : rawptr, unamed1 : Int) -> Int,
    notification : #type proc "c" (unamed0 : rawptr, unamed1 : Int),
    get_camera_feed_id : #type proc "c" (unamed0 : rawptr) -> Int,
    get_external_depth_for_eye : #type proc "c" (unamed0 : rawptr, unamed1 : Int) -> Int,
};

Aabb :: struct {
    dont_touch_that : [24]u8,
};

Array :: struct {
    dont_touch_that : [1]u8,
};

Basis :: struct {
    dont_touch_that : [36]u8,
};

Color :: struct {
    dont_touch_that : [16]u8,
};

Dictionary :: struct {
    dont_touch_that : [1]u8,
};

MethodBind :: struct {
    dont_touch_that : [1]u8,
};

GdnativeApiVersion :: struct {
    major : _c.uint,
    minor : _c.uint,
};

GdnativeApiStruct :: struct {
    type : GdnativeApiTypes,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
};

GdnativeApiStructUnion :: struct #raw_union {
    api_struct: GdnativeApiStruct,
    ext_nativescript_api_struct: GdnativeExtNativescriptApiStruct,
}

GdnativeCoreApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    num_extensions : _c.uint,
    extensions : ^^GdnativeApiStruct,
    godot_color_new_rgba : #type proc "c" (r_dest : ^Color, p_r : _c.float, p_g : _c.float, p_b : _c.float, p_a : _c.float),
    godot_color_new_rgb : #type proc "c" (r_dest : ^Color, p_r : _c.float, p_g : _c.float, p_b : _c.float),
    godot_color_get_r : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_set_r : #type proc "c" (p_self : ^Color, r : _c.float),
    godot_color_get_g : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_set_g : #type proc "c" (p_self : ^Color, g : _c.float),
    godot_color_get_b : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_set_b : #type proc "c" (p_self : ^Color, b : _c.float),
    godot_color_get_a : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_set_a : #type proc "c" (p_self : ^Color, a : _c.float),
    godot_color_get_h : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_get_s : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_get_v : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_as_string : #type proc "c" (p_self : ^Color) -> String,
    godot_color_to_rgba32 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_to_argb32 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_gray : #type proc "c" (p_self : ^Color) -> _c.float,
    godot_color_inverted : #type proc "c" (p_self : ^Color) -> Color,
    godot_color_contrasted : #type proc "c" (p_self : ^Color) -> Color,
    godot_color_linear_interpolate : #type proc "c" (p_self : ^Color, p_b : ^Color, p_t : _c.float) -> Color,
    godot_color_blend : #type proc "c" (p_self : ^Color, p_over : ^Color) -> Color,
    godot_color_to_html : #type proc "c" (p_self : ^Color, p_with_alpha : Bool) -> String,
    godot_color_operator_equal : #type proc "c" (p_self : ^Color, p_b : ^Color) -> Bool,
    godot_color_operator_less : #type proc "c" (p_self : ^Color, p_b : ^Color) -> Bool,
    godot_vector2_new : #type proc "c" (r_dest : ^Vector2, p_x : _c.float, p_y : _c.float),
    godot_vector2_as_string : #type proc "c" (p_self : ^Vector2) -> String,
    godot_vector2_normalized : #type proc "c" (p_self : ^Vector2) -> Vector2,
    godot_vector2_length : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_vector2_angle : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_vector2_length_squared : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_vector2_is_normalized : #type proc "c" (p_self : ^Vector2) -> Bool,
    godot_vector2_distance_to : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2) -> _c.float,
    godot_vector2_distance_squared_to : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2) -> _c.float,
    godot_vector2_angle_to : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2) -> _c.float,
    godot_vector2_angle_to_point : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2) -> _c.float,
    godot_vector2_linear_interpolate : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2, p_t : _c.float) -> Vector2,
    godot_vector2_cubic_interpolate : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2, p_pre_a : ^Vector2, p_post_b : ^Vector2, p_t : _c.float) -> Vector2,
    godot_vector2_rotated : #type proc "c" (p_self : ^Vector2, p_phi : _c.float) -> Vector2,
    godot_vector2_tangent : #type proc "c" (p_self : ^Vector2) -> Vector2,
    godot_vector2_floor : #type proc "c" (p_self : ^Vector2) -> Vector2,
    godot_vector2_snapped : #type proc "c" (p_self : ^Vector2, p_by : ^Vector2) -> Vector2,
    godot_vector2_aspect : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_vector2_dot : #type proc "c" (p_self : ^Vector2, p_with : ^Vector2) -> _c.float,
    godot_vector2_slide : #type proc "c" (p_self : ^Vector2, p_n : ^Vector2) -> Vector2,
    godot_vector2_bounce : #type proc "c" (p_self : ^Vector2, p_n : ^Vector2) -> Vector2,
    godot_vector2_reflect : #type proc "c" (p_self : ^Vector2, p_n : ^Vector2) -> Vector2,
    godot_vector2_abs : #type proc "c" (p_self : ^Vector2) -> Vector2,
    godot_vector2_clamped : #type proc "c" (p_self : ^Vector2, p_length : _c.float) -> Vector2,
    godot_vector2_operator_add : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Vector2,
    godot_vector2_operator_subtract : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Vector2,
    godot_vector2_operator_multiply_vector : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Vector2,
    godot_vector2_operator_multiply_scalar : #type proc "c" (p_self : ^Vector2, p_b : _c.float) -> Vector2,
    godot_vector2_operator_divide_vector : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Vector2,
    godot_vector2_operator_divide_scalar : #type proc "c" (p_self : ^Vector2, p_b : _c.float) -> Vector2,
    godot_vector2_operator_equal : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Bool,
    godot_vector2_operator_less : #type proc "c" (p_self : ^Vector2, p_b : ^Vector2) -> Bool,
    godot_vector2_operator_neg : #type proc "c" (p_self : ^Vector2) -> Vector2,
    godot_vector2_set_x : #type proc "c" (p_self : ^Vector2, p_x : _c.float),
    godot_vector2_set_y : #type proc "c" (p_self : ^Vector2, p_y : _c.float),
    godot_vector2_get_x : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_vector2_get_y : #type proc "c" (p_self : ^Vector2) -> _c.float,
    godot_quat_new : #type proc "c" (r_dest : ^Quat, p_x : _c.float, p_y : _c.float, p_z : _c.float, p_w : _c.float),
    godot_quat_new_with_axis_angle : #type proc "c" (r_dest : ^Quat, p_axis : ^Vector3, p_angle : _c.float),
    godot_quat_get_x : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_set_x : #type proc "c" (p_self : ^Quat, val : _c.float),
    godot_quat_get_y : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_set_y : #type proc "c" (p_self : ^Quat, val : _c.float),
    godot_quat_get_z : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_set_z : #type proc "c" (p_self : ^Quat, val : _c.float),
    godot_quat_get_w : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_set_w : #type proc "c" (p_self : ^Quat, val : _c.float),
    godot_quat_as_string : #type proc "c" (p_self : ^Quat) -> String,
    godot_quat_length : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_length_squared : #type proc "c" (p_self : ^Quat) -> _c.float,
    godot_quat_normalized : #type proc "c" (p_self : ^Quat) -> Quat,
    godot_quat_is_normalized : #type proc "c" (p_self : ^Quat) -> Bool,
    godot_quat_inverse : #type proc "c" (p_self : ^Quat) -> Quat,
    godot_quat_dot : #type proc "c" (p_self : ^Quat, p_b : ^Quat) -> _c.float,
    godot_quat_xform : #type proc "c" (p_self : ^Quat, p_v : ^Vector3) -> Vector3,
    godot_quat_slerp : #type proc "c" (p_self : ^Quat, p_b : ^Quat, p_t : _c.float) -> Quat,
    godot_quat_slerpni : #type proc "c" (p_self : ^Quat, p_b : ^Quat, p_t : _c.float) -> Quat,
    godot_quat_cubic_slerp : #type proc "c" (p_self : ^Quat, p_b : ^Quat, p_pre_a : ^Quat, p_post_b : ^Quat, p_t : _c.float) -> Quat,
    godot_quat_operator_multiply : #type proc "c" (p_self : ^Quat, p_b : _c.float) -> Quat,
    godot_quat_operator_add : #type proc "c" (p_self : ^Quat, p_b : ^Quat) -> Quat,
    godot_quat_operator_subtract : #type proc "c" (p_self : ^Quat, p_b : ^Quat) -> Quat,
    godot_quat_operator_divide : #type proc "c" (p_self : ^Quat, p_b : _c.float) -> Quat,
    godot_quat_operator_equal : #type proc "c" (p_self : ^Quat, p_b : ^Quat) -> Bool,
    godot_quat_operator_neg : #type proc "c" (p_self : ^Quat) -> Quat,
    godot_basis_new_with_rows : #type proc "c" (r_dest : ^Basis, p_x_axis : ^Vector3, p_y_axis : ^Vector3, p_z_axis : ^Vector3),
    godot_basis_new_with_axis_and_angle : #type proc "c" (r_dest : ^Basis, p_axis : ^Vector3, p_phi : _c.float),
    godot_basis_new_with_euler : #type proc "c" (r_dest : ^Basis, p_euler : ^Vector3),
    godot_basis_as_string : #type proc "c" (p_self : ^Basis) -> String,
    godot_basis_inverse : #type proc "c" (p_self : ^Basis) -> Basis,
    godot_basis_transposed : #type proc "c" (p_self : ^Basis) -> Basis,
    godot_basis_orthonormalized : #type proc "c" (p_self : ^Basis) -> Basis,
    godot_basis_determinant : #type proc "c" (p_self : ^Basis) -> _c.float,
    godot_basis_rotated : #type proc "c" (p_self : ^Basis, p_axis : ^Vector3, p_phi : _c.float) -> Basis,
    godot_basis_scaled : #type proc "c" (p_self : ^Basis, p_scale : ^Vector3) -> Basis,
    godot_basis_get_scale : #type proc "c" (p_self : ^Basis) -> Vector3,
    godot_basis_get_euler : #type proc "c" (p_self : ^Basis) -> Vector3,
    godot_basis_tdotx : #type proc "c" (p_self : ^Basis, p_with : ^Vector3) -> _c.float,
    godot_basis_tdoty : #type proc "c" (p_self : ^Basis, p_with : ^Vector3) -> _c.float,
    godot_basis_tdotz : #type proc "c" (p_self : ^Basis, p_with : ^Vector3) -> _c.float,
    godot_basis_xform : #type proc "c" (p_self : ^Basis, p_v : ^Vector3) -> Vector3,
    godot_basis_xform_inv : #type proc "c" (p_self : ^Basis, p_v : ^Vector3) -> Vector3,
    godot_basis_get_orthogonal_index : #type proc "c" (p_self : ^Basis) -> _c.int,
    godot_basis_new : #type proc "c" (r_dest : ^Basis),
    godot_basis_new_with_euler_quat : #type proc "c" (r_dest : ^Basis, p_euler : ^Quat),
    godot_basis_get_elements : #type proc "c" (p_self : ^Basis, p_elements : ^Vector3),
    godot_basis_get_axis : #type proc "c" (p_self : ^Basis, p_axis : _c.int) -> Vector3,
    godot_basis_set_axis : #type proc "c" (p_self : ^Basis, p_axis : _c.int, p_value : ^Vector3),
    godot_basis_get_row : #type proc "c" (p_self : ^Basis, p_row : _c.int) -> Vector3,
    godot_basis_set_row : #type proc "c" (p_self : ^Basis, p_row : _c.int, p_value : ^Vector3),
    godot_basis_operator_equal : #type proc "c" (p_self : ^Basis, p_b : ^Basis) -> Bool,
    godot_basis_operator_add : #type proc "c" (p_self : ^Basis, p_b : ^Basis) -> Basis,
    godot_basis_operator_subtract : #type proc "c" (p_self : ^Basis, p_b : ^Basis) -> Basis,
    godot_basis_operator_multiply_vector : #type proc "c" (p_self : ^Basis, p_b : ^Basis) -> Basis,
    godot_basis_operator_multiply_scalar : #type proc "c" (p_self : ^Basis, p_b : _c.float) -> Basis,
    godot_vector3_new : #type proc "c" (r_dest : ^Vector3, p_x : _c.float, p_y : _c.float, p_z : _c.float),
    godot_vector3_as_string : #type proc "c" (p_self : ^Vector3) -> String,
    godot_vector3_min_axis : #type proc "c" (p_self : ^Vector3) -> _c.int,
    godot_vector3_max_axis : #type proc "c" (p_self : ^Vector3) -> _c.int,
    godot_vector3_length : #type proc "c" (p_self : ^Vector3) -> _c.float,
    godot_vector3_length_squared : #type proc "c" (p_self : ^Vector3) -> _c.float,
    godot_vector3_is_normalized : #type proc "c" (p_self : ^Vector3) -> Bool,
    godot_vector3_normalized : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_inverse : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_snapped : #type proc "c" (p_self : ^Vector3, p_by : ^Vector3) -> Vector3,
    godot_vector3_rotated : #type proc "c" (p_self : ^Vector3, p_axis : ^Vector3, p_phi : _c.float) -> Vector3,
    godot_vector3_linear_interpolate : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3, p_t : _c.float) -> Vector3,
    godot_vector3_cubic_interpolate : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3, p_pre_a : ^Vector3, p_post_b : ^Vector3, p_t : _c.float) -> Vector3,
    godot_vector3_dot : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> _c.float,
    godot_vector3_cross : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Vector3,
    godot_vector3_outer : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Basis,
    godot_vector3_to_diagonal_matrix : #type proc "c" (p_self : ^Vector3) -> Basis,
    godot_vector3_abs : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_floor : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_ceil : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_distance_to : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> _c.float,
    godot_vector3_distance_squared_to : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> _c.float,
    godot_vector3_angle_to : #type proc "c" (p_self : ^Vector3, p_to : ^Vector3) -> _c.float,
    godot_vector3_slide : #type proc "c" (p_self : ^Vector3, p_n : ^Vector3) -> Vector3,
    godot_vector3_bounce : #type proc "c" (p_self : ^Vector3, p_n : ^Vector3) -> Vector3,
    godot_vector3_reflect : #type proc "c" (p_self : ^Vector3, p_n : ^Vector3) -> Vector3,
    godot_vector3_operator_add : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Vector3,
    godot_vector3_operator_subtract : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Vector3,
    godot_vector3_operator_multiply_vector : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Vector3,
    godot_vector3_operator_multiply_scalar : #type proc "c" (p_self : ^Vector3, p_b : _c.float) -> Vector3,
    godot_vector3_operator_divide_vector : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Vector3,
    godot_vector3_operator_divide_scalar : #type proc "c" (p_self : ^Vector3, p_b : _c.float) -> Vector3,
    godot_vector3_operator_equal : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Bool,
    godot_vector3_operator_less : #type proc "c" (p_self : ^Vector3, p_b : ^Vector3) -> Bool,
    godot_vector3_operator_neg : #type proc "c" (p_self : ^Vector3) -> Vector3,
    godot_vector3_set_axis : #type proc "c" (p_self : ^Vector3, p_axis : Vector3Axis, p_val : _c.float),
    godot_vector3_get_axis : #type proc "c" (p_self : ^Vector3, p_axis : Vector3Axis) -> _c.float,
    godot_pool_byte_array_new : #type proc "c" (r_dest : ^PoolByteArray),
    godot_pool_byte_array_new_copy : #type proc "c" (r_dest : ^PoolByteArray, p_src : ^PoolByteArray),
    godot_pool_byte_array_new_with_array : #type proc "c" (r_dest : ^PoolByteArray, p_a : ^Array),
    godot_pool_byte_array_append : #type proc "c" (p_self : ^PoolByteArray, p_data : u8),
    godot_pool_byte_array_append_array : #type proc "c" (p_self : ^PoolByteArray, p_array : ^PoolByteArray),
    godot_pool_byte_array_insert : #type proc "c" (p_self : ^PoolByteArray, p_idx : _c.int, p_data : u8) -> Error,
    godot_pool_byte_array_invert : #type proc "c" (p_self : ^PoolByteArray),
    godot_pool_byte_array_push_back : #type proc "c" (p_self : ^PoolByteArray, p_data : u8),
    godot_pool_byte_array_remove : #type proc "c" (p_self : ^PoolByteArray, p_idx : _c.int),
    godot_pool_byte_array_resize : #type proc "c" (p_self : ^PoolByteArray, p_size : _c.int),
    godot_pool_byte_array_read : #type proc "c" (p_self : ^PoolByteArray) -> ^PoolByteArrayReadAccess,
    godot_pool_byte_array_write : #type proc "c" (p_self : ^PoolByteArray) -> ^PoolByteArrayWriteAccess,
    godot_pool_byte_array_set : #type proc "c" (p_self : ^PoolByteArray, p_idx : _c.int, p_data : u8),
    godot_pool_byte_array_get : #type proc "c" (p_self : ^PoolByteArray, p_idx : _c.int) -> u8,
    godot_pool_byte_array_size : #type proc "c" (p_self : ^PoolByteArray) -> _c.int,
    godot_pool_byte_array_destroy : #type proc "c" (p_self : ^PoolByteArray),
    godot_pool_int_array_new : #type proc "c" (r_dest : ^PoolIntArray),
    godot_pool_int_array_new_copy : #type proc "c" (r_dest : ^PoolIntArray, p_src : ^PoolIntArray),
    godot_pool_int_array_new_with_array : #type proc "c" (r_dest : ^PoolIntArray, p_a : ^Array),
    godot_pool_int_array_append : #type proc "c" (p_self : ^PoolIntArray, p_data : _c.int),
    godot_pool_int_array_append_array : #type proc "c" (p_self : ^PoolIntArray, p_array : ^PoolIntArray),
    godot_pool_int_array_insert : #type proc "c" (p_self : ^PoolIntArray, p_idx : _c.int, p_data : _c.int) -> Error,
    godot_pool_int_array_invert : #type proc "c" (p_self : ^PoolIntArray),
    godot_pool_int_array_push_back : #type proc "c" (p_self : ^PoolIntArray, p_data : _c.int),
    godot_pool_int_array_remove : #type proc "c" (p_self : ^PoolIntArray, p_idx : _c.int),
    godot_pool_int_array_resize : #type proc "c" (p_self : ^PoolIntArray, p_size : _c.int),
    godot_pool_int_array_read : #type proc "c" (p_self : ^PoolIntArray) -> ^PoolIntArrayReadAccess,
    godot_pool_int_array_write : #type proc "c" (p_self : ^PoolIntArray) -> ^PoolIntArrayWriteAccess,
    godot_pool_int_array_set : #type proc "c" (p_self : ^PoolIntArray, p_idx : _c.int, p_data : _c.int),
    godot_pool_int_array_get : #type proc "c" (p_self : ^PoolIntArray, p_idx : _c.int) -> _c.int,
    godot_pool_int_array_size : #type proc "c" (p_self : ^PoolIntArray) -> _c.int,
    godot_pool_int_array_destroy : #type proc "c" (p_self : ^PoolIntArray),
    godot_pool_real_array_new : #type proc "c" (r_dest : ^PoolRealArray),
    godot_pool_real_array_new_copy : #type proc "c" (r_dest : ^PoolRealArray, p_src : ^PoolRealArray),
    godot_pool_real_array_new_with_array : #type proc "c" (r_dest : ^PoolRealArray, p_a : ^Array),
    godot_pool_real_array_append : #type proc "c" (p_self : ^PoolRealArray, p_data : _c.float),
    godot_pool_real_array_append_array : #type proc "c" (p_self : ^PoolRealArray, p_array : ^PoolRealArray),
    godot_pool_real_array_insert : #type proc "c" (p_self : ^PoolRealArray, p_idx : _c.int, p_data : _c.float) -> Error,
    godot_pool_real_array_invert : #type proc "c" (p_self : ^PoolRealArray),
    godot_pool_real_array_push_back : #type proc "c" (p_self : ^PoolRealArray, p_data : _c.float),
    godot_pool_real_array_remove : #type proc "c" (p_self : ^PoolRealArray, p_idx : _c.int),
    godot_pool_real_array_resize : #type proc "c" (p_self : ^PoolRealArray, p_size : _c.int),
    godot_pool_real_array_read : #type proc "c" (p_self : ^PoolRealArray) -> ^PoolRealArrayReadAccess,
    godot_pool_real_array_write : #type proc "c" (p_self : ^PoolRealArray) -> ^PoolRealArrayWriteAccess,
    godot_pool_real_array_set : #type proc "c" (p_self : ^PoolRealArray, p_idx : _c.int, p_data : _c.float),
    godot_pool_real_array_get : #type proc "c" (p_self : ^PoolRealArray, p_idx : _c.int) -> _c.float,
    godot_pool_real_array_size : #type proc "c" (p_self : ^PoolRealArray) -> _c.int,
    godot_pool_real_array_destroy : #type proc "c" (p_self : ^PoolRealArray),
    godot_pool_string_array_new : #type proc "c" (r_dest : ^PoolStringArray),
    godot_pool_string_array_new_copy : #type proc "c" (r_dest : ^PoolStringArray, p_src : ^PoolStringArray),
    godot_pool_string_array_new_with_array : #type proc "c" (r_dest : ^PoolStringArray, p_a : ^Array),
    godot_pool_string_array_append : #type proc "c" (p_self : ^PoolStringArray, p_data : ^String),
    godot_pool_string_array_append_array : #type proc "c" (p_self : ^PoolStringArray, p_array : ^PoolStringArray),
    godot_pool_string_array_insert : #type proc "c" (p_self : ^PoolStringArray, p_idx : _c.int, p_data : ^String) -> Error,
    godot_pool_string_array_invert : #type proc "c" (p_self : ^PoolStringArray),
    godot_pool_string_array_push_back : #type proc "c" (p_self : ^PoolStringArray, p_data : ^String),
    godot_pool_string_array_remove : #type proc "c" (p_self : ^PoolStringArray, p_idx : _c.int),
    godot_pool_string_array_resize : #type proc "c" (p_self : ^PoolStringArray, p_size : _c.int),
    godot_pool_string_array_read : #type proc "c" (p_self : ^PoolStringArray) -> ^PoolStringArrayReadAccess,
    godot_pool_string_array_write : #type proc "c" (p_self : ^PoolStringArray) -> ^PoolStringArrayWriteAccess,
    godot_pool_string_array_set : #type proc "c" (p_self : ^PoolStringArray, p_idx : _c.int, p_data : ^String),
    godot_pool_string_array_get : #type proc "c" (p_self : ^PoolStringArray, p_idx : _c.int) -> String,
    godot_pool_string_array_size : #type proc "c" (p_self : ^PoolStringArray) -> _c.int,
    godot_pool_string_array_destroy : #type proc "c" (p_self : ^PoolStringArray),
    godot_pool_vector2_array_new : #type proc "c" (r_dest : ^PoolVector2Array),
    godot_pool_vector2_array_new_copy : #type proc "c" (r_dest : ^PoolVector2Array, p_src : ^PoolVector2Array),
    godot_pool_vector2_array_new_with_array : #type proc "c" (r_dest : ^PoolVector2Array, p_a : ^Array),
    godot_pool_vector2_array_append : #type proc "c" (p_self : ^PoolVector2Array, p_data : ^Vector2),
    godot_pool_vector2_array_append_array : #type proc "c" (p_self : ^PoolVector2Array, p_array : ^PoolVector2Array),
    godot_pool_vector2_array_insert : #type proc "c" (p_self : ^PoolVector2Array, p_idx : _c.int, p_data : ^Vector2) -> Error,
    godot_pool_vector2_array_invert : #type proc "c" (p_self : ^PoolVector2Array),
    godot_pool_vector2_array_push_back : #type proc "c" (p_self : ^PoolVector2Array, p_data : ^Vector2),
    godot_pool_vector2_array_remove : #type proc "c" (p_self : ^PoolVector2Array, p_idx : _c.int),
    godot_pool_vector2_array_resize : #type proc "c" (p_self : ^PoolVector2Array, p_size : _c.int),
    godot_pool_vector2_array_read : #type proc "c" (p_self : ^PoolVector2Array) -> ^PoolVector2ArrayReadAccess,
    godot_pool_vector2_array_write : #type proc "c" (p_self : ^PoolVector2Array) -> ^PoolVector2ArrayWriteAccess,
    godot_pool_vector2_array_set : #type proc "c" (p_self : ^PoolVector2Array, p_idx : _c.int, p_data : ^Vector2),
    godot_pool_vector2_array_get : #type proc "c" (p_self : ^PoolVector2Array, p_idx : _c.int) -> Vector2,
    godot_pool_vector2_array_size : #type proc "c" (p_self : ^PoolVector2Array) -> _c.int,
    godot_pool_vector2_array_destroy : #type proc "c" (p_self : ^PoolVector2Array),
    godot_pool_vector3_array_new : #type proc "c" (r_dest : ^PoolVector3Array),
    godot_pool_vector3_array_new_copy : #type proc "c" (r_dest : ^PoolVector3Array, p_src : ^PoolVector3Array),
    godot_pool_vector3_array_new_with_array : #type proc "c" (r_dest : ^PoolVector3Array, p_a : ^Array),
    godot_pool_vector3_array_append : #type proc "c" (p_self : ^PoolVector3Array, p_data : ^Vector3),
    godot_pool_vector3_array_append_array : #type proc "c" (p_self : ^PoolVector3Array, p_array : ^PoolVector3Array),
    godot_pool_vector3_array_insert : #type proc "c" (p_self : ^PoolVector3Array, p_idx : _c.int, p_data : ^Vector3) -> Error,
    godot_pool_vector3_array_invert : #type proc "c" (p_self : ^PoolVector3Array),
    godot_pool_vector3_array_push_back : #type proc "c" (p_self : ^PoolVector3Array, p_data : ^Vector3),
    godot_pool_vector3_array_remove : #type proc "c" (p_self : ^PoolVector3Array, p_idx : _c.int),
    godot_pool_vector3_array_resize : #type proc "c" (p_self : ^PoolVector3Array, p_size : _c.int),
    godot_pool_vector3_array_read : #type proc "c" (p_self : ^PoolVector3Array) -> ^PoolVector3ArrayReadAccess,
    godot_pool_vector3_array_write : #type proc "c" (p_self : ^PoolVector3Array) -> ^PoolVector3ArrayWriteAccess,
    godot_pool_vector3_array_set : #type proc "c" (p_self : ^PoolVector3Array, p_idx : _c.int, p_data : ^Vector3),
    godot_pool_vector3_array_get : #type proc "c" (p_self : ^PoolVector3Array, p_idx : _c.int) -> Vector3,
    godot_pool_vector3_array_size : #type proc "c" (p_self : ^PoolVector3Array) -> _c.int,
    godot_pool_vector3_array_destroy : #type proc "c" (p_self : ^PoolVector3Array),
    godot_pool_color_array_new : #type proc "c" (r_dest : ^PoolColorArray),
    godot_pool_color_array_new_copy : #type proc "c" (r_dest : ^PoolColorArray, p_src : ^PoolColorArray),
    godot_pool_color_array_new_with_array : #type proc "c" (r_dest : ^PoolColorArray, p_a : ^Array),
    godot_pool_color_array_append : #type proc "c" (p_self : ^PoolColorArray, p_data : ^Color),
    godot_pool_color_array_append_array : #type proc "c" (p_self : ^PoolColorArray, p_array : ^PoolColorArray),
    godot_pool_color_array_insert : #type proc "c" (p_self : ^PoolColorArray, p_idx : _c.int, p_data : ^Color) -> Error,
    godot_pool_color_array_invert : #type proc "c" (p_self : ^PoolColorArray),
    godot_pool_color_array_push_back : #type proc "c" (p_self : ^PoolColorArray, p_data : ^Color),
    godot_pool_color_array_remove : #type proc "c" (p_self : ^PoolColorArray, p_idx : _c.int),
    godot_pool_color_array_resize : #type proc "c" (p_self : ^PoolColorArray, p_size : _c.int),
    godot_pool_color_array_read : #type proc "c" (p_self : ^PoolColorArray) -> ^PoolColorArrayReadAccess,
    godot_pool_color_array_write : #type proc "c" (p_self : ^PoolColorArray) -> ^PoolColorArrayWriteAccess,
    godot_pool_color_array_set : #type proc "c" (p_self : ^PoolColorArray, p_idx : _c.int, p_data : ^Color),
    godot_pool_color_array_get : #type proc "c" (p_self : ^PoolColorArray, p_idx : _c.int) -> Color,
    godot_pool_color_array_size : #type proc "c" (p_self : ^PoolColorArray) -> _c.int,
    godot_pool_color_array_destroy : #type proc "c" (p_self : ^PoolColorArray),
    godot_pool_byte_array_read_access_copy : #type proc "c" (p_read : ^PoolByteArrayReadAccess) -> ^PoolByteArrayReadAccess,
    godot_pool_byte_array_read_access_ptr : #type proc "c" (p_read : ^PoolByteArrayReadAccess) -> ^u8,
    godot_pool_byte_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolByteArrayReadAccess, p_other : ^PoolByteArrayReadAccess),
    godot_pool_byte_array_read_access_destroy : #type proc "c" (p_read : ^PoolByteArrayReadAccess),
    godot_pool_int_array_read_access_copy : #type proc "c" (p_read : ^PoolIntArrayReadAccess) -> ^PoolIntArrayReadAccess,
    godot_pool_int_array_read_access_ptr : #type proc "c" (p_read : ^PoolIntArrayReadAccess) -> ^_c.int,
    godot_pool_int_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolIntArrayReadAccess, p_other : ^PoolIntArrayReadAccess),
    godot_pool_int_array_read_access_destroy : #type proc "c" (p_read : ^PoolIntArrayReadAccess),
    godot_pool_real_array_read_access_copy : #type proc "c" (p_read : ^PoolRealArrayReadAccess) -> ^PoolRealArrayReadAccess,
    godot_pool_real_array_read_access_ptr : #type proc "c" (p_read : ^PoolRealArrayReadAccess) -> ^_c.float,
    godot_pool_real_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolRealArrayReadAccess, p_other : ^PoolRealArrayReadAccess),
    godot_pool_real_array_read_access_destroy : #type proc "c" (p_read : ^PoolRealArrayReadAccess),
    godot_pool_string_array_read_access_copy : #type proc "c" (p_read : ^PoolStringArrayReadAccess) -> ^PoolStringArrayReadAccess,
    godot_pool_string_array_read_access_ptr : #type proc "c" (p_read : ^PoolStringArrayReadAccess) -> ^String,
    godot_pool_string_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolStringArrayReadAccess, p_other : ^PoolStringArrayReadAccess),
    godot_pool_string_array_read_access_destroy : #type proc "c" (p_read : ^PoolStringArrayReadAccess),
    godot_pool_vector2_array_read_access_copy : #type proc "c" (p_read : ^PoolVector2ArrayReadAccess) -> ^PoolVector2ArrayReadAccess,
    godot_pool_vector2_array_read_access_ptr : #type proc "c" (p_read : ^PoolVector2ArrayReadAccess) -> ^Vector2,
    godot_pool_vector2_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolVector2ArrayReadAccess, p_other : ^PoolVector2ArrayReadAccess),
    godot_pool_vector2_array_read_access_destroy : #type proc "c" (p_read : ^PoolVector2ArrayReadAccess),
    godot_pool_vector3_array_read_access_copy : #type proc "c" (p_read : ^PoolVector3ArrayReadAccess) -> ^PoolVector3ArrayReadAccess,
    godot_pool_vector3_array_read_access_ptr : #type proc "c" (p_read : ^PoolVector3ArrayReadAccess) -> ^Vector3,
    godot_pool_vector3_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolVector3ArrayReadAccess, p_other : ^PoolVector3ArrayReadAccess),
    godot_pool_vector3_array_read_access_destroy : #type proc "c" (p_read : ^PoolVector3ArrayReadAccess),
    godot_pool_color_array_read_access_copy : #type proc "c" (p_read : ^PoolColorArrayReadAccess) -> ^PoolColorArrayReadAccess,
    godot_pool_color_array_read_access_ptr : #type proc "c" (p_read : ^PoolColorArrayReadAccess) -> ^Color,
    godot_pool_color_array_read_access_operator_assign : #type proc "c" (p_read : ^PoolColorArrayReadAccess, p_other : ^PoolColorArrayReadAccess),
    godot_pool_color_array_read_access_destroy : #type proc "c" (p_read : ^PoolColorArrayReadAccess),
    godot_pool_byte_array_write_access_copy : #type proc "c" (p_write : ^PoolByteArrayWriteAccess) -> ^PoolByteArrayWriteAccess,
    godot_pool_byte_array_write_access_ptr : #type proc "c" (p_write : ^PoolByteArrayWriteAccess) -> ^u8,
    godot_pool_byte_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolByteArrayWriteAccess, p_other : ^PoolByteArrayWriteAccess),
    godot_pool_byte_array_write_access_destroy : #type proc "c" (p_write : ^PoolByteArrayWriteAccess),
    godot_pool_int_array_write_access_copy : #type proc "c" (p_write : ^PoolIntArrayWriteAccess) -> ^PoolIntArrayWriteAccess,
    godot_pool_int_array_write_access_ptr : #type proc "c" (p_write : ^PoolIntArrayWriteAccess) -> ^_c.int,
    godot_pool_int_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolIntArrayWriteAccess, p_other : ^PoolIntArrayWriteAccess),
    godot_pool_int_array_write_access_destroy : #type proc "c" (p_write : ^PoolIntArrayWriteAccess),
    godot_pool_real_array_write_access_copy : #type proc "c" (p_write : ^PoolRealArrayWriteAccess) -> ^PoolRealArrayWriteAccess,
    godot_pool_real_array_write_access_ptr : #type proc "c" (p_write : ^PoolRealArrayWriteAccess) -> ^_c.float,
    godot_pool_real_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolRealArrayWriteAccess, p_other : ^PoolRealArrayWriteAccess),
    godot_pool_real_array_write_access_destroy : #type proc "c" (p_write : ^PoolRealArrayWriteAccess),
    godot_pool_string_array_write_access_copy : #type proc "c" (p_write : ^PoolStringArrayWriteAccess) -> ^PoolStringArrayWriteAccess,
    godot_pool_string_array_write_access_ptr : #type proc "c" (p_write : ^PoolStringArrayWriteAccess) -> ^String,
    godot_pool_string_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolStringArrayWriteAccess, p_other : ^PoolStringArrayWriteAccess),
    godot_pool_string_array_write_access_destroy : #type proc "c" (p_write : ^PoolStringArrayWriteAccess),
    godot_pool_vector2_array_write_access_copy : #type proc "c" (p_write : ^PoolVector2ArrayWriteAccess) -> ^PoolVector2ArrayWriteAccess,
    godot_pool_vector2_array_write_access_ptr : #type proc "c" (p_write : ^PoolVector2ArrayWriteAccess) -> ^Vector2,
    godot_pool_vector2_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolVector2ArrayWriteAccess, p_other : ^PoolVector2ArrayWriteAccess),
    godot_pool_vector2_array_write_access_destroy : #type proc "c" (p_write : ^PoolVector2ArrayWriteAccess),
    godot_pool_vector3_array_write_access_copy : #type proc "c" (p_write : ^PoolVector3ArrayWriteAccess) -> ^PoolVector3ArrayWriteAccess,
    godot_pool_vector3_array_write_access_ptr : #type proc "c" (p_write : ^PoolVector3ArrayWriteAccess) -> ^Vector3,
    godot_pool_vector3_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolVector3ArrayWriteAccess, p_other : ^PoolVector3ArrayWriteAccess),
    godot_pool_vector3_array_write_access_destroy : #type proc "c" (p_write : ^PoolVector3ArrayWriteAccess),
    godot_pool_color_array_write_access_copy : #type proc "c" (p_write : ^PoolColorArrayWriteAccess) -> ^PoolColorArrayWriteAccess,
    godot_pool_color_array_write_access_ptr : #type proc "c" (p_write : ^PoolColorArrayWriteAccess) -> ^Color,
    godot_pool_color_array_write_access_operator_assign : #type proc "c" (p_write : ^PoolColorArrayWriteAccess, p_other : ^PoolColorArrayWriteAccess),
    godot_pool_color_array_write_access_destroy : #type proc "c" (p_write : ^PoolColorArrayWriteAccess),
    godot_array_new : #type proc "c" (r_dest : ^Array),
    godot_array_new_copy : #type proc "c" (r_dest : ^Array, p_src : ^Array),
    godot_array_new_pool_color_array : #type proc "c" (r_dest : ^Array, p_pca : ^PoolColorArray),
    godot_array_new_pool_vector3_array : #type proc "c" (r_dest : ^Array, p_pv3a : ^PoolVector3Array),
    godot_array_new_pool_vector2_array : #type proc "c" (r_dest : ^Array, p_pv2a : ^PoolVector2Array),
    godot_array_new_pool_string_array : #type proc "c" (r_dest : ^Array, p_psa : ^PoolStringArray),
    godot_array_new_pool_real_array : #type proc "c" (r_dest : ^Array, p_pra : ^PoolRealArray),
    godot_array_new_pool_int_array : #type proc "c" (r_dest : ^Array, p_pia : ^PoolIntArray),
    godot_array_new_pool_byte_array : #type proc "c" (r_dest : ^Array, p_pba : ^PoolByteArray),
    godot_array_set : #type proc "c" (p_self : ^Array, p_idx : _c.int, p_value : ^Variant),
    godot_array_get : #type proc "c" (p_self : ^Array, p_idx : _c.int) -> Variant,
    godot_array_operator_index : #type proc "c" (p_self : ^Array, p_idx : _c.int) -> ^Variant,
    godot_array_operator_index_const : #type proc "c" (p_self : ^Array, p_idx : _c.int) -> ^Variant,
    godot_array_append : #type proc "c" (p_self : ^Array, p_value : ^Variant),
    godot_array_clear : #type proc "c" (p_self : ^Array),
    godot_array_count : #type proc "c" (p_self : ^Array, p_value : ^Variant) -> _c.int,
    godot_array_empty : #type proc "c" (p_self : ^Array) -> Bool,
    godot_array_erase : #type proc "c" (p_self : ^Array, p_value : ^Variant),
    godot_array_front : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_back : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_find : #type proc "c" (p_self : ^Array, p_what : ^Variant, p_from : _c.int) -> _c.int,
    godot_array_find_last : #type proc "c" (p_self : ^Array, p_what : ^Variant) -> _c.int,
    godot_array_has : #type proc "c" (p_self : ^Array, p_value : ^Variant) -> Bool,
    godot_array_hash : #type proc "c" (p_self : ^Array) -> _c.int,
    godot_array_insert : #type proc "c" (p_self : ^Array, p_pos : _c.int, p_value : ^Variant),
    godot_array_invert : #type proc "c" (p_self : ^Array),
    godot_array_pop_back : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_pop_front : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_push_back : #type proc "c" (p_self : ^Array, p_value : ^Variant),
    godot_array_push_front : #type proc "c" (p_self : ^Array, p_value : ^Variant),
    godot_array_remove : #type proc "c" (p_self : ^Array, p_idx : _c.int),
    godot_array_resize : #type proc "c" (p_self : ^Array, p_size : _c.int),
    godot_array_rfind : #type proc "c" (p_self : ^Array, p_what : ^Variant, p_from : _c.int) -> _c.int,
    godot_array_size : #type proc "c" (p_self : ^Array) -> _c.int,
    godot_array_sort : #type proc "c" (p_self : ^Array),
    godot_array_sort_custom : #type proc "c" (p_self : ^Array, p_obj : rawptr, p_func : ^String),
    godot_array_bsearch : #type proc "c" (p_self : ^Array, p_value : ^Variant, p_before : Bool) -> _c.int,
    godot_array_bsearch_custom : #type proc "c" (p_self : ^Array, p_value : ^Variant, p_obj : rawptr, p_func : ^String, p_before : Bool) -> _c.int,
    godot_array_destroy : #type proc "c" (p_self : ^Array),
    godot_dictionary_new : #type proc "c" (r_dest : ^Dictionary),
    godot_dictionary_new_copy : #type proc "c" (r_dest : ^Dictionary, p_src : ^Dictionary),
    godot_dictionary_destroy : #type proc "c" (p_self : ^Dictionary),
    godot_dictionary_size : #type proc "c" (p_self : ^Dictionary) -> _c.int,
    godot_dictionary_empty : #type proc "c" (p_self : ^Dictionary) -> Bool,
    godot_dictionary_clear : #type proc "c" (p_self : ^Dictionary),
    godot_dictionary_has : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> Bool,
    godot_dictionary_has_all : #type proc "c" (p_self : ^Dictionary, p_keys : ^Array) -> Bool,
    godot_dictionary_erase : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant),
    godot_dictionary_hash : #type proc "c" (p_self : ^Dictionary) -> _c.int,
    godot_dictionary_keys : #type proc "c" (p_self : ^Dictionary) -> Array,
    godot_dictionary_values : #type proc "c" (p_self : ^Dictionary) -> Array,
    godot_dictionary_get : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> Variant,
    godot_dictionary_set : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant, p_value : ^Variant),
    godot_dictionary_operator_index : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> ^Variant,
    godot_dictionary_operator_index_const : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> ^Variant,
    godot_dictionary_next : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> ^Variant,
    godot_dictionary_operator_equal : #type proc "c" (p_self : ^Dictionary, p_b : ^Dictionary) -> Bool,
    godot_dictionary_to_json : #type proc "c" (p_self : ^Dictionary) -> String,
    godot_node_path_new : #type proc "c" (r_dest : ^NodePath, p_from : ^String),
    godot_node_path_new_copy : #type proc "c" (r_dest : ^NodePath, p_src : ^NodePath),
    godot_node_path_destroy : #type proc "c" (p_self : ^NodePath),
    godot_node_path_as_string : #type proc "c" (p_self : ^NodePath) -> String,
    godot_node_path_is_absolute : #type proc "c" (p_self : ^NodePath) -> Bool,
    godot_node_path_get_name_count : #type proc "c" (p_self : ^NodePath) -> _c.int,
    godot_node_path_get_name : #type proc "c" (p_self : ^NodePath, p_idx : _c.int) -> String,
    godot_node_path_get_subname_count : #type proc "c" (p_self : ^NodePath) -> _c.int,
    godot_node_path_get_subname : #type proc "c" (p_self : ^NodePath, p_idx : _c.int) -> String,
    godot_node_path_get_concatenated_subnames : #type proc "c" (p_self : ^NodePath) -> String,
    godot_node_path_is_empty : #type proc "c" (p_self : ^NodePath) -> Bool,
    godot_node_path_operator_equal : #type proc "c" (p_self : ^NodePath, p_b : ^NodePath) -> Bool,
    godot_plane_new_with_reals : #type proc "c" (r_dest : ^Plane, p_a : _c.float, p_b : _c.float, p_c : _c.float, p_d : _c.float),
    godot_plane_new_with_vectors : #type proc "c" (r_dest : ^Plane, p_v1 : ^Vector3, p_v2 : ^Vector3, p_v3 : ^Vector3),
    godot_plane_new_with_normal : #type proc "c" (r_dest : ^Plane, p_normal : ^Vector3, p_d : _c.float),
    godot_plane_as_string : #type proc "c" (p_self : ^Plane) -> String,
    godot_plane_normalized : #type proc "c" (p_self : ^Plane) -> Plane,
    godot_plane_center : #type proc "c" (p_self : ^Plane) -> Vector3,
    godot_plane_get_any_point : #type proc "c" (p_self : ^Plane) -> Vector3,
    godot_plane_is_point_over : #type proc "c" (p_self : ^Plane, p_point : ^Vector3) -> Bool,
    godot_plane_distance_to : #type proc "c" (p_self : ^Plane, p_point : ^Vector3) -> _c.float,
    godot_plane_has_point : #type proc "c" (p_self : ^Plane, p_point : ^Vector3, p_epsilon : _c.float) -> Bool,
    godot_plane_project : #type proc "c" (p_self : ^Plane, p_point : ^Vector3) -> Vector3,
    godot_plane_intersect_3 : #type proc "c" (p_self : ^Plane, r_dest : ^Vector3, p_b : ^Plane, p_c : ^Plane) -> Bool,
    godot_plane_intersects_ray : #type proc "c" (p_self : ^Plane, r_dest : ^Vector3, p_from : ^Vector3, p_dir : ^Vector3) -> Bool,
    godot_plane_intersects_segment : #type proc "c" (p_self : ^Plane, r_dest : ^Vector3, p_begin : ^Vector3, p_end : ^Vector3) -> Bool,
    godot_plane_operator_neg : #type proc "c" (p_self : ^Plane) -> Plane,
    godot_plane_operator_equal : #type proc "c" (p_self : ^Plane, p_b : ^Plane) -> Bool,
    godot_plane_set_normal : #type proc "c" (p_self : ^Plane, p_normal : ^Vector3),
    godot_plane_get_normal : #type proc "c" (p_self : ^Plane) -> Vector3,
    godot_plane_get_d : #type proc "c" (p_self : ^Plane) -> _c.float,
    godot_plane_set_d : #type proc "c" (p_self : ^Plane, p_d : _c.float),
    godot_rect2_new_with_position_and_size : #type proc "c" (r_dest : ^Rect2, p_pos : ^Vector2, p_size : ^Vector2),
    godot_rect2_new : #type proc "c" (r_dest : ^Rect2, p_x : _c.float, p_y : _c.float, p_width : _c.float, p_height : _c.float),
    godot_rect2_as_string : #type proc "c" (p_self : ^Rect2) -> String,
    godot_rect2_get_area : #type proc "c" (p_self : ^Rect2) -> _c.float,
    godot_rect2_intersects : #type proc "c" (p_self : ^Rect2, p_b : ^Rect2) -> Bool,
    godot_rect2_encloses : #type proc "c" (p_self : ^Rect2, p_b : ^Rect2) -> Bool,
    godot_rect2_has_no_area : #type proc "c" (p_self : ^Rect2) -> Bool,
    godot_rect2_clip : #type proc "c" (p_self : ^Rect2, p_b : ^Rect2) -> Rect2,
    godot_rect2_merge : #type proc "c" (p_self : ^Rect2, p_b : ^Rect2) -> Rect2,
    godot_rect2_has_point : #type proc "c" (p_self : ^Rect2, p_point : ^Vector2) -> Bool,
    godot_rect2_grow : #type proc "c" (p_self : ^Rect2, p_by : _c.float) -> Rect2,
    godot_rect2_expand : #type proc "c" (p_self : ^Rect2, p_to : ^Vector2) -> Rect2,
    godot_rect2_operator_equal : #type proc "c" (p_self : ^Rect2, p_b : ^Rect2) -> Bool,
    godot_rect2_get_position : #type proc "c" (p_self : ^Rect2) -> Vector2,
    godot_rect2_get_size : #type proc "c" (p_self : ^Rect2) -> Vector2,
    godot_rect2_set_position : #type proc "c" (p_self : ^Rect2, p_pos : ^Vector2),
    godot_rect2_set_size : #type proc "c" (p_self : ^Rect2, p_size : ^Vector2),
    godot_aabb_new : #type proc "c" (r_dest : ^Aabb, p_pos : ^Vector3, p_size : ^Vector3),
    godot_aabb_get_position : #type proc "c" (p_self : ^Aabb) -> Vector3,
    godot_aabb_set_position : #type proc "c" (p_self : ^Aabb, p_v : ^Vector3),
    godot_aabb_get_size : #type proc "c" (p_self : ^Aabb) -> Vector3,
    godot_aabb_set_size : #type proc "c" (p_self : ^Aabb, p_v : ^Vector3),
    godot_aabb_as_string : #type proc "c" (p_self : ^Aabb) -> String,
    godot_aabb_get_area : #type proc "c" (p_self : ^Aabb) -> _c.float,
    godot_aabb_has_no_area : #type proc "c" (p_self : ^Aabb) -> Bool,
    godot_aabb_has_no_surface : #type proc "c" (p_self : ^Aabb) -> Bool,
    godot_aabb_intersects : #type proc "c" (p_self : ^Aabb, p_with : ^Aabb) -> Bool,
    godot_aabb_encloses : #type proc "c" (p_self : ^Aabb, p_with : ^Aabb) -> Bool,
    godot_aabb_merge : #type proc "c" (p_self : ^Aabb, p_with : ^Aabb) -> Aabb,
    godot_aabb_intersection : #type proc "c" (p_self : ^Aabb, p_with : ^Aabb) -> Aabb,
    godot_aabb_intersects_plane : #type proc "c" (p_self : ^Aabb, p_plane : ^Plane) -> Bool,
    godot_aabb_intersects_segment : #type proc "c" (p_self : ^Aabb, p_from : ^Vector3, p_to : ^Vector3) -> Bool,
    godot_aabb_has_point : #type proc "c" (p_self : ^Aabb, p_point : ^Vector3) -> Bool,
    godot_aabb_get_support : #type proc "c" (p_self : ^Aabb, p_dir : ^Vector3) -> Vector3,
    godot_aabb_get_longest_axis : #type proc "c" (p_self : ^Aabb) -> Vector3,
    godot_aabb_get_longest_axis_index : #type proc "c" (p_self : ^Aabb) -> _c.int,
    godot_aabb_get_longest_axis_size : #type proc "c" (p_self : ^Aabb) -> _c.float,
    godot_aabb_get_shortest_axis : #type proc "c" (p_self : ^Aabb) -> Vector3,
    godot_aabb_get_shortest_axis_index : #type proc "c" (p_self : ^Aabb) -> _c.int,
    godot_aabb_get_shortest_axis_size : #type proc "c" (p_self : ^Aabb) -> _c.float,
    godot_aabb_expand : #type proc "c" (p_self : ^Aabb, p_to_point : ^Vector3) -> Aabb,
    godot_aabb_grow : #type proc "c" (p_self : ^Aabb, p_by : _c.float) -> Aabb,
    godot_aabb_get_endpoint : #type proc "c" (p_self : ^Aabb, p_idx : _c.int) -> Vector3,
    godot_aabb_operator_equal : #type proc "c" (p_self : ^Aabb, p_b : ^Aabb) -> Bool,
    godot_rid_new : #type proc "c" (r_dest : ^Rid),
    godot_rid_get_id : #type proc "c" (p_self : ^Rid) -> _c.int,
    godot_rid_new_with_resource : #type proc "c" (r_dest : ^Rid, p_from : rawptr),
    godot_rid_operator_equal : #type proc "c" (p_self : ^Rid, p_b : ^Rid) -> Bool,
    godot_rid_operator_less : #type proc "c" (p_self : ^Rid, p_b : ^Rid) -> Bool,
    godot_transform_new_with_axis_origin : #type proc "c" (r_dest : ^Transform, p_x_axis : ^Vector3, p_y_axis : ^Vector3, p_z_axis : ^Vector3, p_origin : ^Vector3),
    godot_transform_new : #type proc "c" (r_dest : ^Transform, p_basis : ^Basis, p_origin : ^Vector3),
    godot_transform_get_basis : #type proc "c" (p_self : ^Transform) -> Basis,
    godot_transform_set_basis : #type proc "c" (p_self : ^Transform, p_v : ^Basis),
    godot_transform_get_origin : #type proc "c" (p_self : ^Transform) -> Vector3,
    godot_transform_set_origin : #type proc "c" (p_self : ^Transform, p_v : ^Vector3),
    godot_transform_as_string : #type proc "c" (p_self : ^Transform) -> String,
    godot_transform_inverse : #type proc "c" (p_self : ^Transform) -> Transform,
    godot_transform_affine_inverse : #type proc "c" (p_self : ^Transform) -> Transform,
    godot_transform_orthonormalized : #type proc "c" (p_self : ^Transform) -> Transform,
    godot_transform_rotated : #type proc "c" (p_self : ^Transform, p_axis : ^Vector3, p_phi : _c.float) -> Transform,
    godot_transform_scaled : #type proc "c" (p_self : ^Transform, p_scale : ^Vector3) -> Transform,
    godot_transform_translated : #type proc "c" (p_self : ^Transform, p_ofs : ^Vector3) -> Transform,
    godot_transform_looking_at : #type proc "c" (p_self : ^Transform, p_target : ^Vector3, p_up : ^Vector3) -> Transform,
    godot_transform_xform_plane : #type proc "c" (p_self : ^Transform, p_v : ^Plane) -> Plane,
    godot_transform_xform_inv_plane : #type proc "c" (p_self : ^Transform, p_v : ^Plane) -> Plane,
    godot_transform_new_identity : #type proc "c" (r_dest : ^Transform),
    godot_transform_operator_equal : #type proc "c" (p_self : ^Transform, p_b : ^Transform) -> Bool,
    godot_transform_operator_multiply : #type proc "c" (p_self : ^Transform, p_b : ^Transform) -> Transform,
    godot_transform_xform_vector3 : #type proc "c" (p_self : ^Transform, p_v : ^Vector3) -> Vector3,
    godot_transform_xform_inv_vector3 : #type proc "c" (p_self : ^Transform, p_v : ^Vector3) -> Vector3,
    godot_transform_xform_aabb : #type proc "c" (p_self : ^Transform, p_v : ^Aabb) -> Aabb,
    godot_transform_xform_inv_aabb : #type proc "c" (p_self : ^Transform, p_v : ^Aabb) -> Aabb,
    godot_transform2d_new : #type proc "c" (r_dest : ^Transform2D, p_rot : _c.float, p_pos : ^Vector2),
    godot_transform2d_new_axis_origin : #type proc "c" (r_dest : ^Transform2D, p_x_axis : ^Vector2, p_y_axis : ^Vector2, p_origin : ^Vector2),
    godot_transform2d_as_string : #type proc "c" (p_self : ^Transform2D) -> String,
    godot_transform2d_inverse : #type proc "c" (p_self : ^Transform2D) -> Transform2D,
    godot_transform2d_affine_inverse : #type proc "c" (p_self : ^Transform2D) -> Transform2D,
    godot_transform2d_get_rotation : #type proc "c" (p_self : ^Transform2D) -> _c.float,
    godot_transform2d_get_origin : #type proc "c" (p_self : ^Transform2D) -> Vector2,
    godot_transform2d_get_scale : #type proc "c" (p_self : ^Transform2D) -> Vector2,
    godot_transform2d_orthonormalized : #type proc "c" (p_self : ^Transform2D) -> Transform2D,
    godot_transform2d_rotated : #type proc "c" (p_self : ^Transform2D, p_phi : _c.float) -> Transform2D,
    godot_transform2d_scaled : #type proc "c" (p_self : ^Transform2D, p_scale : ^Vector2) -> Transform2D,
    godot_transform2d_translated : #type proc "c" (p_self : ^Transform2D, p_offset : ^Vector2) -> Transform2D,
    godot_transform2d_xform_vector2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Vector2) -> Vector2,
    godot_transform2d_xform_inv_vector2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Vector2) -> Vector2,
    godot_transform2d_basis_xform_vector2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Vector2) -> Vector2,
    godot_transform2d_basis_xform_inv_vector2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Vector2) -> Vector2,
    godot_transform2d_interpolate_with : #type proc "c" (p_self : ^Transform2D, p_m : ^Transform2D, p_c : _c.float) -> Transform2D,
    godot_transform2d_operator_equal : #type proc "c" (p_self : ^Transform2D, p_b : ^Transform2D) -> Bool,
    godot_transform2d_operator_multiply : #type proc "c" (p_self : ^Transform2D, p_b : ^Transform2D) -> Transform2D,
    godot_transform2d_new_identity : #type proc "c" (r_dest : ^Transform2D),
    godot_transform2d_xform_rect2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Rect2) -> Rect2,
    godot_transform2d_xform_inv_rect2 : #type proc "c" (p_self : ^Transform2D, p_v : ^Rect2) -> Rect2,
    godot_variant_get_type : #type proc "c" (p_v : ^Variant) -> VariantType,
    godot_variant_new_copy : #type proc "c" (r_dest : ^Variant, p_src : ^Variant),
    godot_variant_new_nil : #type proc "c" (r_dest : ^Variant),
    godot_variant_new_bool : #type proc "c" (r_dest : ^Variant, p_b : Bool),
    godot_variant_new_uint : #type proc "c" (r_dest : ^Variant, p_i : u64),
    godot_variant_new_int : #type proc "c" (r_dest : ^Variant, p_i : i64),
    godot_variant_new_real : #type proc "c" (r_dest : ^Variant, p_r : _c.double),
    godot_variant_new_string : #type proc "c" (r_dest : ^Variant, p_s : ^String),
    godot_variant_new_vector2 : #type proc "c" (r_dest : ^Variant, p_v2 : ^Vector2),
    godot_variant_new_rect2 : #type proc "c" (r_dest : ^Variant, p_rect2 : ^Rect2),
    godot_variant_new_vector3 : #type proc "c" (r_dest : ^Variant, p_v3 : ^Vector3),
    godot_variant_new_transform2d : #type proc "c" (r_dest : ^Variant, p_t2d : ^Transform2D),
    godot_variant_new_plane : #type proc "c" (r_dest : ^Variant, p_plane : ^Plane),
    godot_variant_new_quat : #type proc "c" (r_dest : ^Variant, p_quat : ^Quat),
    godot_variant_new_aabb : #type proc "c" (r_dest : ^Variant, p_aabb : ^Aabb),
    godot_variant_new_basis : #type proc "c" (r_dest : ^Variant, p_basis : ^Basis),
    godot_variant_new_transform : #type proc "c" (r_dest : ^Variant, p_trans : ^Transform),
    godot_variant_new_color : #type proc "c" (r_dest : ^Variant, p_color : ^Color),
    godot_variant_new_node_path : #type proc "c" (r_dest : ^Variant, p_np : ^NodePath),
    godot_variant_new_rid : #type proc "c" (r_dest : ^Variant, p_rid : ^Rid),
    godot_variant_new_object : #type proc "c" (r_dest : ^Variant, p_obj : rawptr),
    godot_variant_new_dictionary : #type proc "c" (r_dest : ^Variant, p_dict : ^Dictionary),
    godot_variant_new_array : #type proc "c" (r_dest : ^Variant, p_arr : ^Array),
    godot_variant_new_pool_byte_array : #type proc "c" (r_dest : ^Variant, p_pba : ^PoolByteArray),
    godot_variant_new_pool_int_array : #type proc "c" (r_dest : ^Variant, p_pia : ^PoolIntArray),
    godot_variant_new_pool_real_array : #type proc "c" (r_dest : ^Variant, p_pra : ^PoolRealArray),
    godot_variant_new_pool_string_array : #type proc "c" (r_dest : ^Variant, p_psa : ^PoolStringArray),
    godot_variant_new_pool_vector2_array : #type proc "c" (r_dest : ^Variant, p_pv2a : ^PoolVector2Array),
    godot_variant_new_pool_vector3_array : #type proc "c" (r_dest : ^Variant, p_pv3a : ^PoolVector3Array),
    godot_variant_new_pool_color_array : #type proc "c" (r_dest : ^Variant, p_pca : ^PoolColorArray),
    godot_variant_as_bool : #type proc "c" (p_self : ^Variant) -> Bool,
    godot_variant_as_uint : #type proc "c" (p_self : ^Variant) -> u64,
    godot_variant_as_int : #type proc "c" (p_self : ^Variant) -> i64,
    godot_variant_as_real : #type proc "c" (p_self : ^Variant) -> _c.double,
    godot_variant_as_string : #type proc "c" (p_self : ^Variant) -> String,
    godot_variant_as_vector2 : #type proc "c" (p_self : ^Variant) -> Vector2,
    godot_variant_as_rect2 : #type proc "c" (p_self : ^Variant) -> Rect2,
    godot_variant_as_vector3 : #type proc "c" (p_self : ^Variant) -> Vector3,
    godot_variant_as_transform2d : #type proc "c" (p_self : ^Variant) -> Transform2D,
    godot_variant_as_plane : #type proc "c" (p_self : ^Variant) -> Plane,
    godot_variant_as_quat : #type proc "c" (p_self : ^Variant) -> Quat,
    godot_variant_as_aabb : #type proc "c" (p_self : ^Variant) -> Aabb,
    godot_variant_as_basis : #type proc "c" (p_self : ^Variant) -> Basis,
    godot_variant_as_transform : #type proc "c" (p_self : ^Variant) -> Transform,
    godot_variant_as_color : #type proc "c" (p_self : ^Variant) -> Color,
    godot_variant_as_node_path : #type proc "c" (p_self : ^Variant) -> NodePath,
    godot_variant_as_rid : #type proc "c" (p_self : ^Variant) -> Rid,
    godot_variant_as_object : #type proc "c" (p_self : ^Variant) -> rawptr,
    godot_variant_as_dictionary : #type proc "c" (p_self : ^Variant) -> Dictionary,
    godot_variant_as_array : #type proc "c" (p_self : ^Variant) -> Array,
    godot_variant_as_pool_byte_array : #type proc "c" (p_self : ^Variant) -> PoolByteArray,
    godot_variant_as_pool_int_array : #type proc "c" (p_self : ^Variant) -> PoolIntArray,
    godot_variant_as_pool_real_array : #type proc "c" (p_self : ^Variant) -> PoolRealArray,
    godot_variant_as_pool_string_array : #type proc "c" (p_self : ^Variant) -> PoolStringArray,
    godot_variant_as_pool_vector2_array : #type proc "c" (p_self : ^Variant) -> PoolVector2Array,
    godot_variant_as_pool_vector3_array : #type proc "c" (p_self : ^Variant) -> PoolVector3Array,
    godot_variant_as_pool_color_array : #type proc "c" (p_self : ^Variant) -> PoolColorArray,
    godot_variant_call : #type proc "c" (p_self : ^Variant, p_method : ^String, p_args : ^^Variant, p_argcount : _c.int, r_error : ^VariantCallError) -> Variant,
    godot_variant_has_method : #type proc "c" (p_self : ^Variant, p_method : ^String) -> Bool,
    godot_variant_operator_equal : #type proc "c" (p_self : ^Variant, p_other : ^Variant) -> Bool,
    godot_variant_operator_less : #type proc "c" (p_self : ^Variant, p_other : ^Variant) -> Bool,
    godot_variant_hash_compare : #type proc "c" (p_self : ^Variant, p_other : ^Variant) -> Bool,
    godot_variant_booleanize : #type proc "c" (p_self : ^Variant) -> Bool,
    godot_variant_destroy : #type proc "c" (p_self : ^Variant),
    godot_char_string_length : #type proc "c" (p_cs : ^CharString) -> _c.int,
    godot_char_string_get_data : #type proc "c" (p_cs : ^CharString) -> cstring,
    godot_char_string_destroy : #type proc "c" (p_cs : ^CharString),
    godot_string_new : #type proc "c" (r_dest : ^String),
    godot_string_new_copy : #type proc "c" (r_dest : ^String, p_src : ^String),
    godot_string_new_with_wide_string : #type proc "c" (r_dest : ^String, p_contents : ^_c.wchar_t, p_size : _c.int),
    godot_string_operator_index : #type proc "c" (p_self : ^String, p_idx : _c.int) -> ^_c.wchar_t,
    godot_string_operator_index_const : #type proc "c" (p_self : ^String, p_idx : _c.int) -> _c.wchar_t,
    godot_string_wide_str : #type proc "c" (p_self : ^String) -> ^_c.wchar_t,
    godot_string_operator_equal : #type proc "c" (p_self : ^String, p_b : ^String) -> Bool,
    godot_string_operator_less : #type proc "c" (p_self : ^String, p_b : ^String) -> Bool,
    godot_string_operator_plus : #type proc "c" (p_self : ^String, p_b : ^String) -> String,
    godot_string_length : #type proc "c" (p_self : ^String) -> _c.int,
    godot_string_casecmp_to : #type proc "c" (p_self : ^String, p_str : ^String) -> _c.schar,
    godot_string_nocasecmp_to : #type proc "c" (p_self : ^String, p_str : ^String) -> _c.schar,
    godot_string_naturalnocasecmp_to : #type proc "c" (p_self : ^String, p_str : ^String) -> _c.schar,
    godot_string_begins_with : #type proc "c" (p_self : ^String, p_string : ^String) -> Bool,
    godot_string_begins_with_char_array : #type proc "c" (p_self : ^String, p_char_array : cstring) -> Bool,
    godot_string_bigrams : #type proc "c" (p_self : ^String) -> Array,
    godot_string_chr : #type proc "c" (p_character : _c.wchar_t) -> String,
    godot_string_ends_with : #type proc "c" (p_self : ^String, p_string : ^String) -> Bool,
    godot_string_find : #type proc "c" (p_self : ^String, p_what : String) -> _c.int,
    godot_string_find_from : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int) -> _c.int,
    godot_string_findmk : #type proc "c" (p_self : ^String, p_keys : ^Array) -> _c.int,
    godot_string_findmk_from : #type proc "c" (p_self : ^String, p_keys : ^Array, p_from : _c.int) -> _c.int,
    godot_string_findmk_from_in_place : #type proc "c" (p_self : ^String, p_keys : ^Array, p_from : _c.int, r_key : ^_c.int) -> _c.int,
    godot_string_findn : #type proc "c" (p_self : ^String, p_what : String) -> _c.int,
    godot_string_findn_from : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int) -> _c.int,
    godot_string_find_last : #type proc "c" (p_self : ^String, p_what : String) -> _c.int,
    godot_string_format : #type proc "c" (p_self : ^String, p_values : ^Variant) -> String,
    godot_string_format_with_custom_placeholder : #type proc "c" (p_self : ^String, p_values : ^Variant, p_placeholder : cstring) -> String,
    godot_string_hex_encode_buffer : #type proc "c" (p_buffer : ^u8, p_len : _c.int) -> String,
    godot_string_hex_to_int : #type proc "c" (p_self : ^String) -> _c.int,
    godot_string_hex_to_int_without_prefix : #type proc "c" (p_self : ^String) -> _c.int,
    godot_string_insert : #type proc "c" (p_self : ^String, p_at_pos : _c.int, p_string : String) -> String,
    godot_string_is_numeric : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_subsequence_of : #type proc "c" (p_self : ^String, p_string : ^String) -> Bool,
    godot_string_is_subsequence_ofi : #type proc "c" (p_self : ^String, p_string : ^String) -> Bool,
    godot_string_lpad : #type proc "c" (p_self : ^String, p_min_length : _c.int) -> String,
    godot_string_lpad_with_custom_character : #type proc "c" (p_self : ^String, p_min_length : _c.int, p_character : ^String) -> String,
    godot_string_match : #type proc "c" (p_self : ^String, p_wildcard : ^String) -> Bool,
    godot_string_matchn : #type proc "c" (p_self : ^String, p_wildcard : ^String) -> Bool,
    godot_string_md5 : #type proc "c" (p_md5 : ^u8) -> String,
    godot_string_num : #type proc "c" (p_num : _c.double) -> String,
    godot_string_num_int64 : #type proc "c" (p_num : i64, p_base : _c.int) -> String,
    godot_string_num_int64_capitalized : #type proc "c" (p_num : i64, p_base : _c.int, p_capitalize_hex : Bool) -> String,
    godot_string_num_real : #type proc "c" (p_num : _c.double) -> String,
    godot_string_num_scientific : #type proc "c" (p_num : _c.double) -> String,
    godot_string_num_with_decimals : #type proc "c" (p_num : _c.double, p_decimals : _c.int) -> String,
    godot_string_pad_decimals : #type proc "c" (p_self : ^String, p_digits : _c.int) -> String,
    godot_string_pad_zeros : #type proc "c" (p_self : ^String, p_digits : _c.int) -> String,
    godot_string_replace_first : #type proc "c" (p_self : ^String, p_key : String, p_with : String) -> String,
    godot_string_replace : #type proc "c" (p_self : ^String, p_key : String, p_with : String) -> String,
    godot_string_replacen : #type proc "c" (p_self : ^String, p_key : String, p_with : String) -> String,
    godot_string_rfind : #type proc "c" (p_self : ^String, p_what : String) -> _c.int,
    godot_string_rfindn : #type proc "c" (p_self : ^String, p_what : String) -> _c.int,
    godot_string_rfind_from : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int) -> _c.int,
    godot_string_rfindn_from : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int) -> _c.int,
    godot_string_rpad : #type proc "c" (p_self : ^String, p_min_length : _c.int) -> String,
    godot_string_rpad_with_custom_character : #type proc "c" (p_self : ^String, p_min_length : _c.int, p_character : ^String) -> String,
    godot_string_similarity : #type proc "c" (p_self : ^String, p_string : ^String) -> _c.float,
    godot_string_sprintf : #type proc "c" (p_self : ^String, p_values : ^Array, p_error : ^Bool) -> String,
    godot_string_substr : #type proc "c" (p_self : ^String, p_from : _c.int, p_chars : _c.int) -> String,
    godot_string_to_double : #type proc "c" (p_self : ^String) -> _c.double,
    godot_string_to_float : #type proc "c" (p_self : ^String) -> _c.float,
    godot_string_to_int : #type proc "c" (p_self : ^String) -> _c.int,
    godot_string_camelcase_to_underscore : #type proc "c" (p_self : ^String) -> String,
    godot_string_camelcase_to_underscore_lowercased : #type proc "c" (p_self : ^String) -> String,
    godot_string_capitalize : #type proc "c" (p_self : ^String) -> String,
    godot_string_char_to_double : #type proc "c" (p_what : cstring) -> _c.double,
    godot_string_char_to_int : #type proc "c" (p_what : cstring) -> _c.int,
    godot_string_wchar_to_int : #type proc "c" (p_str : ^_c.wchar_t) -> i64,
    godot_string_char_to_int_with_len : #type proc "c" (p_what : cstring, p_len : _c.int) -> _c.int,
    godot_string_char_to_int64_with_len : #type proc "c" (p_str : ^_c.wchar_t, p_len : _c.int) -> i64,
    godot_string_hex_to_int64 : #type proc "c" (p_self : ^String) -> i64,
    godot_string_hex_to_int64_with_prefix : #type proc "c" (p_self : ^String) -> i64,
    godot_string_to_int64 : #type proc "c" (p_self : ^String) -> i64,
    godot_string_unicode_char_to_double : #type proc "c" (p_str : ^_c.wchar_t, r_end : ^^_c.wchar_t) -> _c.double,
    godot_string_get_slice_count : #type proc "c" (p_self : ^String, p_splitter : String) -> _c.int,
    godot_string_get_slice : #type proc "c" (p_self : ^String, p_splitter : String, p_slice : _c.int) -> String,
    godot_string_get_slicec : #type proc "c" (p_self : ^String, p_splitter : _c.wchar_t, p_slice : _c.int) -> String,
    godot_string_split : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_allow_empty : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_floats : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_floats_allows_empty : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_floats_mk : #type proc "c" (p_self : ^String, p_splitters : ^Array) -> Array,
    godot_string_split_floats_mk_allows_empty : #type proc "c" (p_self : ^String, p_splitters : ^Array) -> Array,
    godot_string_split_ints : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_ints_allows_empty : #type proc "c" (p_self : ^String, p_splitter : ^String) -> Array,
    godot_string_split_ints_mk : #type proc "c" (p_self : ^String, p_splitters : ^Array) -> Array,
    godot_string_split_ints_mk_allows_empty : #type proc "c" (p_self : ^String, p_splitters : ^Array) -> Array,
    godot_string_split_spaces : #type proc "c" (p_self : ^String) -> Array,
    godot_string_char_lowercase : #type proc "c" (p_char : _c.wchar_t) -> _c.wchar_t,
    godot_string_char_uppercase : #type proc "c" (p_char : _c.wchar_t) -> _c.wchar_t,
    godot_string_to_lower : #type proc "c" (p_self : ^String) -> String,
    godot_string_to_upper : #type proc "c" (p_self : ^String) -> String,
    godot_string_get_basename : #type proc "c" (p_self : ^String) -> String,
    godot_string_get_extension : #type proc "c" (p_self : ^String) -> String,
    godot_string_left : #type proc "c" (p_self : ^String, p_pos : _c.int) -> String,
    godot_string_ord_at : #type proc "c" (p_self : ^String, p_idx : _c.int) -> _c.wchar_t,
    godot_string_plus_file : #type proc "c" (p_self : ^String, p_file : ^String) -> String,
    godot_string_right : #type proc "c" (p_self : ^String, p_pos : _c.int) -> String,
    godot_string_strip_edges : #type proc "c" (p_self : ^String, p_left : Bool, p_right : Bool) -> String,
    godot_string_strip_escapes : #type proc "c" (p_self : ^String) -> String,
    godot_string_erase : #type proc "c" (p_self : ^String, p_pos : _c.int, p_chars : _c.int),
    godot_string_ascii : #type proc "c" (p_self : ^String) -> CharString,
    godot_string_ascii_extended : #type proc "c" (p_self : ^String) -> CharString,
    godot_string_utf8 : #type proc "c" (p_self : ^String) -> CharString,
    godot_string_parse_utf8 : #type proc "c" (p_self : ^String, p_utf8 : cstring) -> Bool,
    godot_string_parse_utf8_with_len : #type proc "c" (p_self : ^String, p_utf8 : cstring, p_len : _c.int) -> Bool,
    godot_string_chars_to_utf8 : #type proc "c" (p_utf8 : cstring) -> String,
    godot_string_chars_to_utf8_with_len : #type proc "c" (p_utf8 : cstring, p_len : _c.int) -> String,
    godot_string_hash : #type proc "c" (p_self : ^String) -> u32,
    godot_string_hash64 : #type proc "c" (p_self : ^String) -> u64,
    godot_string_hash_chars : #type proc "c" (p_cstr : cstring) -> u32,
    godot_string_hash_chars_with_len : #type proc "c" (p_cstr : cstring, p_len : _c.int) -> u32,
    godot_string_hash_utf8_chars : #type proc "c" (p_str : ^_c.wchar_t) -> u32,
    godot_string_hash_utf8_chars_with_len : #type proc "c" (p_str : ^_c.wchar_t, p_len : _c.int) -> u32,
    godot_string_md5_buffer : #type proc "c" (p_self : ^String) -> PoolByteArray,
    godot_string_md5_text : #type proc "c" (p_self : ^String) -> String,
    godot_string_sha256_buffer : #type proc "c" (p_self : ^String) -> PoolByteArray,
    godot_string_sha256_text : #type proc "c" (p_self : ^String) -> String,
    godot_string_empty : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_get_base_dir : #type proc "c" (p_self : ^String) -> String,
    godot_string_get_file : #type proc "c" (p_self : ^String) -> String,
    godot_string_humanize_size : #type proc "c" (p_size : u64) -> String,
    godot_string_is_abs_path : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_rel_path : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_resource_file : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_path_to : #type proc "c" (p_self : ^String, p_path : ^String) -> String,
    godot_string_path_to_file : #type proc "c" (p_self : ^String, p_path : ^String) -> String,
    godot_string_simplify_path : #type proc "c" (p_self : ^String) -> String,
    godot_string_c_escape : #type proc "c" (p_self : ^String) -> String,
    godot_string_c_escape_multiline : #type proc "c" (p_self : ^String) -> String,
    godot_string_c_unescape : #type proc "c" (p_self : ^String) -> String,
    godot_string_http_escape : #type proc "c" (p_self : ^String) -> String,
    godot_string_http_unescape : #type proc "c" (p_self : ^String) -> String,
    godot_string_json_escape : #type proc "c" (p_self : ^String) -> String,
    godot_string_word_wrap : #type proc "c" (p_self : ^String, p_chars_per_line : _c.int) -> String,
    godot_string_xml_escape : #type proc "c" (p_self : ^String) -> String,
    godot_string_xml_escape_with_quotes : #type proc "c" (p_self : ^String) -> String,
    godot_string_xml_unescape : #type proc "c" (p_self : ^String) -> String,
    godot_string_percent_decode : #type proc "c" (p_self : ^String) -> String,
    godot_string_percent_encode : #type proc "c" (p_self : ^String) -> String,
    godot_string_is_valid_float : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_valid_hex_number : #type proc "c" (p_self : ^String, p_with_prefix : Bool) -> Bool,
    godot_string_is_valid_html_color : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_valid_identifier : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_valid_integer : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_is_valid_ip_address : #type proc "c" (p_self : ^String) -> Bool,
    godot_string_destroy : #type proc "c" (p_self : ^String),
    godot_string_name_new : #type proc "c" (r_dest : ^StringName, p_name : ^String),
    godot_string_name_new_data : #type proc "c" (r_dest : ^StringName, p_name : cstring),
    godot_string_name_get_name : #type proc "c" (p_self : ^StringName) -> String,
    godot_string_name_get_hash : #type proc "c" (p_self : ^StringName) -> u32,
    godot_string_name_get_data_unique_pointer : #type proc "c" (p_self : ^StringName) -> rawptr,
    godot_string_name_operator_equal : #type proc "c" (p_self : ^StringName, p_other : ^StringName) -> Bool,
    godot_string_name_operator_less : #type proc "c" (p_self : ^StringName, p_other : ^StringName) -> Bool,
    godot_string_name_destroy : #type proc "c" (p_self : ^StringName),
    godot_object_destroy : #type proc "c" (p_o : rawptr),
    godot_global_get_singleton : #type proc "c" (p_name : cstring) -> rawptr,
    godot_method_bind_get_method : #type proc "c" (p_classname : cstring, p_methodname : cstring) -> ^MethodBind,
    godot_method_bind_ptrcall : #type proc "c" (p_method_bind : ^MethodBind, p_instance : rawptr, p_args : ^rawptr, p_ret : rawptr),
    godot_method_bind_call : #type proc "c" (p_method_bind : ^MethodBind, p_instance : rawptr, p_args : ^^Variant, p_arg_count : _c.int, p_call_error : ^VariantCallError) -> Variant,
    godot_get_class_constructor : #type proc "c" (p_classname : cstring) -> ClassConstructor,
    godot_get_global_constants : #type proc "c" () -> Dictionary,
    godot_register_native_call_type : #type proc "c" (call_type : cstring, p_callback : NativeCallCb),
    godot_alloc : #type proc "c" (p_bytes : _c.int) -> rawptr,
    godot_realloc : #type proc "c" (p_ptr : rawptr, p_bytes : _c.int) -> rawptr,
    godot_free : #type proc "c" (p_ptr : rawptr),
    godot_print_error : #type proc "c" (p_description : cstring, p_function : cstring, p_file : cstring, p_line : _c.int),
    godot_print_warning : #type proc "c" (p_description : cstring, p_function : cstring, p_file : cstring, p_line : _c.int),
    godot_print : #type proc "c" (p_message : ^String),
};

GdnativeInitOptions :: struct {
    in_editor : Bool,
    core_api_hash : u64,
    editor_api_hash : u64,
    no_api_hash : u64,
    report_version_mismatch : #type proc "c" (p_library : rawptr, p_what : cstring, p_want : GdnativeApiVersion, p_have : GdnativeApiVersion),
    report_loading_error : #type proc "c" (p_library : rawptr, p_what : cstring),
    gd_native_library : rawptr,
    api_struct : ^GdnativeCoreApiStruct,
    active_library_path : ^String,
};

GdnativeTerminateOptions :: struct {
    in_editor : Bool,
};

NodePath :: struct {
    dont_touch_that : [1]u8,
};

Plane :: struct {
    dont_touch_that : [16]u8,
};

PoolArrayReadAccess :: struct {
    dont_touch_that : [1]u8,
};

PoolArrayWriteAccess :: struct {
    dont_touch_that : [1]u8,
};

PoolByteArray :: struct {
    dont_touch_that : [1]u8,
};

PoolIntArray :: struct {
    dont_touch_that : [1]u8,
};

PoolRealArray :: struct {
    dont_touch_that : [1]u8,
};

PoolStringArray :: struct {
    dont_touch_that : [1]u8,
};

PoolVector2Array :: struct {
    dont_touch_that : [1]u8,
};

PoolVector3Array :: struct {
    dont_touch_that : [1]u8,
};

PoolColorArray :: struct {
    dont_touch_that : [1]u8,
};

Quat :: struct {
    dont_touch_that : [16]u8,
};

Rect2 :: struct {
    dont_touch_that : [16]u8,
};

Rid :: struct {
    dont_touch_that : [1]u8,
};

StringName :: struct {
    dont_touch_that : [1]u8,
};

String :: struct {
    dont_touch_that : [1]u8,
};

CharString :: struct {
    dont_touch_that : [1]u8,
};

Transform2D :: struct {
    dont_touch_that : [24]u8,
};

Transform :: struct {
    dont_touch_that : [48]u8,
};

Variant :: struct {
    dont_touch_that : [17]u8,
};

VariantCallError :: struct {
    error : VariantCallErrorError,
    argument : _c.int,
    expected : VariantType,
};

Vector2 :: struct {
    dont_touch_that : [8]u8,
};

Vector3 :: struct {
    dont_touch_that : [12]u8,
};

GdnativeExtNativescript1_1ApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_nativescript_set_method_argument_information : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_function_name : cstring, p_num_args : _c.int, p_args : ^MethodArg),
    godot_nativescript_set_class_documentation : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_documentation : String),
    godot_nativescript_set_method_documentation : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_function_name : cstring, p_documentation : String),
    godot_nativescript_set_property_documentation : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_path : cstring, p_documentation : String),
    godot_nativescript_set_signal_documentation : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_signal_name : cstring, p_documentation : String),
    godot_nativescript_set_global_type_tag : #type proc "c" (p_idx : _c.int, p_name : cstring, p_type_tag : rawptr),
    godot_nativescript_get_global_type_tag : #type proc "c" (p_idx : _c.int, p_name : cstring) -> rawptr,
    godot_nativescript_set_type_tag : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_type_tag : rawptr),
    godot_nativescript_get_type_tag : #type proc "c" (p_object : rawptr) -> rawptr,
    godot_nativescript_register_instance_binding_data_functions : #type proc "c" (p_binding_functions : InstanceBindingFunctions) -> _c.int,
    godot_nativescript_unregister_instance_binding_data_functions : #type proc "c" (p_idx : _c.int),
    godot_nativescript_get_instance_binding_data : #type proc "c" (p_idx : _c.int, p_object : rawptr) -> rawptr,
    godot_nativescript_profiling_add_data : #type proc "c" (p_signature : cstring, p_line : u64),
};

GdnativeExtNativescriptApiStruct :: struct {
    type : GdnativeApiTypes,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_nativescript_register_class : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_base : cstring, p_create_func : InstanceCreateFunc, p_destroy_func : InstanceDestroyFunc),
    godot_nativescript_register_tool_class : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_base : cstring, p_create_func : InstanceCreateFunc, p_destroy_func : InstanceDestroyFunc),
    godot_nativescript_register_method : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_function_name : cstring, p_attr : MethodAttributes, p_method : InstanceMethod),
    godot_nativescript_register_property : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_path : cstring, p_attr : ^PropertyAttributes, p_set_func : PropertySetFunc, p_get_func : PropertyGetFunc),
    godot_nativescript_register_signal : #type proc "c" (p_gdnative_handle : rawptr, p_name : cstring, p_signal : ^Signal),
    godot_nativescript_get_userdata : #type proc "c" (p_instance : rawptr) -> rawptr,
};

GdnativeExtPluginscriptApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_pluginscript_register_language : #type proc "c" (language_desc : ^PluginscriptLanguageDesc),
};

GdnativeExtAndroidApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_android_get_env : #type proc "c" () -> rawptr,
    godot_android_get_activity : #type proc "c" () -> rawptr,
    godot_android_get_surface : #type proc "c" () -> rawptr,
    godot_android_is_activity_resumed : #type proc "c" () -> Bool,
};

GdnativeExtArvr1_2ApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_arvr_set_interface : #type proc "c" (p_arvr_interface : rawptr, p_gdn_interface : ^ArvrInterfaceGdnative),
    godot_arvr_get_depthid : #type proc "c" (p_render_target : ^Rid) -> _c.int,
};

GdnativeExtArvrApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_arvr_register_interface : #type proc "c" (p_interface : ^ArvrInterfaceGdnative),
    godot_arvr_get_worldscale : #type proc "c" () -> _c.float,
    godot_arvr_get_reference_frame : #type proc "c" () -> Transform,
    godot_arvr_blit : #type proc "c" (p_eye : _c.int, p_render_target : ^Rid, p_screen_rect : ^Rect2),
    godot_arvr_get_texid : #type proc "c" (p_render_target : ^Rid) -> _c.int,
    godot_arvr_add_controller : #type proc "c" (p_device_name : cstring, p_hand : _c.int, p_tracks_orientation : Bool, p_tracks_position : Bool) -> _c.int,
    godot_arvr_remove_controller : #type proc "c" (p_controller_id : _c.int),
    godot_arvr_set_controller_transform : #type proc "c" (p_controller_id : _c.int, p_transform : ^Transform, p_tracks_orientation : Bool, p_tracks_position : Bool),
    godot_arvr_set_controller_button : #type proc "c" (p_controller_id : _c.int, p_button : _c.int, p_is_pressed : Bool),
    godot_arvr_set_controller_axis : #type proc "c" (p_controller_id : _c.int, p_exis : _c.int, p_value : _c.float, p_can_be_negative : Bool),
    godot_arvr_get_controller_rumble : #type proc "c" (p_controller_id : _c.int) -> _c.float,
};

GdnativeExtVideodecoderApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_videodecoder_file_read : #type proc "c" (file_ptr : rawptr, buf : ^u8, buf_size : _c.int) -> _c.int,
    godot_videodecoder_file_seek : #type proc "c" (file_ptr : rawptr, pos : i64, whence : _c.int) -> i64,
    godot_videodecoder_register_decoder : #type proc "c" (p_interface : ^VideodecoderInterfaceGdnative),
};

GdnativeExtNet3_2ApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_net_set_webrtc_library : #type proc "c" (p_library : ^NetWebrtcLibrary) -> Error,
    godot_net_bind_webrtc_peer_connection : #type proc "c" (p_obj : rawptr, p_interface : ^NetWebrtcPeerConnection),
    godot_net_bind_webrtc_data_channel : #type proc "c" (p_obj : rawptr, p_interface : ^NetWebrtcDataChannel),
};

GdnativeExtNetApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_net_bind_stream_peer : #type proc "c" (p_obj : rawptr, p_interface : ^NetStreamPeer),
    godot_net_bind_packet_peer : #type proc "c" (p_obj : rawptr, p_interface : ^NetPacketPeer),
    godot_net_bind_multiplayer_peer : #type proc "c" (p_obj : rawptr, p_interface : ^NetMultiplayerPeer),
};

GdnativeCore1_2ApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_dictionary_duplicate : #type proc "c" (p_self : ^Dictionary, p_deep : Bool) -> Dictionary,
    godot_vector3_move_toward : #type proc "c" (p_self : ^Vector3, p_to : ^Vector3, p_delta : _c.float) -> Vector3,
    godot_vector2_move_toward : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2, p_delta : _c.float) -> Vector2,
    godot_string_count : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int, p_to : _c.int) -> _c.int,
    godot_string_countn : #type proc "c" (p_self : ^String, p_what : String, p_from : _c.int, p_to : _c.int) -> _c.int,
    godot_vector3_direction_to : #type proc "c" (p_self : ^Vector3, p_to : ^Vector3) -> Vector3,
    godot_vector2_direction_to : #type proc "c" (p_self : ^Vector2, p_to : ^Vector2) -> Vector2,
    godot_array_slice : #type proc "c" (p_self : ^Array, p_begin : _c.int, p_end : _c.int, p_step : _c.int, p_deep : Bool) -> Array,
    godot_pool_byte_array_empty : #type proc "c" (p_self : ^PoolByteArray) -> Bool,
    godot_pool_int_array_empty : #type proc "c" (p_self : ^PoolIntArray) -> Bool,
    godot_pool_real_array_empty : #type proc "c" (p_self : ^PoolRealArray) -> Bool,
    godot_pool_string_array_empty : #type proc "c" (p_self : ^PoolStringArray) -> Bool,
    godot_pool_vector2_array_empty : #type proc "c" (p_self : ^PoolVector2Array) -> Bool,
    godot_pool_vector3_array_empty : #type proc "c" (p_self : ^PoolVector3Array) -> Bool,
    godot_pool_color_array_empty : #type proc "c" (p_self : ^PoolColorArray) -> Bool,
    godot_get_class_tag : #type proc "c" (p_class : ^StringName) -> rawptr,
    godot_object_cast_to : #type proc "c" (p_object : rawptr, p_class_tag : rawptr) -> rawptr,
    godot_instance_from_id : #type proc "c" (p_instance_id : _c.int) -> rawptr,
};

GdnativeCore1_1ApiStruct :: struct {
    type : _c.uint,
    version : GdnativeApiVersion,
    next : ^GdnativeApiStruct,
    godot_color_to_abgr32 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_to_abgr64 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_to_argb64 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_to_rgba64 : #type proc "c" (p_self : ^Color) -> _c.int,
    godot_color_darkened : #type proc "c" (p_self : ^Color, p_amount : _c.float) -> Color,
    godot_color_from_hsv : #type proc "c" (p_self : ^Color, p_h : _c.float, p_s : _c.float, p_v : _c.float, p_a : _c.float) -> Color,
    godot_color_lightened : #type proc "c" (p_self : ^Color, p_amount : _c.float) -> Color,
    godot_array_duplicate : #type proc "c" (p_self : ^Array, p_deep : Bool) -> Array,
    godot_array_max : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_min : #type proc "c" (p_self : ^Array) -> Variant,
    godot_array_shuffle : #type proc "c" (p_self : ^Array),
    godot_basis_slerp : #type proc "c" (p_self : ^Basis, p_b : ^Basis, p_t : _c.float) -> Basis,
    godot_dictionary_get_with_default : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant, p_default : ^Variant) -> Variant,
    godot_dictionary_erase_with_return : #type proc "c" (p_self : ^Dictionary, p_key : ^Variant) -> Bool,
    godot_node_path_get_as_property_path : #type proc "c" (p_self : ^NodePath) -> NodePath,
    godot_quat_set_axis_angle : #type proc "c" (p_self : ^Quat, p_axis : ^Vector3, p_angle : _c.float),
    godot_rect2_grow_individual : #type proc "c" (p_self : ^Rect2, p_left : _c.float, p_top : _c.float, p_right : _c.float, p_bottom : _c.float) -> Rect2,
    godot_rect2_grow_margin : #type proc "c" (p_self : ^Rect2, p_margin : _c.int, p_by : _c.float) -> Rect2,
    godot_rect2_abs : #type proc "c" (p_self : ^Rect2) -> Rect2,
    godot_string_dedent : #type proc "c" (p_self : ^String) -> String,
    godot_string_trim_prefix : #type proc "c" (p_self : ^String, p_prefix : ^String) -> String,
    godot_string_trim_suffix : #type proc "c" (p_self : ^String, p_suffix : ^String) -> String,
    godot_string_rstrip : #type proc "c" (p_self : ^String, p_chars : ^String) -> String,
    godot_string_rsplit : #type proc "c" (p_self : ^String, p_divisor : ^String, p_allow_empty : Bool, p_maxsplit : _c.int) -> PoolStringArray,
    godot_basis_get_quat : #type proc "c" (p_self : ^Basis) -> Quat,
    godot_basis_set_quat : #type proc "c" (p_self : ^Basis, p_quat : ^Quat),
    godot_basis_set_axis_angle_scale : #type proc "c" (p_self : ^Basis, p_axis : ^Vector3, p_phi : _c.float, p_scale : ^Vector3),
    godot_basis_set_euler_scale : #type proc "c" (p_self : ^Basis, p_euler : ^Vector3, p_scale : ^Vector3),
    godot_basis_set_quat_scale : #type proc "c" (p_self : ^Basis, p_quat : ^Quat, p_scale : ^Vector3),
    godot_is_instance_valid : #type proc "c" (p_object : rawptr) -> Bool,
    godot_quat_new_with_basis : #type proc "c" (r_dest : ^Quat, p_basis : ^Basis),
    godot_quat_new_with_euler : #type proc "c" (r_dest : ^Quat, p_euler : ^Vector3),
    godot_transform_new_with_quat : #type proc "c" (r_dest : ^Transform, p_quat : ^Quat),
    godot_variant_get_operator_name : #type proc "c" (p_op : VariantOperator) -> String,
    godot_variant_evaluate : #type proc "c" (p_op : VariantOperator, p_a : ^Variant, p_b : ^Variant, r_ret : ^Variant, r_valid : ^Bool),
};

PropertyAttributes :: struct {
    rset_type : MethodRpcMode,
    type : _c.int,
    hint : PropertyHint,
    hint_string : String,
    usage : PropertyUsageFlags,
    default_value : Variant,
};

InstanceCreateFunc :: struct {
    create_func : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr) -> rawptr,
    method_data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

InstanceDestroyFunc :: struct {
    destroy_func : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr, unamed2 : rawptr),
    method_data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

MethodAttributes :: struct {
    rpc_type : MethodRpcMode,
};

InstanceMethod :: struct {
    method : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr, unamed2 : rawptr, unamed3 : _c.int, unamed4 : [^]Variant) -> Variant,
    method_data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

PropertySetFunc :: struct {
    set_func : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr, unamed2 : rawptr, unamed3 : ^Variant),
    method_data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

PropertyGetFunc :: struct {
    get_func : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr, unamed2 : rawptr) -> Variant,
    method_data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

SignalArgument :: struct {
    name : String,
    type : _c.int,
    hint : PropertyHint,
    hint_string : String,
    usage : PropertyUsageFlags,
    default_value : Variant,
};

Signal :: struct {
    name : String,
    num_args : _c.int,
    args : ^SignalArgument,
    num_default_args : _c.int,
    default_args : ^Variant,
};

MethodArg :: struct {
    name : String,
    type : VariantType,
    hint : PropertyHint,
    hint_string : String,
};

InstanceBindingFunctions :: struct {
    alloc_instance_binding_data : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr, unamed2 : rawptr) -> rawptr,
    free_instance_binding_data : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr),
    refcount_incremented_instance_binding : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr),
    refcount_decremented_instance_binding : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr) -> Bool,
    data : rawptr,
    free_func : #type proc "c" (unamed0 : rawptr),
};

NetStreamPeer :: struct {
    version : GdnativeApiVersion,
    data : rawptr,
    get_data : #type proc "c" (user : rawptr, p_buffer : ^u8, p_bytes : _c.int) -> Error,
    get_partial_data : #type proc "c" (user : rawptr, p_buffer : ^u8, p_bytes : _c.int, r_received : ^_c.int) -> Error,
    put_data : #type proc "c" (user : rawptr, p_data : ^u8, p_bytes : _c.int) -> Error,
    put_partial_data : #type proc "c" (user : rawptr, p_data : ^u8, p_bytes : _c.int, r_sent : ^_c.int) -> Error,
    get_available_bytes : #type proc "c" (user : rawptr) -> _c.int,
    next : rawptr,
};

NetPacketPeer :: struct {
    version : GdnativeApiVersion,
    data : rawptr,
    get_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^^u8, unamed2 : ^_c.int) -> Error,
    put_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^u8, unamed2 : _c.int) -> Error,
    get_available_packet_count : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_max_packet_size : #type proc "c" (unamed0 : rawptr) -> _c.int,
    next : rawptr,
};

NetMultiplayerPeer :: struct {
    version : GdnativeApiVersion,
    data : rawptr,
    get_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^^u8, unamed2 : ^_c.int) -> Error,
    put_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^u8, unamed2 : _c.int) -> Error,
    get_available_packet_count : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_max_packet_size : #type proc "c" (unamed0 : rawptr) -> _c.int,
    set_transfer_mode : #type proc "c" (unamed0 : rawptr, unamed1 : _c.int),
    get_transfer_mode : #type proc "c" (unamed0 : rawptr) -> _c.int,
    set_target_peer : #type proc "c" (unamed0 : rawptr, unamed1 : _c.int),
    get_packet_peer : #type proc "c" (unamed0 : rawptr) -> _c.int,
    is_server : #type proc "c" (unamed0 : rawptr) -> Bool,
    poll : #type proc "c" (unamed0 : rawptr),
    get_unique_id : #type proc "c" (unamed0 : rawptr) -> i32,
    set_refuse_new_connections : #type proc "c" (unamed0 : rawptr, unamed1 : Bool),
    is_refusing_new_connections : #type proc "c" (unamed0 : rawptr) -> Bool,
    get_connection_status : #type proc "c" (unamed0 : rawptr) -> _c.int,
    next : rawptr,
};

NetWebrtcLibrary :: struct {
    version : GdnativeApiVersion,
    unregistered : #type proc "c" (),
    create_peer_connection : #type proc "c" (unamed0 : rawptr) -> Error,
    next : rawptr,
};

NetWebrtcPeerConnection :: struct {
    version : GdnativeApiVersion,
    data : rawptr,
    get_connection_state : #type proc "c" (unamed0 : rawptr) -> _c.int,
    initialize : #type proc "c" (unamed0 : rawptr, unamed1 : ^Dictionary) -> Error,
    create_data_channel : #type proc "c" (unamed0 : rawptr, p_channel_name : cstring, unamed1 : ^Dictionary) -> rawptr,
    create_offer : #type proc "c" (unamed0 : rawptr) -> Error,
    create_answer : #type proc "c" (unamed0 : rawptr) -> Error,
    set_remote_description : #type proc "c" (unamed0 : rawptr, unamed1 : cstring, unamed2 : cstring) -> Error,
    set_local_description : #type proc "c" (unamed0 : rawptr, unamed1 : cstring, unamed2 : cstring) -> Error,
    add_ice_candidate : #type proc "c" (unamed0 : rawptr, unamed1 : cstring, unamed2 : _c.int, unamed3 : cstring) -> Error,
    poll : #type proc "c" (unamed0 : rawptr) -> Error,
    close : #type proc "c" (unamed0 : rawptr),
    next : rawptr,
};

NetWebrtcDataChannel :: struct {
    version : GdnativeApiVersion,
    data : rawptr,
    get_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^^u8, unamed2 : ^_c.int) -> Error,
    put_packet : #type proc "c" (unamed0 : rawptr, unamed1 : ^u8, unamed2 : _c.int) -> Error,
    get_available_packet_count : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_max_packet_size : #type proc "c" (unamed0 : rawptr) -> _c.int,
    set_write_mode : #type proc "c" (unamed0 : rawptr, unamed1 : _c.int),
    get_write_mode : #type proc "c" (unamed0 : rawptr) -> _c.int,
    was_string_packet : #type proc "c" (unamed0 : rawptr) -> Bool,
    get_ready_state : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_label : #type proc "c" (unamed0 : rawptr) -> cstring,
    is_ordered : #type proc "c" (unamed0 : rawptr) -> Bool,
    get_id : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_max_packet_life_time : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_max_retransmits : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_protocol : #type proc "c" (unamed0 : rawptr) -> cstring,
    is_negotiated : #type proc "c" (unamed0 : rawptr) -> Bool,
    poll : #type proc "c" (unamed0 : rawptr) -> Error,
    close : #type proc "c" (unamed0 : rawptr),
    next : rawptr,
};

NetWebrtcDataChannelExt :: struct {
    get_buffered_amount : #type proc "c" (unamed0 : rawptr) -> _c.int,
    next : rawptr,
};

PluginscriptInstanceDesc :: struct {
    init : #type proc "c" (p_data : rawptr, p_owner : rawptr) -> rawptr,
    finish : #type proc "c" (p_data : rawptr),
    set_prop : #type proc "c" (p_data : rawptr, p_name : ^String, p_value : ^Variant) -> Bool,
    get_prop : #type proc "c" (p_data : rawptr, p_name : ^String, r_ret : ^Variant) -> Bool,
    call_method : #type proc "c" (p_data : rawptr, p_method : ^StringName, p_args : ^^Variant, p_argcount : _c.int, r_error : ^VariantCallError) -> Variant,
    notification : #type proc "c" (p_data : rawptr, p_notification : _c.int),
    get_rpc_mode : #type proc "c" (p_data : rawptr, p_method : ^String) -> MethodRpcMode,
    get_rset_mode : #type proc "c" (p_data : rawptr, p_variable : ^String) -> MethodRpcMode,
    refcount_incremented : #type proc "c" (p_data : rawptr),
    refcount_decremented : #type proc "c" (p_data : rawptr) -> Bool,
};

PluginscriptScriptManifest :: struct {
    data : rawptr,
    name : StringName,
    is_tool : Bool,
    base : StringName,
    member_lines : Dictionary,
    methods : Array,
    signals : Array,
    properties : Array,
};

PluginscriptScriptDesc :: struct {
    init : #type proc "c" (p_data : rawptr, p_path : ^String, p_source : ^String, r_error : ^Error) -> PluginscriptScriptManifest,
    finish : #type proc "c" (p_data : rawptr),
    instance_desc : PluginscriptInstanceDesc,
};

PluginscriptProfilingData :: struct {
    signature : StringName,
    call_count : _c.int,
    total_time : _c.int,
    self_time : _c.int,
};

PluginscriptLanguageDesc :: struct {
    name : cstring,
    type : cstring,
    extension : cstring,
    recognized_extensions : ^cstring,
    init : #type proc "c" () -> rawptr,
    finish : #type proc "c" (p_data : rawptr),
    reserved_words : ^cstring,
    comment_delimiters : ^cstring,
    string_delimiters : ^cstring,
    has_named_classes : Bool,
    supports_builtin_mode : Bool,
    get_template_source_code : #type proc "c" (p_data : rawptr, p_class_name : ^String, p_base_class_name : ^String) -> String,
    validate : #type proc "c" (p_data : rawptr, p_script : ^String, r_line_error : ^_c.int, r_col_error : ^_c.int, r_test_error : ^String, p_path : ^String, r_functions : ^PoolStringArray) -> Bool,
    find_function : #type proc "c" (p_data : rawptr, p_function : ^String, p_code : ^String) -> _c.int,
    make_function : #type proc "c" (p_data : rawptr, p_class : ^String, p_name : ^String, p_args : ^PoolStringArray) -> String,
    complete_code : #type proc "c" (p_data : rawptr, p_code : ^String, p_path : ^String, p_owner : rawptr, r_options : ^Array, r_force : ^Bool, r_call_hint : ^String) -> Error,
    auto_indent_code : #type proc "c" (p_data : rawptr, p_code : ^String, p_from_line : _c.int, p_to_line : _c.int),
    add_global_constant : #type proc "c" (p_data : rawptr, p_variable : ^String, p_value : ^Variant),
    debug_get_error : #type proc "c" (p_data : rawptr) -> String,
    debug_get_stack_level_count : #type proc "c" (p_data : rawptr) -> _c.int,
    debug_get_stack_level_line : #type proc "c" (p_data : rawptr, p_level : _c.int) -> _c.int,
    debug_get_stack_level_function : #type proc "c" (p_data : rawptr, p_level : _c.int) -> String,
    debug_get_stack_level_source : #type proc "c" (p_data : rawptr, p_level : _c.int) -> String,
    debug_get_stack_level_locals : #type proc "c" (p_data : rawptr, p_level : _c.int, p_locals : ^PoolStringArray, p_values : ^Array, p_max_subitems : _c.int, p_max_depth : _c.int),
    debug_get_stack_level_members : #type proc "c" (p_data : rawptr, p_level : _c.int, p_members : ^PoolStringArray, p_values : ^Array, p_max_subitems : _c.int, p_max_depth : _c.int),
    debug_get_globals : #type proc "c" (p_data : rawptr, p_locals : ^PoolStringArray, p_values : ^Array, p_max_subitems : _c.int, p_max_depth : _c.int),
    debug_parse_stack_level_expression : #type proc "c" (p_data : rawptr, p_level : _c.int, p_expression : ^String, p_max_subitems : _c.int, p_max_depth : _c.int) -> String,
    get_public_functions : #type proc "c" (p_data : rawptr, r_functions : ^Array),
    get_public_constants : #type proc "c" (p_data : rawptr, r_constants : ^Dictionary),
    profiling_start : #type proc "c" (p_data : rawptr),
    profiling_stop : #type proc "c" (p_data : rawptr),
    profiling_get_accumulated_data : #type proc "c" (p_data : rawptr, r_info : ^PluginscriptProfilingData, p_info_max : _c.int) -> _c.int,
    profiling_get_frame_data : #type proc "c" (p_data : rawptr, r_info : ^PluginscriptProfilingData, p_info_max : _c.int) -> _c.int,
    profiling_frame : #type proc "c" (p_data : rawptr),
    script_desc : PluginscriptScriptDesc,
};

VideodecoderInterfaceGdnative :: struct {
    version : GdnativeApiVersion,
    next : rawptr,
    constructor : #type proc "c" (unamed0 : rawptr) -> rawptr,
    destructor : #type proc "c" (unamed0 : rawptr),
    get_plugin_name : #type proc "c" () -> cstring,
    get_supported_extensions : #type proc "c" (count : ^_c.int) -> ^cstring,
    open_file : #type proc "c" (unamed0 : rawptr, unamed1 : rawptr) -> Bool,
    get_length : #type proc "c" (unamed0 : rawptr) -> _c.float,
    get_playback_position : #type proc "c" (unamed0 : rawptr) -> _c.float,
    seek : #type proc "c" (unamed0 : rawptr, unamed1 : _c.float),
    set_audio_track : #type proc "c" (unamed0 : rawptr, unamed1 : _c.int),
    update : #type proc "c" (unamed0 : rawptr, unamed1 : _c.float),
    get_videoframe : #type proc "c" (unamed0 : rawptr) -> ^PoolByteArray,
    get_audioframe : #type proc "c" (unamed0 : rawptr, unamed1 : ^_c.float, unamed2 : _c.int) -> _c.int,
    get_channels : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_mix_rate : #type proc "c" (unamed0 : rawptr) -> _c.int,
    get_texture_size : #type proc "c" (unamed0 : rawptr) -> Vector2,
};
    defer gd_api.godot_string_destroy(&data)
    gd_api.godot_string_parse_utf8(&data, cstr)

    gd_api.godot_print(&data)
}